swarmauri-typing 0.7.0.dev2__tar.gz

swarmauri_typing-0.7.0.dev2/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.3
+Name: swarmauri-typing
+Version: 0.7.0.dev2
+Summary: This repository includes typing used in the Swarmauri framework.
+License: Apache-2.0
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+![Swamauri Logo](https://res.cloudinary.com/dbjmpekvl/image/upload/v1730099724/Swarmauri-logo-lockup-2048x757_hww01w.png)
+
+<p align="center">
+    <a href="https://pypi.org/project/swarmauri/">
+        <img src="https://img.shields.io/pypi/dm/swarmauri" alt="PyPI - Downloads"/></a>
+    <a href="https://github.com/swarmauri/swarmauri-sdk">
+        <img src="https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https://github.com/swarmauri/swarmauri-sdk&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false" alt="GitHub Hits"/></a>
+    <a href="https://pypi.org/project/swarmauri_typing/">
+        <img src="https://img.shields.io/pypi/pyversions/swarmauri" alt="PyPI - Python Version"/></a>
+    <a href="https://pypi.org/project/swarmauri_typing/">
+        <img src="https://img.shields.io/pypi/l/swarmauri_typing" alt="PyPI - License"/></a>
+    <br />
+    <a href="https://pypi.org/project/swarmauri/">
+        <img src="https://img.shields.io/pypi/v/swarmauri?label=swarmauri_typing&color=green" alt="PyPI - swarmauri_core"/></a>
+</p>
+
+
+# Swarmauri Typing Library
+
+The Swarmauri Typing Library provides advanced type utilities for Python, enabling more expressive and flexible type annotations. It includes tools for creating intersection and union types dynamically.
+
+## Features
+
+- **Intersection Types**: Create intersection types that combine multiple classes.
+
+```python
+from typing import Type, TypeVar, Union, Any, Annotated, Tuple
+
+T = TypeVar("T")
+
+class IntersectionMetadata:
+    def __init__(self, classes: Tuple[Type[T]]):
+        self.classes = classes
+
+    def __repr__(self):
+        return f"IntersectionMetadata(classes={self.classes!r})"
+
+class Intersection(type):
+    def __class_getitem__(cls, classes: Union[Type, Tuple[Type, ...]]) -> type:
+        if not isinstance(classes, tuple):
+            classes = (classes,)
+
+        common = set(classes[0].__mro__)
+        for c in classes[1:]:
+            common.intersection_update(c.__mro__)
+
+        ordered_common = [c for c in classes[0].__mro__ if c in common]
+
+        if not ordered_common:
+            return Annotated[Any, IntersectionMetadata(classes=(classes))]
+        else:
+            union_type = Union[tuple(ordered_common)]
+            return Annotated[union_type, IntersectionMetadata(classes=(classes))]
+```
+
+- **Union Factory**: Dynamically create union types based on a provided function.
+
+```python
+from typing import Type, TypeVar, Callable, List, Union, Any, Annotated, get_args, Optional
+
+T = TypeVar("T")
+
+class UnionFactoryMetadata:
+    def __init__(self, data: Any, name: Optional[str] = None):
+        self.data = data
+        self.name = name or self.__class__.__name__
+
+    def __repr__(self):
+        return f"UnionFactoryMetadata(name={self.name!r}, data={self.data!r})"
+
+class UnionFactory:
+    def __init__(self, bound: Callable[[Type[T]], List[type]], name: str = None, annotation_extenders: List[Any] = None):
+        self.name = name or self.__class__.__name__
+        self._union_types_getter = bound
+        self._annotation_extenders = annotation_extenders or []
+
+    def _add_metadata(self, annotated_type: Any, new_metadata: Any) -> Any:
+        if not (hasattr(annotated_type, '__origin__') and annotated_type.__origin__ is Annotated):
+            return Annotated[annotated_type, new_metadata]
+
+        args = get_args(annotated_type)
+        base_type = args[0]
+        old_metadata = args[1:]
+        return Annotated[base_type, *old_metadata, new_metadata]
+
+    def __getitem__(self, input_data: Union[Type[T], str]) -> type:
+        if isinstance(input_data, str):
+            model_name = input_data
+        else:
+            model_name = input_data.__name__
+
+        union_members = self._union_types_getter(model_name)
+
+        if not union_members:
+            final_annotated = Annotated[Any, UnionFactoryMetadata(data=model_name, name=self.name)]
+        else:
+            union_type = Union[tuple(union_members)]
+            final_annotated = Annotated[union_type, UnionFactoryMetadata(data=model_name, name=self.name)]
+
+            for extension in self._annotation_extenders:
+                final_annotated = self._add_metadata(final_annotated, extension)
+
+        return final_annotated
+```
+
+## Getting Started
+
+To start using the Swarmauri Typing Library, include it as a module in your Python project. Ensure you have Python 3.10 or later installed.
+
+### Steps to install via pypi
+
+```sh
+pip install swarmauri-typing
+```
+
+### Usage Example
+
+```python
+from swarmauri_typing import Intersection, UnionFactory
+
+# Example of using Intersection
+class A: pass
+class B: pass
+
+IntersectionType = Intersection[A, B]
+
+# Example of using UnionFactory
+def my_types_getter(name: str):
+    return [A, B]
+
+union_factory = UnionFactory(my_types_getter)
+MyUnion = union_factory["MyModel"]
+```
+
+
+## Contributing
+
+Contributions are welcome! If you'd like to add a new feature, fix a bug, or improve documentation, kindly go through the [contributions guidelines](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) first.
+
+

swarmauri_typing-0.7.0.dev2/README.md

@@ -0,0 +1,139 @@
+![Swamauri Logo](https://res.cloudinary.com/dbjmpekvl/image/upload/v1730099724/Swarmauri-logo-lockup-2048x757_hww01w.png)
+
+<p align="center">
+    <a href="https://pypi.org/project/swarmauri/">
+        <img src="https://img.shields.io/pypi/dm/swarmauri" alt="PyPI - Downloads"/></a>
+    <a href="https://github.com/swarmauri/swarmauri-sdk">
+        <img src="https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https://github.com/swarmauri/swarmauri-sdk&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false" alt="GitHub Hits"/></a>
+    <a href="https://pypi.org/project/swarmauri_typing/">
+        <img src="https://img.shields.io/pypi/pyversions/swarmauri" alt="PyPI - Python Version"/></a>
+    <a href="https://pypi.org/project/swarmauri_typing/">
+        <img src="https://img.shields.io/pypi/l/swarmauri_typing" alt="PyPI - License"/></a>
+    <br />
+    <a href="https://pypi.org/project/swarmauri/">
+        <img src="https://img.shields.io/pypi/v/swarmauri?label=swarmauri_typing&color=green" alt="PyPI - swarmauri_core"/></a>
+</p>
+
+
+# Swarmauri Typing Library
+
+The Swarmauri Typing Library provides advanced type utilities for Python, enabling more expressive and flexible type annotations. It includes tools for creating intersection and union types dynamically.
+
+## Features
+
+- **Intersection Types**: Create intersection types that combine multiple classes.
+
+```python
+from typing import Type, TypeVar, Union, Any, Annotated, Tuple
+
+T = TypeVar("T")
+
+class IntersectionMetadata:
+    def __init__(self, classes: Tuple[Type[T]]):
+        self.classes = classes
+
+    def __repr__(self):
+        return f"IntersectionMetadata(classes={self.classes!r})"
+
+class Intersection(type):
+    def __class_getitem__(cls, classes: Union[Type, Tuple[Type, ...]]) -> type:
+        if not isinstance(classes, tuple):
+            classes = (classes,)
+
+        common = set(classes[0].__mro__)
+        for c in classes[1:]:
+            common.intersection_update(c.__mro__)
+
+        ordered_common = [c for c in classes[0].__mro__ if c in common]
+
+        if not ordered_common:
+            return Annotated[Any, IntersectionMetadata(classes=(classes))]
+        else:
+            union_type = Union[tuple(ordered_common)]
+            return Annotated[union_type, IntersectionMetadata(classes=(classes))]
+```
+
+- **Union Factory**: Dynamically create union types based on a provided function.
+
+```python
+from typing import Type, TypeVar, Callable, List, Union, Any, Annotated, get_args, Optional
+
+T = TypeVar("T")
+
+class UnionFactoryMetadata:
+    def __init__(self, data: Any, name: Optional[str] = None):
+        self.data = data
+        self.name = name or self.__class__.__name__
+
+    def __repr__(self):
+        return f"UnionFactoryMetadata(name={self.name!r}, data={self.data!r})"
+
+class UnionFactory:
+    def __init__(self, bound: Callable[[Type[T]], List[type]], name: str = None, annotation_extenders: List[Any] = None):
+        self.name = name or self.__class__.__name__
+        self._union_types_getter = bound
+        self._annotation_extenders = annotation_extenders or []
+
+    def _add_metadata(self, annotated_type: Any, new_metadata: Any) -> Any:
+        if not (hasattr(annotated_type, '__origin__') and annotated_type.__origin__ is Annotated):
+            return Annotated[annotated_type, new_metadata]
+
+        args = get_args(annotated_type)
+        base_type = args[0]
+        old_metadata = args[1:]
+        return Annotated[base_type, *old_metadata, new_metadata]
+
+    def __getitem__(self, input_data: Union[Type[T], str]) -> type:
+        if isinstance(input_data, str):
+            model_name = input_data
+        else:
+            model_name = input_data.__name__
+
+        union_members = self._union_types_getter(model_name)
+
+        if not union_members:
+            final_annotated = Annotated[Any, UnionFactoryMetadata(data=model_name, name=self.name)]
+        else:
+            union_type = Union[tuple(union_members)]
+            final_annotated = Annotated[union_type, UnionFactoryMetadata(data=model_name, name=self.name)]
+
+            for extension in self._annotation_extenders:
+                final_annotated = self._add_metadata(final_annotated, extension)
+
+        return final_annotated
+```
+
+## Getting Started
+
+To start using the Swarmauri Typing Library, include it as a module in your Python project. Ensure you have Python 3.10 or later installed.
+
+### Steps to install via pypi
+
+```sh
+pip install swarmauri-typing
+```
+
+### Usage Example
+
+```python
+from swarmauri_typing import Intersection, UnionFactory
+
+# Example of using Intersection
+class A: pass
+class B: pass
+
+IntersectionType = Intersection[A, B]
+
+# Example of using UnionFactory
+def my_types_getter(name: str):
+    return [A, B]
+
+union_factory = UnionFactory(my_types_getter)
+MyUnion = union_factory["MyModel"]
+```
+
+
+## Contributing
+
+Contributions are welcome! If you'd like to add a new feature, fix a bug, or improve documentation, kindly go through the [contributions guidelines](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) first.
+

swarmauri_typing-0.7.0.dev2/pyproject.toml

@@ -0,0 +1,57 @@
+[project]
+name = "swarmauri-typing"
+version = "0.7.0.dev2"
+description = "This repository includes typing used in the Swarmauri framework."
+authors = [
+    { name = "Jacob Stewart", email = "jacob@swarmauri.com" },
+    ]
+license = "Apache-2.0"
+readme = { file = "README.md", content-type = "text/markdown" }
+repository = "http://github.com/swarmauri/swarmauri-sdk"
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12"
+]
+requires-python = ">=3.10,<3.13"
+
+[tool.uv.sources]
+swarmauri_core = { workspace = true }
+
+[dependency-groups]
+dev = [
+"toml>=0.10.2",
+"pytest>=8.0.0",
+"pytest-xdist>=3.6.1",
+"pytest-asyncio>=0.24.0",
+"pytest-timeout>=2.3.1",
+"pytest-json-report>=1.5.0",
+"python-dotenv>=1.0.0",
+"pytest-mock>=3.14.0",
+"jsonschema>=4.18.5",
+"ruff>=0.9.9",
+]
+
+[tool.pytest.ini_options]
+markers = [
+    "test: standard test",
+    "unit: Unit tests",
+    "i9n: Integration Tests",
+    "r8n: Regression Tests",
+    "timeout: mark test to timeout after X seconds",
+    "xfail: Expected failures",
+    "xpass: Expected passes",
+    "acceptance: Acceptance tests"
+]
+
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)s] %(message)s"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+
+asyncio_default_fixture_loop_scope = "function"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

swarmauri_typing-0.7.0.dev2/swarmauri_typing/Intersection.py

@@ -0,0 +1,47 @@
+from typing import Type, TypeVar, Union, Any, Annotated, Tuple
+
+T = TypeVar("T")
+
+
+class IntersectionMetadata:
+    def __init__(self, classes: Tuple[Type[T]]):
+        self.classes = classes
+
+    def __repr__(self):
+        # Return a more 'developer-focused' string, e.g.:
+        return f"IntersectionMetadata(classes={self.classes!r})"
+
+
+# The Intersection metaclass as provided.
+class Intersection(type):
+    """
+    A generic metaclass to create an intersection of discriminated subclasses.
+    Usage:
+        Intersection[TypeA, TypeB, ...]
+    will return an Annotated Union of all registered classes that are common to
+    all given resource types.
+    """
+
+    def __class_getitem__(cls, classes: Union[Type, Tuple[Type, ...]]) -> type:
+        # Allow a single type or a tuple of types.
+        if not isinstance(classes, tuple):
+            classes = (classes,)
+
+        # Compute the intersection of all MRO sets.
+        common = set(classes[0].__mro__)
+        for c in classes[1:]:
+            common.intersection_update(c.__mro__)
+
+        # Order the common classes as they appear in the first class's MRO.
+        ordered_common = [c for c in classes[0].__mro__ if c in common]
+
+        if not ordered_common:
+            # Fallback to Any (should not happen as 'object' is always common)
+            return Annotated[Any, IntersectionMetadata(classes=(classes))]
+        else:
+            # Construct a Union type from the ordered common bases.
+            union_type = Union[tuple(ordered_common)]
+            return Annotated[
+                union_type,
+                IntersectionMetadata(classes=(classes)),
+            ]

swarmauri_typing-0.7.0.dev2/swarmauri_typing/UnionFactory.py

@@ -0,0 +1,109 @@
+from typing import (
+    Type,
+    TypeVar,
+    Callable,
+    List,
+    Union,
+    Any,
+    Annotated,
+    get_args,
+    Optional,
+)
+
+T = TypeVar("T")
+
+
+class UnionFactoryMetadata:
+    """
+    Stores any metadata related to the union created by 'UnionFactory'.
+    You can store anything you like in here (e.g., the original input
+    or other context data).
+    """
+
+    def __init__(self, data: Any, name: Optional[str] = None):
+        self.data = data
+        self.name = name or self.__class__.__name__
+
+    def __repr__(self):
+        # Return a more 'developer-focused' string, e.g.:
+        return f"UnionFactoryMetadata(name={self.name!r}, data={self.data!r})"
+
+
+class UnionFactory:
+    """
+    A configurable factory for creating Annotated Union types.
+
+    This can be used for many scenarios—e.g., uniting a set of classes
+    discovered dynamically, or enumerating a set of allowed types
+    based on a function you supply.
+    """
+
+    def __init__(
+        self,
+        bound: Callable[[Type[T]], List[type]],
+        name: "str" = None,
+        annotation_extenders: List[Any] = None,
+    ):
+        """
+        :param bound:
+            A function that takes an input (like a parent class or any other
+            context) and returns a list of types to be included in the union.
+        :param annotation_extenders:
+            A list of metadata items to be appended (in order) to the final
+            Annotated[...] union (beyond the default UnionFactoryMetadata).
+        """
+        self.name = name or self.__class__.__name__
+        self._union_types_getter = bound
+        self._annotation_extenders = annotation_extenders or []
+
+    def _add_metadata(self, annotated_type: Any, new_metadata: Any) -> Any:
+        """
+        Appends 'new_metadata' to an existing Annotated type,
+        or wraps a bare type in Annotated if it's not already Annotated.
+        """
+        if not (
+            hasattr(annotated_type, "__origin__")
+            and annotated_type.__origin__ is Annotated
+        ):
+            return Annotated[annotated_type, new_metadata]
+
+        args = get_args(annotated_type)
+        base_type = args[0]
+        old_metadata = args[1:]
+        return Annotated[base_type, *old_metadata, new_metadata]
+
+    def __getitem__(self, input_data: Union[Type[T], str]) -> type:
+        """
+        Usage example:
+          union_factory = UnionFactory(my_types_getter, [meta1, meta2])
+          MyUnion = union_factory[MyParentClassOrOtherInput]
+
+        Returns:
+          An Annotated[...] union (or Annotated[Any, ...]) with:
+            • A UnionFactoryMetadata object referencing 'input_data'
+            • Any additional metadata from 'annotation_extenders'
+        """
+
+        if isinstance(input_data, str):
+            model_name = input_data
+        else:
+            model_name = input_data.__name__
+
+        union_members = self._union_types_getter(model_name)
+
+        # If no types are returned, fall back to Annotated[Any, UnionFactoryMetadata]
+        if not union_members:
+            final_annotated = Annotated[
+                Any, UnionFactoryMetadata(data=model_name, name=self.name)
+            ]
+        else:
+            union_type = Union[tuple(union_members)]
+            final_annotated = Annotated[
+                union_type, UnionFactoryMetadata(data=model_name, name=self.name)
+            ]
+
+            # Add any additional metadata
+            for extension in self._annotation_extenders:
+                final_annotated = self._add_metadata(final_annotated, extension)
+
+        return final_annotated

swarmauri_typing-0.7.0.dev2/swarmauri_typing/__init__.py

@@ -0,0 +1,22 @@
+from .UnionFactory import UnionFactory, UnionFactoryMetadata
+from .Intersection import Intersection, IntersectionMetadata
+
+__all__ = [
+    "UnionFactory",
+    "UnionFactoryMetadata",
+    "Intersection",
+    "IntersectionMetadata",
+]
+
+try:
+    # For Python 3.8 and newer
+    from importlib.metadata import version, PackageNotFoundError
+except ImportError:
+    # For older Python versions, use the backport
+    from importlib_metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("swarmauri_typing")
+except PackageNotFoundError:
+    # If the package is not installed (for example, during development)
+    __version__ = "0.0.0"