b6b4cd0a4c
### Overview Major restructuring from monolithic `arcade-ai` package to modular library architecture with standardized uv-based dependency management.  ### New Package Structure - **`arcade-tdk`** - Lightweight toolkit development kit (core decorators, auth) - **`arcade-core`** - Core execution engine and catalog functionality - **`arcade-serve`** - FastAPI/MCP server components - **`arcade-ai`** - Meta package that includes CLI functionality. Optionally include evals via the `evals` extra. Optionally include all packages via the `all` extra. ### Key Benefits - **Lighter Dependencies**: Toolkits now depend only on `arcade-tdk` (~2 deps) vs full `arcade-ai` (~30+ deps) - **Faster Builds**: uv provides 10-100x faster dependency resolution and installation - **Better Modularity**: Clear separation of concerns, consumers import only what they need - **Standard Tooling**: Eliminates custom poetry scripts, uses standard Python packaging ### Migration Impact - All 20 toolkits converted from poetry → uv with `arcade-tdk` dependencies plus `arcade-ai[evals]` and `arcade-serve` dev dependencies. When developing locally, devs should install toolkits via `make install-local`. - Modern Python 3.10+ type hints throughout - Standardized build system with hatchling backend - Enhanced Makefile with robust toolkit management commands - Removed `arcade dev` CLI command - Reduce the number of files created by `arcade new` and add an option to not generate a tests and evals folder. This foundation enables faster development cycles and cleaner dependency chains for the growing toolkit ecosystem. ### Todo After this PR is merged - [ ] Post-merge workflow(s) (release & publish containers, etc) - [ ] Release order plan. @EricGustin suggests releasing in the following order: 1. `arcade-core` version 0.1.0 2. `arcade-serve` version 0.1.0 and `arcade-tdk` version 0.1.0 3. `arcade-ai` version 2.0.0 4. Patch release for all toolkits (all changes in toolkits are internal refactors) - [ ] [Update docs](https://github.com/ArcadeAI/docs/pull/318) --------- Co-authored-by: Eric Gustin <eric@arcade.dev> Co-authored-by: Eric Gustin <34000337+EricGustin@users.noreply.github.com>
76 lines
2.7 KiB
Python
76 lines
2.7 KiB
Python
from typing import Annotated
|
|
|
|
import pytest
|
|
from arcade_core.catalog import ToolCatalog, get_wire_type
|
|
from arcade_tdk import tool
|
|
|
|
|
|
class Case:
|
|
def __init__(self, input_type: type, output_type: type | None):
|
|
self.input_type = input_type
|
|
self.output_type = output_type
|
|
|
|
def __str__(self):
|
|
return f"Case(input_type={self.input_type}, output_type={self.output_type})"
|
|
|
|
|
|
primitives = [bool, float, int, str]
|
|
|
|
test_cases = [
|
|
Case(input_type=input_type, output_type=output_type)
|
|
for input_type in [*primitives, []]
|
|
for output_type in [*primitives, None]
|
|
] + [
|
|
Case(input_type=[primitives[i] for i in range(n)], output_type=output_type)
|
|
for n in range(2, len(primitives) + 1)
|
|
for output_type in [*primitives, None]
|
|
]
|
|
|
|
|
|
# Generate tool functions dynamically
|
|
def generate_tool_function(input_types: list[type], output_type: type | None):
|
|
input_annotation = ", ".join([
|
|
f"param{i}: Annotated[{input_type.__name__}, 'Param {i + 1}']"
|
|
for i, input_type in enumerate(input_types)
|
|
])
|
|
output_annotation = f" -> {output_type.__name__}" if output_type else ""
|
|
|
|
func_code = f"""
|
|
@tool(desc="Generated function with input and output types")
|
|
def generated_func({input_annotation}){output_annotation}:
|
|
pass
|
|
"""
|
|
local_vars = {}
|
|
exec(func_code, {"tool": tool, "Annotated": Annotated}, local_vars) # noqa: S102
|
|
generated_func = local_vars.get("generated_func")
|
|
generated_func.__source__ = func_code # Attach the source code to the function
|
|
return generated_func
|
|
|
|
|
|
@pytest.mark.parametrize("test_case", test_cases, ids=[str(tc) for tc in test_cases])
|
|
def test_create_tool_def2(test_case):
|
|
input_types = (
|
|
test_case.input_type if isinstance(test_case.input_type, list) else [test_case.input_type]
|
|
)
|
|
output_type = test_case.output_type
|
|
|
|
# Generate the function dynamically
|
|
generated_func = generate_tool_function(input_types, output_type)
|
|
|
|
assert generated_func is not None, "generated_func was not created"
|
|
|
|
# Create tool definition using the generated function
|
|
tool_def = ToolCatalog.create_tool_definition(generated_func, "1.0")
|
|
|
|
for i, input_type in enumerate(input_types):
|
|
param = tool_def.input.parameters[i]
|
|
assert (
|
|
param.value_schema.val_type == get_wire_type(input_type)
|
|
), f"Parameter {param.name} has value type {param.value_schema.val_type} but {input_type} was expected at index {i}"
|
|
|
|
if output_type:
|
|
assert tool_def.output.value_schema.val_type == get_wire_type(
|
|
output_type
|
|
), f"Output has value type {tool_def.output.val_type} but {output_type} was expected"
|
|
else:
|
|
assert tool_def.output.value_schema is None, "Output is not None"
|