arcade-core 4.1.0__py3-none-any.whl → 4.2.1__py3-none-any.whl

arcade_core/converters/__init__.py

@@ -0,0 +1,34 @@
+"""Converters for transforming tool definitions between formats."""
+
+from .anthropic import (
+    AnthropicInputSchema,
+    AnthropicInputSchemaProperty,
+    AnthropicToolList,
+    AnthropicToolSchema,
+    to_anthropic,
+)
+from .openai import (
+    OpenAIFunctionParameterProperty,
+    OpenAIFunctionParameters,
+    OpenAIFunctionSchema,
+    OpenAIToolList,
+    OpenAIToolSchema,
+    to_openai,
+)
+from .utils import denormalize_tool_name, normalize_tool_name
+
+__all__ = [
+    "AnthropicInputSchema",
+    "AnthropicInputSchemaProperty",
+    "AnthropicToolList",
+    "AnthropicToolSchema",
+    "OpenAIFunctionParameterProperty",
+    "OpenAIFunctionParameters",
+    "OpenAIFunctionSchema",
+    "OpenAIToolList",
+    "OpenAIToolSchema",
+    "denormalize_tool_name",
+    "normalize_tool_name",
+    "to_anthropic",
+    "to_openai",
+]

arcade_core/converters/anthropic.py

@@ -0,0 +1,194 @@
+"""Converter for converting Arcade ToolDefinition to Anthropic tool schema."""
+
+from typing import Any, TypedDict
+
+from arcade_core.catalog import MaterializedTool
+from arcade_core.converters.utils import normalize_tool_name
+from arcade_core.schema import InputParameter, ValueSchema
+
+# ----------------------------------------------------------------------------
+# Type definitions for JSON tool schemas used by Anthropic APIs.
+# Defines the proper types for tool schemas to ensure
+# compatibility with Anthropic's Messages API tool use feature.
+# Reference: https://docs.anthropic.com/en/docs/build-with-claude/tool-use
+# ----------------------------------------------------------------------------
+
+
+class AnthropicInputSchemaProperty(TypedDict, total=False):
+    """Type definition for a property within Anthropic input schema."""
+
+    type: str
+    """The JSON Schema type for this property."""
+
+    description: str
+    """Description of the property."""
+
+    enum: list[Any]
+    """Allowed values for enum properties."""
+
+    items: dict[str, Any]
+    """Schema for array items when type is 'array'."""
+
+    properties: dict[str, "AnthropicInputSchemaProperty"]
+    """Nested properties when type is 'object'."""
+
+    required: list[str]
+    """Required fields for nested objects."""
+
+
+class AnthropicInputSchema(TypedDict, total=False):
+    """Type definition for Anthropic tool input schema."""
+
+    type: str
+    """Must be 'object' for tool input schemas."""
+
+    properties: dict[str, AnthropicInputSchemaProperty]
+    """The properties of the tool input parameters."""
+
+    required: list[str]
+    """List of required parameter names."""
+
+
+class AnthropicToolSchema(TypedDict, total=False):
+    """
+    Schema for a tool definition passed to Anthropic's `tools` parameter.
+
+    Unlike OpenAI, Anthropic uses a flat structure without a wrapper object.
+    The schema uses `input_schema` instead of `parameters`.
+    """
+
+    name: str
+    """The name of the tool."""
+
+    description: str
+    """Description of what the tool does."""
+
+    input_schema: AnthropicInputSchema
+    """JSON Schema describing the tool's input parameters."""
+
+
+# Type alias for a list of Anthropic tool schemas
+AnthropicToolList = list[AnthropicToolSchema]
+
+
+# ----------------------------------------------------------------------------
+# Converters
+# ----------------------------------------------------------------------------
+def to_anthropic(tool: MaterializedTool) -> AnthropicToolSchema:
+    """Convert a MaterializedTool to Anthropic tool schema format.
+
+    Args:
+        tool: The MaterializedTool to convert
+
+    Returns:
+        The Anthropic tool schema format (what is passed to the Anthropic API)
+    """
+    name = normalize_tool_name(tool.definition.fully_qualified_name)
+    description = tool.description
+    input_schema = _convert_input_parameters_to_json_schema(tool.definition.input.parameters)
+
+    return _create_tool_schema(name, description, input_schema)
+
+
+def _create_tool_schema(
+    name: str, description: str, input_schema: AnthropicInputSchema
+) -> AnthropicToolSchema:
+    """Create a properly typed Anthropic tool schema.
+
+    Args:
+        name: The name of the tool
+        description: Description of what the tool does
+        input_schema: JSON schema for the tool input parameters
+
+    Returns:
+        A properly typed AnthropicToolSchema
+    """
+    tool: AnthropicToolSchema = {
+        "name": name,
+        "description": description,
+        "input_schema": input_schema,
+    }
+
+    return tool
+
+
+def _convert_value_schema_to_json_schema(
+    value_schema: ValueSchema,
+) -> AnthropicInputSchemaProperty:
+    """Convert Arcade ValueSchema to JSON Schema format for Anthropic."""
+    type_mapping = {
+        "string": "string",
+        "integer": "integer",
+        "number": "number",
+        "boolean": "boolean",
+        "json": "object",
+        "array": "array",
+    }
+
+    schema: AnthropicInputSchemaProperty = {"type": type_mapping[value_schema.val_type]}
+
+    if value_schema.val_type == "array" and value_schema.inner_val_type:
+        items_schema: dict[str, Any] = {"type": type_mapping[value_schema.inner_val_type]}
+
+        # For arrays, enum should be applied to the items, not the array itself
+        if value_schema.enum:
+            items_schema["enum"] = value_schema.enum
+
+        schema["items"] = items_schema
+    else:
+        # Handle enum for non-array types
+        if value_schema.enum:
+            schema["enum"] = value_schema.enum
+
+    # Handle object properties
+    if value_schema.val_type == "json" and value_schema.properties:
+        schema["properties"] = {
+            name: _convert_value_schema_to_json_schema(nested_schema)
+            for name, nested_schema in value_schema.properties.items()
+        }
+
+    return schema
+
+
+def _convert_input_parameters_to_json_schema(
+    parameters: list[InputParameter],
+) -> AnthropicInputSchema:
+    """Convert list of InputParameter to JSON schema parameters object.
+
+    Unlike OpenAI's strict mode, Anthropic uses standard JSON Schema:
+    - Only actually required parameters are listed in 'required'
+    - No need to add 'null' to optional parameter types
+    - No 'additionalProperties: false' requirement
+    """
+    if not parameters:
+        # Minimal JSON schema for a tool with no input parameters
+        return {
+            "type": "object",
+            "properties": {},
+        }
+
+    properties: dict[str, AnthropicInputSchemaProperty] = {}
+    required: list[str] = []
+
+    for parameter in parameters:
+        param_schema = _convert_value_schema_to_json_schema(parameter.value_schema)
+
+        if parameter.description:
+            param_schema["description"] = parameter.description
+
+        properties[parameter.name] = param_schema
+
+        # Only add actually required parameters to the required list
+        if parameter.required:
+            required.append(parameter.name)
+
+    json_schema: AnthropicInputSchema = {
+        "type": "object",
+        "properties": properties,
+    }
+
+    # Only include 'required' if there are required parameters
+    if required:
+        json_schema["required"] = required
+
+    return json_schema

arcade_core/converters/openai.py

@@ -3,6 +3,7 @@
 from typing import Any, Literal, TypedDict
 
 from arcade_core.catalog import MaterializedTool
+from arcade_core.converters.utils import normalize_tool_name
 from arcade_core.schema import InputParameter, ValueSchema
 
 # ----------------------------------------------------------------------------
@@ -101,7 +102,7 @@ def to_openai(tool: MaterializedTool) -> OpenAIToolSchema:
     Returns:
         The OpenAI JsonToolSchema format (what is passed to the OpenAI API)
     """
-    name = tool.definition.fully_qualified_name.replace(".", "_")
+    name = normalize_tool_name(tool.definition.fully_qualified_name)
     description = tool.description
     parameters_schema = _convert_input_parameters_to_json_schema(tool.definition.input.parameters)
     return _create_tool_schema(name, description, parameters_schema)

arcade_core/converters/utils.py

@@ -0,0 +1,54 @@
+"""Shared utilities for tool name conversion across providers.
+
+This module contains common utilities used by both OpenAI and Anthropic converters.
+"""
+
+
+def normalize_tool_name(name: str) -> str:
+    """
+    Normalize a tool name for LLM provider compatibility.
+
+    Both OpenAI and Anthropic have restrictions on tool names:
+    - OpenAI: allows alphanumeric, hyphens, underscores (max 64 chars)
+    - Anthropic: allows alphanumeric and underscores only (no dots)
+
+    Arcade uses dot notation for fully qualified names (e.g., "Google.Search"),
+    so we normalize by replacing dots with underscores.
+
+    Args:
+        name: The original tool name (e.g., "Google.Search")
+
+    Returns:
+        The normalized tool name (e.g., "Google_Search")
+
+    Examples:
+        >>> normalize_tool_name("Google.Search")
+        'Google_Search'
+        >>> normalize_tool_name("MyTool")
+        'MyTool'
+        >>> normalize_tool_name("Namespace.Sub.Tool")
+        'Namespace_Sub_Tool'
+    """
+    return name.replace(".", "_")
+
+
+def denormalize_tool_name(normalized_name: str, separator: str = ".") -> str:
+    """
+    Reverse the normalization of a tool name.
+
+    This converts provider-format names back to Arcade's dot notation.
+    Note: This is a best-effort reversal and may not be accurate if the original
+    name contained underscores.
+
+    Args:
+        normalized_name: The normalized tool name (e.g., "Google_Search")
+        separator: The separator to use (default: ".")
+
+    Returns:
+        The denormalized tool name (e.g., "Google.Search")
+
+    Examples:
+        >>> denormalize_tool_name("Google_Search")
+        'Google.Search'
+    """
+    return normalized_name.replace("_", separator)

arcade_core/usage/identity.py

@@ -6,7 +6,6 @@ supporting pre-login anonymous tracking, post-login identity stitching,
 and logout identity rotation.
 """
 
-import fcntl
 import json
 import os
 import tempfile
@@ -14,6 +13,7 @@ import uuid
 from typing import Any
 
 import httpx
+import portalocker
 import yaml
 
 from arcade_core.constants import ARCADE_CONFIG_PATH, CREDENTIALS_FILE_PATH
@@ -46,18 +46,16 @@ class UsageIdentity:
         if os.path.exists(self.usage_file_path):
             try:
                 with open(self.usage_file_path) as f:
-                    # lock file
-                    if os.name != "nt":  # Unix-like systems
-                        fcntl.flock(f.fileno(), fcntl.LOCK_SH)
+                    # Lock file for reading (shared lock)
+                    portalocker.lock(f, portalocker.LOCK_SH)
                     try:
                         data = json.load(f)
                         if isinstance(data, dict) and KEY_ANON_ID in data:
                             self._data = data
                             return self._data
                     finally:
-                        # unlock file
-                        if os.name != "nt":
-                            fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+                        # Unlock file
+                        portalocker.unlock(f)
             except Exception:  # noqa: S110
                 pass
 
@@ -80,18 +78,18 @@ class UsageIdentity:
 
         try:
             with os.fdopen(temp_fd, "w") as f:
-                # lock file
-                if os.name != "nt":  # Unix-like systems
-                    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+                # Lock file for writing (exclusive lock)
+                portalocker.lock(f, portalocker.LOCK_EX)
                 try:
                     json.dump(data, f, indent=2)
                     f.flush()
                     os.fsync(f.fileno())  # ensure data is written to disk
                 finally:
-                    if os.name != "nt":
-                        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+                    portalocker.unlock(f)
 
-            os.rename(temp_path, self.usage_file_path)
+            # Use os.replace() for cross-platform atomic file replacement
+            # os.replace() is atomic on both Unix and Windows (Python 3.3+)
+            os.replace(temp_path, self.usage_file_path)
         except Exception:
             # clean up
             import contextlib

{arcade_core-4.1.0.dist-info → arcade_core-4.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade-core
-Version: 4.1.0
+Version: 4.2.1
 Summary: Arcade Core - Core library for Arcade platform
 Author-email: Arcade <dev@arcade.dev>
 License: MIT
@@ -16,6 +16,7 @@ Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: loguru>=0.7.0
 Requires-Dist: packaging>=24.1
+Requires-Dist: portalocker>=2.10.0
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: pyjwt>=2.8.0
 Requires-Dist: pyyaml>=6.0

{arcade_core-4.1.0.dist-info → arcade_core-4.2.1.dist-info}/RECORD

@@ -17,15 +17,18 @@ arcade_core/schema.py,sha256=y32Ndlb1b3Hw7_Wm3eVXxh0kSg3oGitWUYBfwFLjHuY,21198
 arcade_core/toolkit.py,sha256=lLlOL6fA6Lmo-dtLTMMcPCzKDf9YQObwxG1LdVADv3E,14431
 arcade_core/utils.py,sha256=_3bM-yfIDFmMVqt-NFYp2Lx1QcNWp7xytGjUQzPs2LY,3255
 arcade_core/version.py,sha256=CpXi3jGlx23RvRyU7iytOMZrnspdWw4yofS8lpP1AJU,18
-arcade_core/converters/openai.py,sha256=4efdgTkvdwT44VGStBhdUmzCnoP5dysceIqPVVPG-vk,7408
+arcade_core/converters/__init__.py,sha256=ckb7c0LCq62_bARxoV7XlRYF7vtGbG1SJnDTWZ9Z7P4,827
+arcade_core/converters/anthropic.py,sha256=Spkf6crPGPF8O82nyxqYI3whRs9togDqoTzTVYaZ6fc,6175
+arcade_core/converters/openai.py,sha256=J4kQlmUzyZjp2vsnS0iDxyF_NhN3NfegiFTl7xYCwXM,7472
+arcade_core/converters/utils.py,sha256=syN6G88UA8sChiLlr1VBna29sczuevb76_OAYuUfvtE,1699
 arcade_core/network/__init__.py,sha256=8GEcg6QAr63U8U1n4bnf7cL-F7FrUrc9otHM2J9ODwk,53
 arcade_core/network/org_transport.py,sha256=DZdIYdldtYZ6gtmWA1C8dXmsNuOv7tePhlpBuAvkhRQ,3222
 arcade_core/usage/__init__.py,sha256=SUR5mqF-bjdbl-P-OOHN6OFAjXZu4agXyPhr7xdVXCw,234
 arcade_core/usage/__main__.py,sha256=rSJkE1G9hlV3HRRA6EJE5Lmy3wKyan7rAxBXHX9A1cI,1577
 arcade_core/usage/constants.py,sha256=1FQIhkFFMZUhU-H4A7GvMb7KQ3qLFrNAZb2-LEvSF3k,1052
-arcade_core/usage/identity.py,sha256=egclRR26jGP1vVvoOoaaZdcS4AtSTZ8fLHpBq1HRgHw,8452
+arcade_core/usage/identity.py,sha256=h_THm-cN3j8nqW7_Lew7OdBRA70valCKJ7zvhDvja_E,8416
 arcade_core/usage/usage_service.py,sha256=xzWWSEktm58liiNYugBHRactSru8V5foriHcsoH0j1A,3407
 arcade_core/usage/utils.py,sha256=FqBOmlhwT68cbnpI5Vx9ZW6vLRYPVg4FJ0GaMEp8qEM,398
-arcade_core-4.1.0.dist-info/METADATA,sha256=LJ8qsm5pS6p17nHRSfnsFiCCzGFtpSDdkmMW4mIXHig,2412
-arcade_core-4.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-arcade_core-4.1.0.dist-info/RECORD,,
+arcade_core-4.2.1.dist-info/METADATA,sha256=5lFJ1C5vqqBXHLC51RdiGvHFsddE-JbG69wt8MFydlM,2447
+arcade_core-4.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+arcade_core-4.2.1.dist-info/RECORD,,