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

hammad/ai/embeddings/types.py

@@ -1,69 +0,0 @@
-"""hammad.ai.embeddings.types"""
-
-from typing import List, Literal
-
-from pydantic import BaseModel
-
-__all__ = (
-    "Embedding",
-    "EmbeddingUsage",
-    "EmbeddingResponse",
-)
-
-
-class Embedding(BaseModel):
-    embedding: List[float]
-    """The embedding vector, which is a list of floats.
-
-    The length of vector depends on the model as listed in the
-    [embedding guide](https://platform.openai.com/docs/guides/embeddings).
-    """
-
-    index: int
-    """The index of the embedding in the list of embeddings."""
-
-    object: Literal["embedding"]
-    """The object type, which is always "embedding"."""
-
-    @property
-    def dimensions(self) -> int:
-        """The dimensions of the embedding."""
-        return len(self.embedding)
-
-
-class EmbeddingUsage(BaseModel):
-    """Usage statistics for embedding requests."""
-
-    prompt_tokens: int
-    """The number of tokens used by the prompt."""
-
-    total_tokens: int
-    """The total number of tokens used by the request."""
-
-
-class EmbeddingResponse(BaseModel):
-    data: List[Embedding]
-    """The list of embeddings generated by the model."""
-
-    model: str
-    """The name of the model used to generate the embedding."""
-
-    object: Literal["list"]
-    """The object type, which is always "list"."""
-
-    usage: EmbeddingUsage
-    """The usage information for the request."""
-
-    @property
-    def dimensions(self) -> int:
-        """The dimensions of the embedding."""
-        return len(self.data[0].embedding)
-
-    def __str__(self) -> str:
-        return (
-            "Embedding Response:\n"
-            f">>> Model: {self.model}\n"
-            f">>> Dimensions: {self.dimensions}\n"
-            f">>> Usage: {self.usage}\n"
-            f">>> Number of Generated Embeddings: {len(self.data)}\n"
-        )

hammad/cache/__init__.py

@@ -1,40 +0,0 @@
-"""hammad.cache"""
-
-from typing import TYPE_CHECKING
-from ..performance.imports import create_getattr_importer
-
-
-if TYPE_CHECKING:
-    from .base_cache import BaseCache, CacheParams, CacheReturn, CacheType
-    from .file_cache import FileCache, FileCacheLocation
-    from .ttl_cache import TTLCache
-    from .cache import Cache, create_cache
-    from .decorators import cached, auto_cached, clear_decorator_cache
-
-
-__all__ = (
-    # hammad.performance.cache.base_cache
-    "BaseCache",
-    "CacheParams",
-    "CacheReturn",
-    "CacheType",
-    # hammad.performance.cache.file_cache
-    "FileCache",
-    "FileCacheLocation",
-    # hammad.performance.cache.ttl_cache
-    "TTLCache",
-    # hammad.performance.cache.cache
-    "Cache",
-    "create_cache",
-    # hammad.performance.cache.decorators
-    "cached",
-    "auto_cached",
-    "clear_decorator_cache",
-)
-
-
-__getattr__ = create_getattr_importer(__all__)
-
-
-def __dir__() -> list[str]:
-    return sorted(__all__)

hammad/cache/base_cache.py

@@ -1,181 +0,0 @@
-"""hammad.cache.base_cache"""
-
-from dataclasses import dataclass
-import hashlib
-import inspect
-from typing import Any, Literal, ParamSpec, TypeAlias, TypeVar, get_args
-
-__all__ = (
-    "BaseCache",
-    "CacheType",
-    "CacheParams",
-    "CacheReturn",
-)
-
-
-CacheType: TypeAlias = Literal["ttl", "file"]
-"""Type of caches that can be created using `hammad`.
-
-- `"ttl"`: Time-to-live cache.
-- `"file"`: File-based cache.
-"""
-
-CacheParams = ParamSpec("CacheParams")
-"""Parameter specification for cache functions."""
-
-CacheReturn = TypeVar("CacheReturn")
-"""Return type for cache functions."""
-
-
-@dataclass
-class BaseCache:
-    """Base class for all caches created using `hammad`."""
-
-    type: CacheType
-    """Type of cache."""
-
-    def __post_init__(self) -> None:
-        """Post-initialization hook."""
-        if self.type not in get_args(CacheType):
-            raise ValueError(f"Invalid cache type: {self.type}")
-
-    def __contains__(self, key: str) -> bool:
-        """Check if key exists in cache."""
-        raise NotImplementedError("Subclasses must implement __contains__")
-
-    def __getitem__(self, key: str) -> Any:
-        """Get value for key."""
-        raise NotImplementedError("Subclasses must implement __getitem__")
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        """Set value for key."""
-        raise NotImplementedError("Subclasses must implement __setitem__")
-
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get value with default if key doesn't exist."""
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def clear(self) -> None:
-        """Clear all cached items."""
-        raise NotImplementedError("Subclasses must implement clear")
-
-    def make_hashable(self, obj: Any) -> str:
-        """
-        Convert any object to a stable hash string.
-
-        Uses SHA-256 to generate consistent hash representations.
-        Handles nested structures recursively.
-
-        Args:
-            obj: Object to hash
-
-        Returns:
-            Hexadecimal hash string
-        """
-
-        def _hash_obj(data: Any) -> str:
-            """Internal recursive hashing function with memoization."""
-            # Handle None first
-            if data is None:
-                return "null"
-
-            if isinstance(data, bool):
-                return f"bool:{data}"
-            elif isinstance(data, int):
-                return f"int:{data}"
-            elif isinstance(data, float):
-                if data != data:  # NaN
-                    return "float:nan"
-                elif data == float("inf"):
-                    return "float:inf"
-                elif data == float("-inf"):
-                    return "float:-inf"
-                else:
-                    return f"float:{data}"
-            elif isinstance(data, str):
-                return f"str:{data}"
-            elif isinstance(data, bytes):
-                return f"bytes:{data.hex()}"
-
-            # Handle collections
-            elif isinstance(data, (list, tuple)):
-                collection_type = "list" if isinstance(data, list) else "tuple"
-                items = [_hash_obj(item) for item in data]
-                return f"{collection_type}:[{','.join(items)}]"
-
-            elif isinstance(data, set):
-                try:
-                    sorted_items = sorted(data, key=lambda x: str(x))
-                except TypeError:
-                    sorted_items = sorted(
-                        data, key=lambda x: (type(x).__name__, str(x))
-                    )
-                items = [_hash_obj(item) for item in sorted_items]
-                return f"set:{{{','.join(items)}}}"
-
-            elif isinstance(data, dict):
-                try:
-                    sorted_items = sorted(data.items(), key=lambda x: str(x[0]))
-                except TypeError:
-                    # Fallback for non-comparable keys
-                    sorted_items = sorted(
-                        data.items(), key=lambda x: (type(x[0]).__name__, str(x[0]))
-                    )
-                pairs = [f"{_hash_obj(k)}:{_hash_obj(v)}" for k, v in sorted_items]
-                return f"dict:{{{','.join(pairs)}}}"
-
-            elif isinstance(data, type):
-                module = getattr(data, "__module__", "builtins")
-                qualname = getattr(data, "__qualname__", data.__name__)
-                return f"type:{module}.{qualname}"
-
-            elif callable(data):
-                module = getattr(data, "__module__", "unknown")
-                qualname = getattr(
-                    data, "__qualname__", getattr(data, "__name__", "unknown_callable")
-                )
-
-                try:
-                    source = inspect.getsource(data)
-                    normalized_source = " ".join(source.split())
-                    return f"callable:{module}.{qualname}:{hash(normalized_source)}"
-                except (OSError, TypeError, IndentationError):
-                    return f"callable:{module}.{qualname}"
-
-            elif hasattr(data, "__dict__"):
-                class_info = (
-                    f"{data.__class__.__module__}.{data.__class__.__qualname__}"
-                )
-                obj_dict = {"__class__": class_info, **data.__dict__}
-                return f"object:{_hash_obj(obj_dict)}"
-
-            elif hasattr(data, "__slots__"):
-                class_info = (
-                    f"{data.__class__.__module__}.{data.__class__.__qualname__}"
-                )
-                slot_dict = {
-                    slot: getattr(data, slot, None)
-                    for slot in data.__slots__
-                    if hasattr(data, slot)
-                }
-                obj_dict = {"__class__": class_info, **slot_dict}
-                return f"slotted_object:{_hash_obj(obj_dict)}"
-
-            else:
-                try:
-                    repr_str = repr(data)
-                    return f"repr:{type(data).__name__}:{repr_str}"
-                except Exception:
-                    # Ultimate fallback
-                    return f"unknown:{type(data).__name__}:{id(data)}"
-
-        # Generate the hash representation
-        hash_representation = _hash_obj(obj)
-
-        # Create final SHA-256 hash
-        return hashlib.sha256(
-            hash_representation.encode("utf-8", errors="surrogatepass")
-        ).hexdigest()

hammad/cache/cache.py

@@ -1,169 +0,0 @@
-"""hammad.cache.cache"""
-
-from typing import (
-    overload,
-    TYPE_CHECKING,
-    Literal,
-    Optional,
-    Any,
-    Union,
-    get_args,
-)
-from pathlib import Path
-
-from .base_cache import BaseCache, CacheType
-from .file_cache import FileCache, FileCacheLocation
-from .ttl_cache import TTLCache
-
-
-__all__ = ("Cache", "create_cache")
-
-
-class Cache:
-    """
-    Helper factory class for creating cache instances.
-
-    Example usage:
-        ttl_cache = Cache(type="ttl", maxsize=100, ttl=60)
-        file_cache = Cache(type="file", location="cache.pkl")
-    """
-
-    @overload
-    def __new__(
-        cls,
-        type: Literal["ttl"] = "ttl",
-        *,
-        maxsize: Optional[int] = None,
-        ttl: Optional[int] = None,
-    ) -> "TTLCache":
-        """
-        Create a new TTL (Time To Live) cache instance.
-
-        Args:
-            type: The type of cache to create.
-            maxsize: The maximum number of items to store in the cache.
-            ttl: The time to live for items in the cache.
-
-        Returns:
-            A new TTL cache instance.
-        """
-        ...
-
-    @overload
-    def __new__(
-        cls, type: Literal["file"], *, location: Optional["FileCacheLocation"] = None
-    ) -> "FileCache":
-        """
-        Create a new file cache instance.
-
-        Args:
-            type: The type of cache to create.
-            location: The directory to store the cache files.
-
-        Returns:
-            A new disk cache instance.
-        """
-        ...
-
-    def __new__(cls, type: "CacheType" = "ttl", **kwargs: Any) -> "BaseCache":
-        """
-        Create a new cache instance.
-        """
-        if type == "ttl":
-            from .ttl_cache import TTLCache
-
-            valid_ttl_params = {"maxsize", "ttl"}
-            ttl_constructor_kwargs = {
-                k: v
-                for k, v in kwargs.items()
-                if k in valid_ttl_params and v is not None
-            }
-            return TTLCache(type=type, **ttl_constructor_kwargs)
-        elif type == "file":
-            from .file_cache import FileCache
-
-            valid_file_params = {"location"}
-            file_constructor_kwargs = {
-                k: v
-                for k, v in kwargs.items()
-                if k in valid_file_params and v is not None
-            }
-            return FileCache(type=type, **file_constructor_kwargs)
-        else:
-            supported_types_tuple = get_args(CacheType)
-            raise ValueError(
-                f"Unsupported cache type: {type}. Supported types are: {supported_types_tuple}"
-            )
-
-
-# Factory
-
-
-@overload
-def create_cache(
-    type: Literal["ttl"], *, maxsize: int = 128, ttl: Optional[float] = None
-) -> "TTLCache": ...
-
-
-@overload
-def create_cache(
-    type: Literal["file"],
-    *,
-    location: Optional["FileCacheLocation"] = None,
-    maxsize: int = 128,
-) -> "FileCache": ...
-
-
-@overload
-def create_cache(type: "CacheType", **kwargs: Any) -> "BaseCache": ...
-
-
-def create_cache(type: "CacheType", **kwargs: Any) -> "BaseCache":
-    """
-    Factory function to create cache instances of different types.
-
-    Args:
-        type: The type of cache to create. Can be "ttl" or "file".
-        **kwargs: Additional keyword arguments specific to the cache type.
-
-    Returns:
-        A cache instance of the specified type.
-
-    Raises:
-        ValueError: If an unsupported cache type is provided.
-
-    Examples:
-        ```python
-        # Create a TTL cache with custom settings
-        ttl_cache = create_cache("ttl", maxsize=256, ttl=300)
-
-        # Create a file cache with custom location
-        file_cache = create_cache("file", location="/tmp/my_cache", maxsize=1000)
-        ```
-    """
-    if type == "ttl":
-        from .ttl_cache import TTLCache
-
-        maxsize = kwargs.pop("maxsize", 128)
-        ttl = kwargs.pop("ttl", None)
-        if kwargs:
-            raise TypeError(
-                f"Unexpected keyword arguments for TTL cache: {list(kwargs.keys())}"
-            )
-        return TTLCache(maxsize=maxsize, ttl=ttl)
-    elif type == "file":
-        from .file_cache import FileCache
-
-        location = kwargs.pop("location", None)
-        # FileCache doesn't support maxsize, so we just ignore it
-        kwargs.pop("maxsize", None)
-        if kwargs:
-            raise TypeError(
-                f"Unexpected keyword arguments for file cache: {list(kwargs.keys())}"
-            )
-        return FileCache(location=location, type=type)
-    else:
-        valid_types = get_args("CacheType")
-        raise ValueError(
-            f"Unsupported cache type: {type}. Valid types are: {valid_types}"
-        )