arcade-core 2.2.0__tar.gz → 2.2.2__tar.gz

{arcade_core-2.2.0 → arcade_core-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade-core
-Version: 2.2.0
+Version: 2.2.2
 Summary: Arcade Core - Core library for Arcade platform
 Author-email: Arcade <dev@arcade.dev>
 License: MIT

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/catalog.py

@@ -4,7 +4,7 @@ import logging
 import os
 import re
 import typing
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
@@ -13,13 +13,12 @@ from types import ModuleType
 from typing import (
     Annotated,
     Any,
-    Callable,
     Literal,
-    Optional,
     Union,
     cast,
     get_args,
     get_origin,
+    get_type_hints,
 )
 
 from pydantic import BaseModel, Field, create_model
@@ -62,6 +61,28 @@ InnerWireType = Literal["string", "integer", "number", "boolean", "json"]
 WireType = Union[InnerWireType, Literal["array"]]
 
 
+def is_typeddict(tp: type) -> bool:
+    """
+    Check if a type is a TypedDict.
+    Works with both typing.TypedDict and typing_extensions.TypedDict.
+    """
+    try:
+        # TypedDict creates classes that inherit from dict
+        if not isinstance(tp, type) or not issubclass(tp, dict):
+            return False
+
+        # Check for TypedDict-specific attributes
+        return (
+            hasattr(tp, "__annotations__")
+            and hasattr(tp, "__total__")
+            and hasattr(tp, "__required_keys__")
+            and hasattr(tp, "__optional_keys__")
+        )
+    except TypeError:
+        # Some special forms raise TypeError when checking issubclass
+        return False
+
+
 @dataclass
 class WireTypeInfo:
     """
@@ -71,6 +92,9 @@ class WireTypeInfo:
     wire_type: WireType
     inner_wire_type: InnerWireType | None = None
     enum_values: list[str] | None = None
+    properties: dict[str, "WireTypeInfo"] | None = None
+    inner_properties: dict[str, "WireTypeInfo"] | None = None
+    description: str | None = None
 
 
 class ToolMeta(BaseModel):
@@ -79,9 +103,9 @@ class ToolMeta(BaseModel):
     """
 
     module: str
-    toolkit: Optional[str] = None
-    package: Optional[str] = None
-    path: Optional[str] = None
+    toolkit: str | None = None
+    package: str | None = None
+    path: str | None = None
     date_added: datetime = Field(default_factory=datetime.now)
     date_updated: datetime = Field(default_factory=datetime.now)
 
@@ -171,7 +195,7 @@ class ToolCatalog(BaseModel):
     def add_tool(
         self,
         tool_func: Callable,
-        toolkit_or_name: Union[str, Toolkit],
+        toolkit_or_name: str | Toolkit,
         module: ModuleType | None = None,
     ) -> None:
         """
@@ -289,7 +313,10 @@ class ToolCatalog(BaseModel):
         raise ValueError(f"Tool {func} not found in the catalog.")
 
     def get_tool_by_name(
-        self, name: str, version: Optional[str] = None, separator: str = TOOL_NAME_SEPARATOR
+        self,
+        name: str,
+        version: str | None = None,
+        separator: str = TOOL_NAME_SEPARATOR,
     ) -> MaterializedTool:
         """Get a tool from the catalog by name.
 
@@ -353,8 +380,8 @@ class ToolCatalog(BaseModel):
     def create_tool_definition(
         tool: Callable,
         toolkit_name: str,
-        toolkit_version: Optional[str] = None,
-        toolkit_desc: Optional[str] = None,
+        toolkit_version: str | None = None,
+        toolkit_desc: str | None = None,
     ) -> ToolDefinition:
         """
         Given a tool function, create a ToolDefinition
@@ -431,16 +458,13 @@ def create_input_definition(func: Callable) -> ToolInput:
                 description=tool_field_info.description,
                 required=is_required,
                 inferrable=tool_field_info.is_inferrable,
-                value_schema=ValueSchema(
-                    val_type=tool_field_info.wire_type_info.wire_type,
-                    inner_val_type=tool_field_info.wire_type_info.inner_wire_type,
-                    enum=tool_field_info.wire_type_info.enum_values,
-                ),
+                value_schema=wire_type_info_to_value_schema(tool_field_info.wire_type_info),
             )
         )
 
     return ToolInput(
-        parameters=input_parameters, tool_context_parameter_name=tool_context_param_name
+        parameters=input_parameters,
+        tool_context_parameter_name=tool_context_param_name,
     )
 
 
@@ -478,11 +502,7 @@ def create_output_definition(func: Callable) -> ToolOutput:
     return ToolOutput(
         description=description,
         available_modes=available_modes,
-        value_schema=ValueSchema(
-            val_type=wire_type_info.wire_type,
-            inner_val_type=wire_type_info.inner_wire_type,
-            enum=wire_type_info.enum_values,
-        ),
+        value_schema=wire_type_info_to_value_schema(wire_type_info),
     )
 
 
@@ -669,12 +689,21 @@ def get_wire_type_info(_type: type) -> WireTypeInfo:
     # Is this a list type?
     # If so, get the inner (enclosed) type
     is_list = get_origin(_type) is list
+    inner_properties = None
+
     if is_list:
         inner_type = get_args(_type)[0]
-        inner_wire_type = cast(
-            InnerWireType,
-            get_wire_type(str) if is_string_literal(inner_type) else get_wire_type(inner_type),
-        )
+
+        # Recursively get wire type info for inner type
+        inner_info = get_wire_type_info(inner_type)
+        inner_wire_type = cast(InnerWireType, inner_info.wire_type)
+
+        # If inner type has properties (it's a complex object), propagate them
+        if inner_info.properties:
+            inner_properties = inner_info.properties
+        # If inner type is array (nested arrays), propagate inner_properties
+        elif inner_info.inner_properties:
+            inner_properties = inner_info.inner_properties
     else:
         inner_wire_type = None
 
@@ -696,11 +725,133 @@ def get_wire_type_info(_type: type) -> WireTypeInfo:
         enum_values = [str(e) for e in get_args(type_to_check)]
 
     # Special case: Enum can be enumerated on the wire
-    elif issubclass(actual_type, Enum):
+    elif isinstance(actual_type, type) and issubclass(actual_type, Enum):
         is_enum = True
-        enum_values = [e.value for e in actual_type]  # type: ignore[union-attr]
+        enum_values = [e.value for e in actual_type]
+
+    # Extract properties for complex types
+    properties = None
+    if wire_type == "json" and not is_list:
+        properties = extract_properties(type_to_check)
+
+    return WireTypeInfo(
+        wire_type,
+        inner_wire_type,
+        enum_values if is_enum else None,
+        properties,
+        inner_properties,
+    )
+
+
+def _extract_typeddict_field_descriptions(typeddict_class: type) -> dict[str, str]:
+    """
+    Extract field descriptions from TypedDict docstrings.
+
+    TypedDict classes typically have field descriptions as docstrings after each field.
+    This function attempts to parse the source code to extract these descriptions.
+    """
+    descriptions = {}
+
+    try:
+        source = inspect.getsource(typeddict_class)
+        # Simple regex to match field: type pattern followed by a docstring
+        # This is a simplified approach - a full AST parser would be more robust
+        import re
+
+        # Pattern to match field definition followed by docstring
+        pattern = r'(\w+):\s*[^"\n]+\n\s*"""([^"]+)"""'
+        matches = re.findall(pattern, source)
+
+        for field_name, description in matches:
+            descriptions[field_name] = description.strip()
+
+    except (OSError, TypeError):
+        # If we can't get the source, return empty descriptions
+        pass
+
+    return descriptions
+
+
+def extract_properties(type_to_check: type) -> dict[str, WireTypeInfo] | None:
+    """
+    Extract properties from TypedDict, Pydantic models, or other structured types.
+    """
+    properties = {}
+
+    # Handle Pydantic BaseModel
+    if isinstance(type_to_check, type) and issubclass(type_to_check, BaseModel):
+        for field_name, field_info in type_to_check.model_fields.items():
+            # Get the field type
+            field_type = field_info.annotation
+            if field_type is None:
+                continue
+
+            # Handle Optional types (Union[T, None])
+            if is_strict_optional(field_type):
+                # Extract the non-None type from Optional
+                field_type = next(arg for arg in get_args(field_type) if arg is not type(None))
+
+            # Get wire type info recursively
+            wire_info = get_wire_type_info(field_type)
+            properties[field_name] = wire_info
+
+    # Handle TypedDict
+    elif is_typeddict(type_to_check):
+        # Get type hints for the TypedDict
+        type_hints = get_type_hints(type_to_check, include_extras=True)
 
-    return WireTypeInfo(wire_type, inner_wire_type, enum_values if is_enum else None)
+        # Try to extract field descriptions from the class source
+        field_descriptions = _extract_typeddict_field_descriptions(type_to_check)
+
+        for field_name, field_type in type_hints.items():
+            # Handle Optional types (Union[T, None])
+            if is_strict_optional(field_type):
+                # Extract the non-None type from Optional
+                field_type = next(arg for arg in get_args(field_type) if arg is not type(None))
+            wire_info = get_wire_type_info(field_type)
+
+            # Add description if available
+            if field_name in field_descriptions:
+                wire_info.description = field_descriptions[field_name]
+
+            properties[field_name] = wire_info
+
+    # Handle regular dict with type annotations (e.g., dict[str, Any])
+    elif get_origin(type_to_check) is dict:
+        # For generic dicts, we can't extract specific properties
+        return None
+
+    return properties if properties else None
+
+
+def wire_type_info_to_value_schema(wire_info: WireTypeInfo) -> ValueSchema:
+    """
+    Convert WireTypeInfo to ValueSchema, including nested properties.
+    """
+    # Convert nested properties if they exist
+    properties = None
+    if wire_info.properties:
+        properties = {
+            name: wire_type_info_to_value_schema(nested_info)
+            for name, nested_info in wire_info.properties.items()
+        }
+
+    # Convert inner properties for array items
+    inner_properties = None
+    if wire_info.inner_properties:
+        inner_properties = {
+            name: wire_type_info_to_value_schema(nested_info)
+            for name, nested_info in wire_info.inner_properties.items()
+        }
+
+    return ValueSchema(
+        val_type=wire_info.wire_type,
+        inner_val_type=wire_info.inner_wire_type,
+        enum=wire_info.enum_values,
+        properties=properties,
+        inner_properties=inner_properties,
+        description=wire_info.description,
+    )
 
 
 def extract_python_param_info(param: inspect.Parameter) -> ParamInfo:
@@ -799,6 +950,9 @@ def get_wire_type(
     if isinstance(_type, type) and issubclass(_type, BaseModel):
         return "json"
 
+    if is_typeddict(_type):
+        return "json"
+
     raise ToolDefinitionError(f"Unsupported parameter type: {_type}")
 
 
@@ -831,7 +985,7 @@ def create_func_models(func: Callable) -> tuple[type[BaseModel], type[BaseModel]
     return input_model, output_model
 
 
-def determine_output_model(func: Callable) -> type[BaseModel]:
+def determine_output_model(func: Callable) -> type[BaseModel]:  # noqa: C901
     """
     Determine the output model for a function based on its return annotation.
     """
@@ -845,6 +999,18 @@ def determine_output_model(func: Callable) -> type[BaseModel]:
             description = (
                 return_annotation.__metadata__[0] if return_annotation.__metadata__ else ""
             )
+
+            # Check if the field type is a TypedDict
+            if is_typeddict(field_type):
+                # Create a Pydantic model from TypedDict
+                typeddict_model = create_model_from_typeddict(
+                    field_type, f"{output_model_name}TypedDict"
+                )
+                return create_model(
+                    output_model_name,
+                    result=(typeddict_model, Field(description=str(description))),
+                )
+
             if description:
                 return create_model(
                     output_model_name,
@@ -857,6 +1023,18 @@ def determine_output_model(func: Callable) -> type[BaseModel]:
             # TODO handle multiple non-None arguments. Raise error?
             for arg in get_args(return_annotation):
                 if arg is not type(None):
+                    # Check if the arg is a TypedDict
+                    if is_typeddict(arg):
+                        typeddict_model = create_model_from_typeddict(
+                            arg, f"{output_model_name}TypedDict"
+                        )
+                        return create_model(
+                            output_model_name,
+                            result=(
+                                typeddict_model,
+                                Field(description="No description provided."),
+                            ),
+                        )
                     return create_model(
                         output_model_name,
                         result=(arg, Field(description="No description provided.")),
@@ -871,6 +1049,17 @@ def determine_output_model(func: Callable) -> type[BaseModel]:
             ),
         )
     else:
+        # Check if return type is TypedDict
+        if is_typeddict(return_annotation):
+            typeddict_model = create_model_from_typeddict(return_annotation, output_model_name)
+            return create_model(
+                output_model_name,
+                result=(
+                    typeddict_model,
+                    Field(description="No description provided."),
+                ),
+            )
+
         # Handle simple return types (like str)
         return create_model(
             output_model_name,
@@ -878,6 +1067,37 @@ def determine_output_model(func: Callable) -> type[BaseModel]:
         )
 
 
+def create_model_from_typeddict(typeddict_class: type, model_name: str) -> type[BaseModel]:
+    """
+    Create a Pydantic model from a TypedDict class.
+    This enables runtime validation of TypedDict structures.
+    """
+    # Get type hints for the TypedDict
+    type_hints = get_type_hints(typeddict_class, include_extras=True)
+
+    # Build field definitions for the Pydantic model
+    field_definitions: dict[str, Any] = {}
+    for field_name, field_type in type_hints.items():
+        # Check if field is required
+        is_required = field_name in getattr(typeddict_class, "__required_keys__", set())
+
+        # Handle nested TypedDict
+        if is_typeddict(field_type):
+            nested_model = create_model_from_typeddict(field_type, f"{model_name}_{field_name}")
+            if is_required:
+                field_definitions[field_name] = (nested_model, Field())
+            else:
+                field_definitions[field_name] = (nested_model, Field(default=None))
+        else:
+            if is_required:
+                field_definitions[field_name] = (field_type, Field())
+            else:
+                field_definitions[field_name] = (field_type, Field(default=None))
+
+    # Create and return the Pydantic model
+    return create_model(model_name, **field_definitions)
+
+
 def to_tool_secret_requirements(
     secrets_requirement: list[str],
 ) -> list[ToolSecretRequirement]:

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/executor.py

@@ -1,6 +1,7 @@
 import asyncio
 import traceback
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from pydantic import BaseModel, ValidationError
 
@@ -12,7 +13,12 @@ from arcade_core.errors import (
     ToolSerializationError,
 )
 from arcade_core.output import output_factory
-from arcade_core.schema import ToolCallLog, ToolCallOutput, ToolContext, ToolDefinition
+from arcade_core.schema import (
+    ToolCallLog,
+    ToolCallOutput,
+    ToolContext,
+    ToolDefinition,
+)
 
 
 class ToolExecutor:
@@ -34,7 +40,9 @@ class ToolExecutor:
         if definition.deprecation_message is not None:
             tool_call_logs.append(
                 ToolCallLog(
-                    message=definition.deprecation_message, level="warning", subtype="deprecation"
+                    message=definition.deprecation_message,
+                    level="warning",
+                    subtype="deprecation",
                 )
             )
 
@@ -101,7 +109,8 @@ class ToolExecutor:
 
         except ValidationError as e:
             raise ToolInputError(
-                message="Error in tool input deserialization", developer_message=str(e)
+                message="Error in tool input deserialization",
+                developer_message=str(e),
             ) from e
 
         return inputs

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/output.py

@@ -1,5 +1,7 @@
 from typing import TypeVar
 
+from pydantic import BaseModel
+
 from arcade_core.schema import ToolCallError, ToolCallLog, ToolCallOutput
 from arcade_core.utils import coerce_empty_list_to_none
 
@@ -17,9 +19,29 @@ class ToolOutputFactory:
         data: T | None = None,
         logs: list[ToolCallLog] | None = None,
     ) -> ToolCallOutput:
-        value = getattr(data, "result", "") if data else ""
+        # Extract the result value
+        """
+        Extracts the result value for the tool output.
+
+        The executor guarantees that `data` is either a string, a dict, or None.
+        """
+        value: str | int | float | bool | dict | list[str] | None
+        if data is None:
+            value = ""
+        elif hasattr(data, "result"):
+            value = getattr(data, "result", "")
+        elif isinstance(data, BaseModel):
+            value = data.model_dump()
+        elif isinstance(data, (str, int, float, bool, list)):
+            value = data
+        else:
+            raise ValueError(f"Unsupported data output type: {type(data)}")
+
         logs = coerce_empty_list_to_none(logs)
-        return ToolCallOutput(value=value, logs=logs)
+        return ToolCallOutput(
+            value=value,
+            logs=logs,
+        )
 
     def fail(
         self,
@@ -56,6 +78,7 @@ class ToolOutputFactory:
                 can_retry=True,
                 additional_prompt_content=additional_prompt_content,
                 retry_after_ms=retry_after_ms,
+                traceback_info=traceback_info,
             ),
             logs=coerce_empty_list_to_none(logs),
         )

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/parse.py

@@ -1,6 +1,5 @@
 import ast
 from pathlib import Path
-from typing import Optional, Union
 
 
 def load_ast_tree(filepath: str | Path) -> ast.AST:
@@ -16,8 +15,8 @@ def load_ast_tree(filepath: str | Path) -> ast.AST:
 
 
 def get_function_name_if_decorated(
-    node: Union[ast.FunctionDef, ast.AsyncFunctionDef],
-) -> Optional[str]:
+    node: ast.FunctionDef | ast.AsyncFunctionDef,
+) -> str | None:
     """
     Check if a function has a decorator.
     """

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/schema.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field
 
@@ -15,12 +15,21 @@ class ValueSchema(BaseModel):
     val_type: Literal["string", "integer", "number", "boolean", "json", "array"]
     """The type of the value."""
 
-    inner_val_type: Optional[Literal["string", "integer", "number", "boolean", "json"]] = None
+    inner_val_type: Literal["string", "integer", "number", "boolean", "json"] | None = None
     """The type of the inner value, if the value is a list."""
 
-    enum: Optional[list[str]] = None
+    enum: list[str] | None = None
     """The list of possible values for the value, if it is a closed list."""
 
+    properties: dict[str, "ValueSchema"] | None = None
+    """For object types (json), the schema of nested properties."""
+
+    inner_properties: dict[str, "ValueSchema"] | None = None
+    """For array types with json items, the schema of properties for each array item."""
+
+    description: str | None = None
+    """Optional description of the value."""
+
 
 class InputParameter(BaseModel):
     """A parameter that can be passed to a tool."""
@@ -30,8 +39,9 @@ class InputParameter(BaseModel):
         ...,
         description="Whether this parameter is required (true) or optional (false).",
     )
-    description: Optional[str] = Field(
-        None, description="A descriptive, human-readable explanation of the parameter."
+    description: str | None = Field(
+        None,
+        description="A descriptive, human-readable explanation of the parameter.",
     )
     value_schema: ValueSchema = Field(
         ...,
@@ -59,14 +69,14 @@ class ToolInput(BaseModel):
 class ToolOutput(BaseModel):
     """The output of a tool."""
 
-    description: Optional[str] = Field(
+    description: str | None = Field(
         None, description="A descriptive, human-readable explanation of the output."
     )
     available_modes: list[str] = Field(
         default_factory=lambda: ["value", "error", "null"],
         description="The available modes for the output.",
     )
-    value_schema: Optional[ValueSchema] = Field(
+    value_schema: ValueSchema | None = Field(
         None, description="The schema of the value of the output."
     )
 
@@ -74,7 +84,7 @@ class ToolOutput(BaseModel):
 class OAuth2Requirement(BaseModel):
     """Indicates that the tool requires OAuth 2.0 authorization."""
 
-    scopes: Optional[list[str]] = None
+    scopes: list[str] | None = None
     """The scope(s) needed for the authorized action."""
 
 
@@ -90,16 +100,16 @@ class ToolAuthRequirement(BaseModel):
     #
     # The Arcade SDK translates these into the appropriate provider ID (Google) and type (OAuth2).
     # The only time the developer will set these is if they are using a custom auth provider.
-    provider_id: Optional[str] = None
+    provider_id: str | None = None
     """The provider ID configured in Arcade that acts as an alias to well-known configuration."""
 
     provider_type: str
     """The type of the authorization provider."""
 
-    id: Optional[str] = None
+    id: str | None = None
     """A provider's unique identifier, allowing the tool to specify a specific authorization provider. Recommended for private tools only."""
 
-    oauth2: Optional[OAuth2Requirement] = None
+    oauth2: OAuth2Requirement | None = None
     """The OAuth 2.0 requirement, if any."""
 
 
@@ -133,13 +143,13 @@ class ToolMetadataRequirement(BaseModel):
 class ToolRequirements(BaseModel):
     """The requirements for a tool to run."""
 
-    authorization: Union[ToolAuthRequirement, None] = None
+    authorization: ToolAuthRequirement | None = None
     """The authorization requirements for the tool, if any."""
 
-    secrets: Union[list[ToolSecretRequirement], None] = None
+    secrets: list[ToolSecretRequirement] | None = None
     """The secret requirements for the tool, if any."""
 
-    metadata: Union[list[ToolMetadataRequirement], None] = None
+    metadata: list[ToolMetadataRequirement] | None = None
     """The metadata requirements for the tool, if any."""
 
 
@@ -149,10 +159,10 @@ class ToolkitDefinition(BaseModel):
     name: str
     """The name of the toolkit."""
 
-    description: Optional[str] = None
+    description: str | None = None
     """The description of the toolkit."""
 
-    version: Optional[str] = None
+    version: str | None = None
     """The version identifier of the toolkit."""
 
 
@@ -166,7 +176,7 @@ class FullyQualifiedName:
     toolkit_name: str
     """The name of the toolkit containing the tool."""
 
-    toolkit_version: Optional[str] = None
+    toolkit_version: str | None = None
     """The version of the toolkit containing the tool."""
 
     def __str__(self) -> str:
@@ -225,7 +235,7 @@ class ToolDefinition(BaseModel):
     requirements: ToolRequirements
     """The requirements (e.g. authorization) for the tool to run."""
 
-    deprecation_message: Optional[str] = None
+    deprecation_message: str | None = None
     """The message to display when the tool is deprecated."""
 
     def get_fully_qualified_name(self) -> FullyQualifiedName:
@@ -241,7 +251,7 @@ class ToolReference(BaseModel):
     toolkit: str
     """The name of the toolkit containing the tool."""
 
-    version: Optional[str] = None
+    version: str | None = None
     """The version of the toolkit containing the tool."""
 
     def get_fully_qualified_name(self) -> FullyQualifiedName:
@@ -313,7 +323,10 @@ class ToolContext(BaseModel):
         return self._get_item(key, self.metadata, "metadata")
 
     def _get_item(
-        self, key: str, items: list[ToolMetadataItem] | list[ToolSecretItem] | None, item_name: str
+        self,
+        key: str,
+        items: list[ToolMetadataItem] | list[ToolSecretItem] | None,
+        item_name: str,
     ) -> str:
         if not key or not key.strip():
             raise ValueError(
@@ -368,7 +381,7 @@ class ToolCallLog(BaseModel):
     ]
     """The level of severity for the log."""
 
-    subtype: Optional[Literal["deprecation"]] = None
+    subtype: Literal["deprecation"] | None = None
     """Optional field for further categorization of the log."""
 
 
@@ -405,7 +418,7 @@ class ToolCallRequiresAuthorization(BaseModel):
 class ToolCallOutput(BaseModel):
     """The output of a tool invocation."""
 
-    value: Union[str, int, float, bool, dict, list[str]] | None = None
+    value: str | int | float | bool | dict | list[str] | None = None
     """The value returned by the tool."""
     logs: list[ToolCallLog] | None = None
     """The logs that occurred during the tool invocation."""

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/toolkit.py

@@ -4,7 +4,7 @@ import logging
 import os
 import types
 from collections import defaultdict
-from pathlib import Path
+from pathlib import Path, PurePosixPath, PureWindowsPath
 
 from pydantic import BaseModel, ConfigDict, field_validator
 
@@ -87,14 +87,6 @@ class Toolkit(BaseModel):
         except (ImportError, AttributeError) as e:
             raise ToolkitLoadError(f"Failed to locate package directory for '{package}'.") from e
 
-        # Get all python files in the package directory
-        try:
-            modules = [f for f in package_dir.glob("**/*.py") if f.is_file()]
-        except OSError as e:
-            raise ToolkitLoadError(
-                f"Failed to locate Python files in package directory for '{package}'."
-            ) from e
-
         toolkit = cls(
             name=name,
             package_name=package_name,
@@ -105,14 +97,7 @@ class Toolkit(BaseModel):
             repository=repo,
         )
 
-        for module_path in modules:
-            relative_path = module_path.relative_to(package_dir)
-            import_path = ".".join(relative_path.with_suffix("").parts)
-            import_path = f"{package_name}.{import_path}"
-            toolkit.tools[import_path] = get_tools_from_file(str(module_path))
-
-        if not toolkit.tools:
-            raise ToolkitLoadError(f"No tools found in package {package}")
+        toolkit.tools = cls.tools_from_directory(package_dir, package_name)
 
         return toolkit
 
@@ -229,6 +214,61 @@ class Toolkit(BaseModel):
 
         return all_toolkits
 
+    @classmethod
+    def tools_from_directory(cls, package_dir: Path, package_name: str) -> dict[str, list[str]]:
+        """
+        Load a Toolkit from a directory.
+        """
+        # Get all python files in the package directory
+        try:
+            modules = [f for f in package_dir.glob("**/*.py") if f.is_file() and Validate.path(f)]
+        except OSError as e:
+            raise ToolkitLoadError(
+                f"Failed to locate Python files in package directory for '{package_name}'."
+            ) from e
+
+        tools: dict[str, list[str]] = {}
+
+        for module_path in modules:
+            relative_path = module_path.relative_to(package_dir)
+            cls.validate_file(module_path)
+            import_path = ".".join(relative_path.with_suffix("").parts)
+            import_path = f"{package_name}.{import_path}"
+            tools[import_path] = get_tools_from_file(str(module_path))
+
+        if not tools:
+            raise ToolkitLoadError(f"No tools found in package {package_name}")
+
+        return tools
+
+    @classmethod
+    def validate_file(cls, file_path: str | Path) -> None:
+        """
+        Validate that the Python code in the given file is syntactically correct.
+
+        Args:
+            file_path: Path to the Python file to validate
+        """
+        # Convert string path to Path object if needed
+        path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        # Check if file exists
+        if not path.exists():
+            raise ValueError(f"❌ File not found: {path}")
+
+        # Check if it's a Python file
+        if not path.suffix == ".py":
+            raise ValueError(f"❌ Not a Python file: {path}")
+
+        try:
+            # Try to compile the code to check for syntax errors
+            with open(path, encoding="utf-8") as f:
+                source = f.read()
+
+            compile(source, str(path), "exec")
+        except Exception as e:
+            raise SyntaxError(f"{path}: {e}")
+
 
 def get_package_directory(package_name: str) -> str:
     """
@@ -247,3 +287,32 @@ def get_package_directory(package_name: str) -> str:
         return spec.submodule_search_locations[0]
     else:
         raise ImportError(f"Package {package_name} does not have a file path associated with it")
+
+
+class Validate:
+    warn = True
+
+    @classmethod
+    def path(cls, path: str | Path) -> bool:
+        """
+        Validate if a path is valid to be served or deployed.
+        """
+        # Check both POSIX and Windows interpretations
+        posix_path = PurePosixPath(path)
+        windows_path = PureWindowsPath(path)
+
+        # Get all possible parts from both interpretations
+        all_parts = set(posix_path.parts) | set(windows_path.parts)
+
+        for part in all_parts:
+            if (part == "venv" or part.startswith(".")) and cls.warn:
+                print(
+                    f"⚠️ Your package may contain a venv directory or hidden files. We suggest moving these out of the toolkit directory to avoid deployment issues: {path}"
+                )
+                cls.warn = False
+            if part in {"dist", "build", "__pycache__", "coverage.xml"}:
+                return False
+            if part.endswith(".lock"):
+                return False
+
+        return True

{arcade_core-2.2.0 → arcade_core-2.2.2}/arcade_core/utils.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import ast
 import inspect
 import re
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from types import UnionType
-from typing import Any, Callable, Literal, TypeVar, Union, get_args, get_origin
+from typing import Any, Literal, TypeVar, Union, get_args, get_origin
 
 T = TypeVar("T")
 

{arcade_core-2.2.0 → arcade_core-2.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arcade-core"
-version = "2.2.0"
+version = "2.2.2"
 description = "Arcade Core - Core library for Arcade platform"
 readme = "README.md"
 license = {text = "MIT"}