arcade-core 2.0.0__py3-none-any.whl

arcade_core/toolkit.py

@@ -0,0 +1,155 @@
+import importlib.metadata
+import importlib.util
+import logging
+import os
+import types
+from collections import defaultdict
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from arcade_core.errors import ToolkitLoadError
+from arcade_core.parse import get_tools_from_file
+
+logger = logging.getLogger(__name__)
+
+
+class Toolkit(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str
+    """Name of the toolkit"""
+
+    package_name: str
+    """Name of the package holding the toolkit"""
+
+    tools: dict[str, list[str]] = defaultdict(list)
+    """Mapping of module names to tools"""
+
+    # Other python package metadata
+    version: str
+    description: str
+    author: list[str] = []
+    repository: str | None = None
+    homepage: str | None = None
+
+    @field_validator("name", mode="before")
+    def strip_arcade_prefix(cls, value: str) -> str:
+        """
+        Validator to strip the 'arcade_' prefix from the name if it exists.
+        """
+        if value.startswith("arcade_"):
+            return value[len("arcade_") :]
+        return value
+
+    @classmethod
+    def from_module(cls, module: types.ModuleType) -> "Toolkit":
+        """
+        Load a toolkit from an imported python module
+
+        >>> import arcade_math
+        >>> toolkit = Toolkit.from_module(arcade_math)
+        """
+        return cls.from_package(module.__name__)
+
+    @classmethod
+    def from_package(cls, package: str) -> "Toolkit":
+        """
+        Load a Toolkit from a Python package
+        """
+        try:
+            metadata = importlib.metadata.metadata(package)
+            name = metadata["Name"]
+            package_name = package
+            version = metadata["Version"]
+            description = metadata.get("Summary", "")  # type: ignore[attr-defined]
+            author = metadata.get_all("Author-email")
+            homepage = metadata.get("Home-page", None)  # type: ignore[attr-defined]
+            repo = metadata.get("Repository", None)  # type: ignore[attr-defined]
+
+        except importlib.metadata.PackageNotFoundError as e:
+            raise ToolkitLoadError(f"Package {package} not found.") from e
+        except KeyError as e:
+            raise ToolkitLoadError(f"Metadata key error for package {package}.") from e
+        except Exception as e:
+            raise ToolkitLoadError(f"Failed to load metadata for package {package}.") from e
+
+        # Get the package directory
+        try:
+            package_dir = Path(get_package_directory(package))
+        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,
+            version=version,
+            description=description,
+            author=author if author else [],
+            homepage=homepage,
+            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}")
+
+        return toolkit
+
+    @classmethod
+    def find_all_arcade_toolkits(cls) -> list["Toolkit"]:
+        """
+        Find all installed packages prefixed with 'arcade_' in the current
+        Python interpreter's environment and load them as Toolkits.
+
+        Returns:
+            List[Toolkit]: A list of Toolkit instances.
+        """
+        import sysconfig
+
+        # Get the site-packages directory of the current interpreter
+        site_packages_dir = sysconfig.get_paths()["purelib"]
+        arcade_packages = [
+            dist.metadata["Name"]
+            for dist in importlib.metadata.distributions(path=[site_packages_dir])
+            if dist.metadata["Name"].startswith("arcade_")
+        ]
+        toolkits = []
+        for package in arcade_packages:
+            try:
+                toolkits.append(cls.from_package(package))
+            except ToolkitLoadError as e:
+                logger.warning(f"Warning: {e} Skipping toolkit {package}")
+        return toolkits
+
+
+def get_package_directory(package_name: str) -> str:
+    """
+    Get the directory of a Python package
+    """
+
+    spec = importlib.util.find_spec(package_name)
+    if spec is None:
+        raise ImportError(f"Cannot find package named {package_name}")
+
+    if spec.origin:
+        # If the package has an origin, return the directory of the origin
+        return os.path.dirname(spec.origin)
+    elif spec.submodule_search_locations:
+        # If the package is a namespace package, return the first search location
+        return spec.submodule_search_locations[0]
+    else:
+        raise ImportError(f"Package {package_name} does not have a file path associated with it")

arcade_core/utils.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import ast
+import inspect
+import re
+from collections.abc import Iterable
+from types import UnionType
+from typing import Any, Callable, Literal, TypeVar, Union, get_args, get_origin
+
+T = TypeVar("T")
+
+
+def first_or_none(_type: type[T], iterable: Iterable[Any]) -> T | None:
+    """
+    Returns the first item in the iterable that is an instance of the given type, or None if no such item is found.
+    """
+    for item in iterable:
+        if isinstance(item, _type):
+            return item
+    return None
+
+
+def pascal_to_snake_case(name: str) -> str:
+    """
+    Converts a PascalCase name to snake_case.
+    """
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+def snake_to_pascal_case(name: str) -> str:
+    """
+    Converts a snake_case name to PascalCase.
+    """
+    if "_" in name:
+        return "".join(x.capitalize() or "_" for x in name.split("_"))
+    # check if first letter is uppercase
+    if name[0].isupper():
+        return name
+    return name.capitalize()
+
+
+def is_string_literal(_type: type) -> bool:
+    """
+    Returns True if the given type is a string literal, i.e. a Literal[str] or Literal[str, str, ...] etc.
+    """
+    return get_origin(_type) is Literal and all(isinstance(arg, str) for arg in get_args(_type))
+
+
+def is_union(_type: type) -> bool:
+    """
+    Returns True if the given type is a union, i.e. a Union[T1, T2, ...] or T1 | T2 | ... etc.
+    """
+    return get_origin(_type) in {Union, UnionType}
+
+
+def is_strict_optional(_type: type) -> bool:
+    """
+    Returns True if the given type is a strict optional type, i.e. a union with exactly two types
+    where one type is None. This covers Optional[T], Union[T, None] and T | None
+    """
+    return is_union(_type) and len(get_args(_type)) == 2 and type(None) in get_args(_type)
+
+
+def does_function_return_value(func: Callable) -> bool:
+    """
+    Returns True if the given function returns a value, i.e. if it has a return statement with a value.
+    """
+    try:
+        source: str | None = inspect.getsource(func)
+    except OSError:
+        # Workaround for parameterized unit tests that use a dynamically-generated function
+        source = getattr(func, "__source__", None)
+
+    if source is None:
+        raise ValueError("Source code not found")
+
+    tree = ast.parse(source)
+
+    class ReturnVisitor(ast.NodeVisitor):
+        def __init__(self) -> None:
+            self.returns_value = False
+
+        def visit_Return(self, node: ast.Return) -> None:
+            if node.value is not None:
+                self.returns_value = True
+
+    visitor = ReturnVisitor()
+    visitor.visit(tree)
+    return visitor.returns_value
+
+
+def coerce_empty_list_to_none(lst: list[Any] | None) -> list[Any] | None:
+    """
+    Coerces empty lists to None, otherwise returns the list unchanged.
+    """
+    if isinstance(lst, list) and len(lst) == 0:
+        return None
+    return lst

arcade_core/version.py

@@ -0,0 +1 @@
+VERSION = "0.1.0"

arcade_core-2.0.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: arcade-core
+Version: 2.0.0
+Summary: Arcade Core - Core library for Arcade platform
+Author-email: Arcade <dev@arcade.dev>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-common==1.28.2
+Requires-Dist: opentelemetry-exporter-otlp-proto-http==1.28.2
+Requires-Dist: opentelemetry-instrumentation-fastapi==0.49b2
+Requires-Dist: packaging>=24.1
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: pyjwt>=2.8.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: types-python-dateutil==2.9.0.20241003
+Requires-Dist: types-pytz==2024.2.0.20241003
+Requires-Dist: types-toml==0.10.8.20240310
+Provides-Extra: dev
+Requires-Dist: mypy>=1.5.1; extra == 'dev'
+Requires-Dist: pre-commit>=3.4.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.7; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.1.2; extra == 'dev'
+Requires-Dist: types-python-dateutil>=2.8.2; extra == 'dev'
+Requires-Dist: types-pytz>=2024.1; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Arcade Core
+
+Core library for the Arcade platform providing foundational components and utilities.
+
+## Overview
+
+Arcade Core provides the essential building blocks for the Arcade platform:
+
+- **Tool Catalog & Toolkit Management**: Core classes for managing and organizing tools
+- **Configuration & Schema Handling**: Configuration management and validation
+- **Authentication & Authorization**: Auth providers and security utilities
+- **Error Handling**: Comprehensive error types and handling
+- **Telemetry & Observability**: Monitoring and tracing capabilities
+- **Utilities**: Common helper functions and validators
+
+## Installation
+
+```bash
+pip install arcade-core
+```
+
+## Usage
+
+```python
+from arcade_core import ToolCatalog, Toolkit, ArcadeConfig
+
+# Create a tool catalog
+catalog = ToolCatalog()
+
+# Load a toolkit
+toolkit = Toolkit.from_directory("path/to/toolkit")
+
+# Configure Arcade
+config = ArcadeConfig.from_file("config.yaml")
+```
+
+## License
+
+MIT License - see LICENSE file for details.

arcade_core-2.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+arcade_core/__init__.py,sha256=1heu3AROAjpistehPzY2H-2nkj_IjQEh-vVlVOCRF1E,88
+arcade_core/annotations.py,sha256=Nst6aejLWXlpTu7GwzWETu1gQCG1XVAUR_qcFbNvyRc,198
+arcade_core/auth.py,sha256=vlbI_QLiFcBXL4odt56CfL4kz0sOuk_MZujaK-cxN68,5347
+arcade_core/catalog.py,sha256=MH-o-NMvUoK_hg8Ibr8dKoF4Yu0z53D5pfUR--BhPCA,31432
+arcade_core/config.py,sha256=e98XQAkYySGW9T_yrJg54BB8Wuq06GPVHp7xqe2d1vU,572
+arcade_core/config_model.py,sha256=GYO37yKi7ih6EYKPpX1Kl-K1XwM2JyEJguyaJ7j9TY8,4260
+arcade_core/errors.py,sha256=h4H1ck4TP-CDKPuRA5EVtRnplWwk9ofwFWE5h4AuMyg,2043
+arcade_core/executor.py,sha256=tEDAM-4d-LMZJc0xAemjoL73kKCyLxTa79NK6vjWqmw,4444
+arcade_core/output.py,sha256=0v0Y47NVQ40-vl9a47XZT7T-cZqcrVZrvO3xYJlcZPs,1852
+arcade_core/parse.py,sha256=SURNI-B9xHCIprxTRTAR0AMT9hIJpQqHjOmrENzFBVI,1899
+arcade_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcade_core/schema.py,sha256=DgVqrRDZMhndhXcb-CvLEnAtVWkseisvtAwcei5Qgmc,14358
+arcade_core/telemetry.py,sha256=qDv8T-wO8nFi0Qh93WKaPH1b6asfoJoyyfA7ZOxPnbA,5566
+arcade_core/toolkit.py,sha256=ufxkyRN2Qmu-TW4GHYuXrsMav3lrTusUqYf_wL-WZdw,5349
+arcade_core/utils.py,sha256=Gg4na-85pY21e5Ab-yxoRlzTQu3FhlP5xQ9G1BhfrI8,2980
+arcade_core/version.py,sha256=CpXi3jGlx23RvRyU7iytOMZrnspdWw4yofS8lpP1AJU,18
+arcade_core-2.0.0.dist-info/METADATA,sha256=g093vgoWqzSNgBs0uExT7dlassVKXEPXc39-9zB9PhA,2542
+arcade_core-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arcade_core-2.0.0.dist-info/RECORD,,

arcade_core-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any