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

hammad/json/__init__.py

@@ -1,21 +0,0 @@
-"""hammad.utils.json"""
-
-from typing import TYPE_CHECKING
-from .._core._utils._import_utils import _auto_create_getattr_loader
-
-if TYPE_CHECKING:
-    from .converters import (
-        convert_to_json_schema,
-        encode_json,
-        decode_json,
-    )
-
-__all__ = ("convert_to_json_schema", "encode_json", "decode_json")
-
-
-__getattr__ = _auto_create_getattr_loader(__all__)
-
-
-def __dir__() -> list[str]:
-    """Get the attributes of the json module."""
-    return list(__all__)

hammad/json/converters.py

@@ -1,152 +0,0 @@
-"""hammad.utils.json.utils
-
-Contains various utility functions used when working with JSON data."""
-
-import dataclasses
-from typing import Any
-import msgspec
-from msgspec.json import encode as encode_json, decode as decode_json
-
-from ..typing import get_type_description, inspection
-
-__all__ = (
-    "SchemaError",
-    "convert_to_json_schema",
-    "encode",
-    "decode",
-)
-
-
-class SchemaError(Exception):
-    """An exception raised when a schema utility raises an error."""
-
-
-def convert_to_json_schema(t: Any) -> dict:
-    """Converts various objects, types, and interfaces into
-    a JSON schema.
-
-    Args:
-        t: The object, type, or interface to convert to a JSON schema.
-
-    Returns:
-        A JSON schema as a dictionary.
-    """
-    from dataclasses import is_dataclass, fields as dataclass_fields
-    import inspect
-    from typing import get_type_hints
-
-    schema = {"type": "object", "properties": {}}
-
-    # Handle msgspec Struct
-    try:
-        if isinstance(t, type) and issubclass(t, msgspec.Struct):
-            struct_info = msgspec.structs.fields(t)
-            for field in struct_info:
-                field_type = field.type
-                field_schema = {
-                    "type": get_type_description(field_type),
-                    "description": f"Field of type {get_type_description(field_type)}",
-                }
-                if field.default is not msgspec.NODEFAULT:
-                    field_schema["default"] = field.default
-                schema["properties"][field.name] = field_schema
-            return schema
-    except (ImportError, AttributeError):
-        pass
-
-    # Handle Pydantic models
-    try:
-        from pydantic import BaseModel
-
-        if isinstance(t, type) and issubclass(t, BaseModel):
-            pydantic_schema = (
-                t.model_json_schema() if hasattr(t, "model_json_schema") else t.schema()
-            )
-            return pydantic_schema
-    except ImportError:
-        pass
-
-    # Handle dataclasses
-    if is_dataclass(t):
-        if isinstance(t, type):
-            # Class-level dataclass
-            for field in dataclass_fields(t):
-                field_type = field.type
-                field_schema = {
-                    "type": get_type_description(field_type),
-                    "description": f"Field of type {get_type_description(field_type)}",
-                }
-                if field.default is not dataclasses.MISSING:
-                    field_schema["default"] = field.default
-                elif field.default_factory is not dataclasses.MISSING:
-                    field_schema["default"] = "factory function"
-                schema["properties"][field.name] = field_schema
-        else:
-            # Instance-level dataclass
-            for field in dataclass_fields(t):
-                field_type = field.type
-                field_schema = {
-                    "type": get_type_description(field_type),
-                    "description": f"Field of type {get_type_description(field_type)}",
-                    "value": getattr(t, field.name, None),
-                }
-                schema["properties"][field.name] = field_schema
-        return schema
-
-    # Handle regular classes with type hints (including abstract classes)
-    if inspect.isclass(t):
-        try:
-            type_hints = get_type_hints(t)
-            for name, type_hint in type_hints.items():
-                schema["properties"][name] = {
-                    "type": get_type_description(type_hint),
-                    "description": f"Field of type {get_type_description(type_hint)}",
-                }
-        except (NameError, AttributeError):
-            pass
-        return schema
-
-    # Handle dictionary
-    if isinstance(t, dict):
-        for key, value in t.items():
-            schema["properties"][key] = {
-                "type": type(value).__name__,
-                "description": f"Field of type {type(value).__name__}",
-                "example": value,
-            }
-        return schema
-
-    # Handle basic types and type hints
-    origin = inspection.get_origin(t)
-    if origin is not None:
-        args = inspection.get_args(t)
-        if origin is list and args:
-            return {"type": "array", "items": {"type": get_type_description(args[0])}}
-        elif origin is dict and len(args) == 2:
-            return {
-                "type": "object",
-                "additionalProperties": {"type": get_type_description(args[1])},
-                "description": f"Object with {get_type_description(args[0])} keys",
-            }
-        elif origin is tuple and args:
-            return {
-                "type": "array",
-                "items": [{"type": get_type_description(arg)} for arg in args],
-                "minItems": len(args),
-                "maxItems": len(args),
-            }
-        elif inspection.is_union_type(t):
-            if inspection.is_optional_type(t):
-                non_none_args = [arg for arg in args if arg is not type(None)]
-                if non_none_args:
-                    return {
-                        "type": get_type_description(non_none_args[0]),
-                        "nullable": True,
-                    }
-            else:
-                return {"anyOf": [{"type": get_type_description(arg)} for arg in args]}
-        elif inspection.is_literal_type(t) and args:
-            return {"enum": list(args)}
-
-    # Default to string representation of type
-    return {"type": get_type_description(t)}

hammad/logging/__init__.py

@@ -1,35 +0,0 @@
-"""hammad.logging"""
-
-from typing import TYPE_CHECKING
-from .._core._utils._import_utils import _auto_create_getattr_loader
-
-if TYPE_CHECKING:
-    from .logger import Logger, create_logger, create_logger_level, LoggerLevelName
-    from .decorators import (
-        trace_function,
-        trace_cls,
-        trace,
-        trace_http,
-        install_trace_http,
-    )
-
-
-__all__ = (
-    "Logger",
-    "LoggerLevelName",
-    "create_logger",
-    "create_logger_level",
-    "trace_function",
-    "trace_cls",
-    "trace",
-    "trace_http",
-    "install_trace_http",
-)
-
-
-__getattr__ = _auto_create_getattr_loader(__all__)
-
-
-def __dir__() -> list[str]:
-    """Get the attributes of the logging module."""
-    return list(__all__)