hammad-python 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

hammad/pydantic/models/cacheable_model.py

@@ -1,79 +0,0 @@
-"""hammad.pydantic.models.cacheable_model"""
-
-from typing import Any, Callable, Dict, Optional
-from functools import wraps
-
-from .subscriptable_model import SubscriptableModel
-
-__all__ = ("CacheableModel",)
-
-
-class CacheableModel(SubscriptableModel):
-    """
-    A model with built-in caching for computed properties.
-    Automatically caches expensive computations and invalidates when dependencies change.
-
-    Usage:
-        >>> class MyModel(CacheableModel):
-        ...     value: int
-        ...     @CacheableModel.cached_property(dependencies=["value"])
-        ...     def expensive_computation(self) -> int:
-        ...         return self.value ** 2
-        >>> model = MyModel(value=10)
-        >>> model.expensive_computation  # Computed once
-        >>> model.expensive_computation  # Returns cached value
-    """
-
-    def __init__(self, **data: Any):
-        super().__init__(**data)
-        self._cache: Dict[str, Any] = {}
-        self._cache_dependencies: Dict[str, list] = {}
-
-    @classmethod
-    def cached_property(cls, dependencies: Optional[list] = None):
-        """Decorator for creating cached properties with optional dependencies."""
-
-        def decorator(func: Callable) -> property:
-            prop_name = func.__name__
-            deps = dependencies or []
-
-            @wraps(func)
-            def wrapper(self) -> Any:
-                # Check if cached and dependencies haven't changed
-                if prop_name in self._cache:
-                    if not deps or all(
-                        getattr(self, dep) == self._cache.get(f"_{dep}_snapshot")
-                        for dep in deps
-                    ):
-                        return self._cache[prop_name]
-
-                # Compute and cache
-                result = func(self)
-                self._cache[prop_name] = result
-
-                # Store dependency snapshots
-                for dep in deps:
-                    self._cache[f"_{dep}_snapshot"] = getattr(self, dep)
-
-                return result
-
-            return property(wrapper)
-
-        return decorator
-
-    def clear_cache(self, property_name: Optional[str] = None) -> None:
-        """Clear cache for specific property or all cached properties."""
-        if property_name:
-            self._cache.pop(property_name, None)
-        else:
-            self._cache.clear()
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        # Invalidate cache when dependencies change
-        if hasattr(self, "_cache") and name in self.__class__.model_fields:
-            # Clear cache for properties that depend on this field
-            for prop_name, deps in getattr(self, "_cache_dependencies", {}).items():
-                if name in deps:
-                    self._cache.pop(prop_name, None)
-
-        super().__setattr__(name, value)

hammad/pydantic/models/fast_model.py

@@ -1,318 +0,0 @@
-"""hammad.pydantic.models.fast_model"""
-
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, TypeVar, Generic
-from pydantic import BaseModel, ConfigDict
-from dataclasses import dataclass
-import copy
-
-T = TypeVar("T")
-
-__all__ = ("FastModel",)
-
-
-class FastModel(BaseModel, Generic[T]):
-    """
-    FastModel = Pydantic BaseModel with IDE friendly(auto code completion),
-    dot-accessible attributes with extended type hints & utilizing the
-    Pydantic style `model_..` method naming convention to avoid conflicts.
-
-    Combines the power of Pydantic BaseModel with dictionary-like access patterns.
-
-    Examples:
-
-        ```python
-        model = FastModel(name="John", age=30)
-
-        print(model.name)
-        print(model.age)
-
-        model.name = "Jane"
-        print(model.name)
-
-        model.age = 25
-
-        # Dictionary-like access
-        print(model["name"])
-        model["age"] = 30
-        ```
-    """
-
-    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
-
-    def __init__(self: "FastModel[T]", *args: Any, **kwargs: Any) -> None:
-        # Handle dictionary-like initialization
-        if args and len(args) == 1 and isinstance(args[0], dict):
-            kwargs.update(args[0])
-            args = ()
-
-        super().__init__(**kwargs)
-
-        # Set all properties to None for annotated attributes not provided
-        for k, v in self.model_attr_types().items():
-            if k not in kwargs:
-                setattr(self, k, None)
-
-        # Set default values of annotated attributes
-        self.init()
-
-    def init(self: "FastModel[T]") -> None:
-        """Override this method to set default values."""
-        ...
-
-    def __getstate__(self: "FastModel[T]") -> dict[str, Any]:
-        return self.model_dump()
-
-    def __setstate__(self: "FastModel[T]", state: dict[str, Any]) -> "FastModel[T]":
-        return FastModel.model_from_dict(state)
-
-    def __deepcopy__(
-        self: "FastModel[T]", memo: Optional[dict[int, Any]] = None
-    ) -> "FastModel[T]":
-        # Get current field values
-        current_data = {}
-        for key in self.keys():
-            current_data[key] = getattr(self, key)
-
-        new = self.model_from_dict(current_data)
-        for key in self.__class__.model_fields.keys():
-            new.model_set_attribute(key, copy.deepcopy(getattr(self, key), memo=memo))
-        return new
-
-    # Dictionary-like access methods
-    def __getitem__(self: "FastModel[T]", key: str) -> Any:
-        """Get field value using dict-like access."""
-        if hasattr(self, key):
-            return getattr(self, key)
-        raise KeyError(key)
-
-    def __setitem__(self: "FastModel[T]", key: str, value: Any) -> None:
-        """Set field value using dict-like access."""
-        setattr(self, key, value)
-
-    def __contains__(self: "FastModel[T]", key: str) -> bool:
-        """Check if field exists using 'in' operator."""
-        return hasattr(self, key) or key in self.__class__.model_fields
-
-    def get(self: "FastModel[T]", key: str, default: Any = None) -> Any:
-        """Get field value with optional default."""
-        return getattr(self, key, default)
-
-    def keys(self: "FastModel[T]"):
-        """Return all field names."""
-        return list(self.__class__.model_fields.keys()) + [
-            k for k in self.__dict__.keys() if not k.startswith("_")
-        ]
-
-    def items(self: "FastModel[T]"):
-        """Return all field (name, value) pairs."""
-        for key in self.keys():
-            yield key, getattr(self, key)
-
-    def values(self: "FastModel[T]"):
-        """Return all field values."""
-        for key in self.keys():
-            yield getattr(self, key)
-
-    def update(self: "FastModel[T]", other: dict) -> None:
-        """Update multiple fields at once."""
-        for key, value in other.items():
-            setattr(self, key, value)
-
-    @classmethod
-    def model_from_dict(cls: type["FastModel[T]"], d: dict[str, Any]) -> "FastModel[T]":
-        return cls(**d)
-
-    @classmethod
-    def model_attr_has_default_value(cls: type["FastModel[T]"], attr_name: str) -> bool:
-        return hasattr(cls, attr_name) and not callable(getattr(cls, attr_name))
-
-    @classmethod
-    def model_get_attr_default_value(cls: type["FastModel[T]"], attr_name: str) -> Any:
-        if cls.model_attr_has_default_value(attr_name):
-            return getattr(cls, attr_name)
-        else:
-            return None
-
-    @classmethod
-    def model_attr_type(cls: type["FastModel[T]"], attr_name: str) -> type:
-        return cls.model_attr_types()[attr_name]
-
-    @classmethod
-    def model_attr_types(cls: type["FastModel[T]"]) -> dict[str, type]:
-        return cls.__annotations__ if hasattr(cls, "__annotations__") else {}
-
-    @classmethod
-    def model_attr_names(cls: type["FastModel[T]"]) -> List[str]:
-        """
-        Returns annotated attribute names
-        :return: List[str]
-        """
-        return [k for k, v in cls.model_attr_types().items()]
-
-    @classmethod
-    def model_has_attr(cls: type["FastModel[T]"], attr_name: str) -> bool:
-        """
-        Returns True if class have an annotated attribute
-        :param attr_name: Attribute name
-        :return: bool
-        """
-        return bool(cls.model_attr_types().get(attr_name))
-
-    def model_set_default(self: "FastModel[T]", attr_name: str) -> None:
-        if self.model_attr_has_default_value(attr_name):
-            attr_default_value: Any = self.model_get_attr_default_value(attr_name)
-            setattr(self, attr_name, attr_default_value)
-
-    def model_get_constructor(
-        self: "FastModel[T]", attr_name: str, value: Any
-    ) -> Tuple[Optional[Callable[..., Any]], Optional[type]]:
-        """
-        This method is used for type conversion.
-        FastModel uses this method to get the type of a value, then based on the
-        value, it return a constructor. If the type of a value is 'float' then
-        it returns 'float' since 'float' is also a constructor to build a float
-        value.
-        """
-        attr_type1: type = self.model_attr_type(attr_name)
-        constructor: Optional[Callable[..., Any]] = None
-        element_type: Optional[type] = None
-
-        if attr_type1 == float:
-            constructor = float
-        elif attr_type1 == str:
-            constructor = str
-        elif attr_type1 == int:
-            constructor = int
-        elif attr_type1 == list:
-            constructor = list
-        elif isinstance(value, FastModel):
-            constructor = attr_type1.model_from_dict
-        elif attr_type1 is Any:
-            constructor = None
-        elif isinstance(value, dict):
-            if attr_type1 == dict:
-                constructor = FastModel.model_from_dict
-            elif issubclass(attr_type1, FastModel):
-                constructor = self.model_attr_type(attr_name).model_from_dict
-        elif attr_type1 is List:
-            constructor = list
-        elif hasattr(attr_type1, "__origin__"):
-            if attr_type1.__dict__["__origin__"] is list:
-                # if the type is 'List[something]'
-                if len(attr_type1.__args__) == 0:
-                    constructor = list
-                elif len(attr_type1.__args__) == 1:
-                    constructor = List
-                    element_type = attr_type1.__args__[0]
-                elif len(attr_type1.__args__) > 1:
-                    raise TypeError("Only one dimensional List is supported")
-            elif attr_type1.__dict__["__origin__"] is tuple:
-                # if the type is 'Tuple[something]'
-                constructor = tuple
-
-        return constructor, element_type
-
-    def model_set_attribute(self: "FastModel[T]", attr_name: str, value: Any) -> None:
-        element_type: Optional[type] = None
-
-        # Check for reserved dict keys (restored from original FastModel)
-        dict_reserved_keys = vars(dict).keys()
-        if attr_name in dict_reserved_keys:
-            raise TypeError("You cannot set a reserved name as attribute")
-
-        if self.model_has_attr(attr_name):
-            if value is None:
-                setattr(self, attr_name, None)
-            elif self.model_attr_type(attr_name) == Any:
-                setattr(self, attr_name, value)
-            else:
-                constructor, element_type = self.model_get_constructor(attr_name, value)
-                if constructor is None:
-                    setattr(self, attr_name, value)
-                elif constructor == List:
-                    # NOTE: fix typing
-                    value_list: List[Any] = value
-                    new_list: List[Any] = []
-
-                    if element_type and issubclass(element_type, FastModel):
-                        element_constructor: Callable[[Any], Any] = (
-                            element_type.model_from_dict
-                        )
-                    else:
-                        element_constructor = (
-                            element_type if element_type else lambda x: x
-                        )
-
-                    for v in value_list:
-                        new_list.append(element_constructor(v))
-                    setattr(self, attr_name, new_list)
-                elif constructor == list:
-                    setattr(self, attr_name, list(value))
-                else:
-                    setattr(self, attr_name, constructor(value))
-        else:
-            if isinstance(value, dict):
-                if isinstance(value, FastModel):
-                    constructor: Callable[[Any], Any] = value.model_from_dict
-                else:
-                    constructor = FastModel.model_from_dict
-                setattr(self, attr_name, constructor(value))
-            else:
-                setattr(self, attr_name, value)
-
-    def model_set_attributes(self: "FastModel[T]", **d: Any) -> None:
-        for k, v in d.items():
-            self.model_set_attribute(k, v)
-
-    def __getattr__(self: "FastModel[T]", item: str) -> T:
-        """Handle missing attribute access like the original FastModel."""
-        # Avoid infinite recursion by checking the actual object dict and model fields
-        if item in self.__class__.model_fields or item in self.__dict__:
-            return getattr(self, item)
-
-        raise AttributeError(
-            f"{type(self).__name__!r} object has no attribute {item!r}"
-        )
-
-    def to_dict(
-        self: "FastModel[T]",
-        *args: Any,
-        exclude: Optional[List[str]] = None,
-        is_recursive: bool = False,
-        exclude_none: bool = False,
-        exclude_none_in_lists: bool = False,
-        **kwargs: Any,
-    ) -> dict[str, T]:
-        """Convert to dictionary with various options."""
-        exclude_set: Set[str] = set(exclude) if exclude is not None else set()
-        ret: dict[str, T] = {}
-
-        for k in self.keys():
-            if k in exclude_set:
-                continue
-
-            v = getattr(self, k)
-
-            if exclude_none and v is None:
-                continue
-
-            if is_recursive and isinstance(v, FastModel):
-                ret[k] = v.to_dict(
-                    is_recursive=is_recursive,
-                    exclude_none=exclude_none,
-                    exclude_none_in_lists=exclude_none_in_lists,
-                )
-            elif exclude_none_in_lists and isinstance(v, list):
-                ret[k] = [
-                    item.to_dict(exclude_none=True, is_recursive=is_recursive)
-                    if isinstance(item, FastModel)
-                    else item
-                    for item in v
-                ]
-            else:
-                ret[k] = v
-
-        return ret
-
-    def model_to_dataclass(self) -> dataclass:
-        return dataclass(**self.model_dump())

hammad/pydantic/models/function_model.py

@@ -1,176 +0,0 @@
-"""hammad.pydantic.models.function_model"""
-
-from typing import Any, Callable, Dict, List, Optional, TypeVar, Generic, cast
-from pydantic import BaseModel
-import inspect
-from typing import get_type_hints
-
-try:
-    from typing import ParamSpec
-except ImportError:
-    from typing_extensions import ParamSpec
-
-__all__ = ("FunctionModel",)
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-class FunctionModel(BaseModel, Generic[P, R]):
-    """
-    A specialized pydantic model that acts as a "passthrough" for functions,
-    allowing for partial function application.
-
-    ```python
-    from cursives.pydantic.models import FunctionModel
-
-    @FunctionModel(exclude = ["y"])
-    def some_function(x: int, y: str = "1") -> int:
-        return x + len(y)
-
-    print(some_function.call(x=1))
-    >>> 2
-
-    print(some_function.function_schema())
-    # Create OpenAI compatible function schema easily!
-    >>> {
-    ...     "name": "some_function",
-    ...     "parameters": {
-    ...         "x": {"type": "integer"},
-    ...         "y": {"type": "string", "default": "1"}
-    ...     }
-    ... }
-
-    print(some_function.call_from_dict(...))
-    """
-
-    def __init__(self, exclude: Optional[List[str]] = None, **kwargs):
-        super().__init__(**kwargs)
-        self._exclude = exclude or []
-        self._original_function: Optional[Callable[P, R]] = None
-        self._function_name: Optional[str] = None
-        self._signature: Optional[inspect.Signature] = None
-        self._type_hints: Optional[Dict[str, Any]] = None
-
-    def __call__(
-        self, func: Callable[P, R], exclude: Optional[List[str]] = None
-    ) -> "FunctionModel[P, R]":
-        """Make this work as a decorator."""
-        self._original_function = func
-        self._function_name = func.__name__
-        self._signature = inspect.signature(func)
-        self._type_hints = get_type_hints(func)
-
-        # Create a new instance that wraps the function
-        # Use exclude parameter if provided, otherwise use self._exclude
-        final_exclude = exclude if exclude is not None else self._exclude
-        wrapped: FunctionModel[P, R] = FunctionModel(exclude=final_exclude)
-        wrapped._original_function = func
-        wrapped._function_name = func.__name__
-        wrapped._signature = self._signature
-        wrapped._type_hints = self._type_hints
-
-        return wrapped
-
-    def call(self, **kwargs) -> R:
-        """Call the wrapped function with provided arguments."""
-        if not self._original_function:
-            raise ValueError("No function wrapped. Use as decorator first.")
-
-        # Get all parameters from signature
-        sig_params = self._signature.parameters
-        final_kwargs = {}
-
-        # Add provided kwargs (but not excluded ones)
-        for key, value in kwargs.items():
-            if key in sig_params and key not in self._exclude:
-                final_kwargs[key] = value
-
-        # Add defaults for missing parameters (except excluded ones)
-        for param_name, param in sig_params.items():
-            if param_name not in final_kwargs and param_name not in self._exclude:
-                if param.default is not inspect.Parameter.empty:
-                    final_kwargs[param_name] = param.default
-
-        return self._original_function(**final_kwargs)
-
-    def call_from_dict(self, data: Dict[str, Any]) -> R:
-        """Call the function using a dictionary of arguments."""
-        return self.call(**data)
-
-    def function_schema(self) -> Dict[str, Any]:
-        """Generate OpenAI-compatible function schema."""
-        if not self._original_function:
-            raise ValueError("No function wrapped. Use as decorator first.")
-
-        schema = {
-            "name": self._function_name,
-            "description": self._original_function.__doc__ or "",
-            "parameters": {"type": "object", "properties": {}, "required": []},
-        }
-
-        # Process each parameter
-        for param_name, param in self._signature.parameters.items():
-            if param_name in self._exclude:
-                continue
-
-            param_type = self._type_hints.get(param_name, Any)
-
-            # Convert Python types to JSON schema types
-            json_type = self._python_type_to_json_schema(param_type)
-
-            param_schema = {"type": json_type}
-
-            # Add default if present
-            if param.default is not inspect.Parameter.empty:
-                param_schema["default"] = param.default
-            else:
-                schema["parameters"]["required"].append(param_name)
-
-            schema["parameters"]["properties"][param_name] = param_schema
-
-        return schema
-
-    def _python_type_to_json_schema(self, python_type: Any) -> str:
-        """Convert Python type to JSON schema type string."""
-        if python_type is int:
-            return "integer"
-        elif python_type is float:
-            return "number"
-        elif python_type is str:
-            return "string"
-        elif python_type is bool:
-            return "boolean"
-        elif python_type is list or python_type is List:
-            return "array"
-        elif python_type is dict or python_type is Dict:
-            return "object"
-        else:
-            return "string"  # Default fallback
-
-    def partial(self, **kwargs) -> "FunctionModel":
-        """Create a new FunctionModel with some arguments pre-filled."""
-        if not self._original_function:
-            raise ValueError("No function wrapped. Use as decorator first.")
-
-        def partial_func(**additional_kwargs):
-            combined_kwargs = {**kwargs, **additional_kwargs}
-            return self.call(**combined_kwargs)
-
-        # Create new wrapped function
-        new_wrapped = FunctionModel(exclude=self._exclude)
-        new_wrapped._original_function = partial_func
-        new_wrapped._function_name = f"{self._function_name}_partial"
-
-        # Update signature to remove pre-filled parameters
-        new_params = []
-        for param_name, param in self._signature.parameters.items():
-            if param_name not in kwargs:
-                new_params.append(param)
-
-        new_wrapped._signature = inspect.Signature(new_params)
-        new_wrapped._type_hints = {
-            k: v for k, v in self._type_hints.items() if k not in kwargs
-        }
-
-        return new_wrapped

hammad/pydantic/models/subscriptable_model.py

@@ -1,63 +0,0 @@
-"""hammad.pydantic.models.subscriptable_model"""
-
-from pydantic import BaseModel
-from typing import Any
-
-__all__ = ("SubscriptableModel",)
-
-
-class SubscriptableModel(BaseModel):
-    """
-    A pydantic model that allows for dict-like access to its fields.
-    """
-
-    def __getitem__(self, key: str) -> Any:
-        """Get field value using dict-like access.
-
-        Usage:
-            >>> msg = Message(role='user')
-            >>> msg['role']
-            'user'
-        """
-        if hasattr(self, key):
-            return getattr(self, key)
-        raise KeyError(key)
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        """Set field value using dict-like access.
-
-        Usage:
-            >>> msg = Message(role='user')
-            >>> msg['role'] = 'assistant'
-            >>> msg['role']
-            'assistant'
-        """
-        setattr(self, key, value)
-
-    def __contains__(self, key: str) -> bool:
-        """Check if field exists using 'in' operator.
-
-        Usage:
-            >>> msg = Message(role='user')
-            >>> 'role' in msg
-            True
-            >>> 'nonexistent' in msg
-            False
-        """
-        if hasattr(self, key):
-            return True
-        if value := self.__class__.model_fields.get(key):
-            return value.default is not None
-        return False
-
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get field value with optional default.
-
-        Usage:
-            >>> msg = Message(role='user')
-            >>> msg.get('role')
-            'user'
-            >>> msg.get('nonexistent', 'default')
-            'default'
-        """
-        return getattr(self, key) if hasattr(self, key) else default