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

hammad/data/models/__init__.py

@@ -5,35 +5,46 @@ models, as well as modules & utilities specifically for various interfaces
 of models such as `pydantic`."""
 
 from typing import TYPE_CHECKING
-from ...performance.imports import create_getattr_importer
+from ..._internal import create_getattr_importer
 
 if TYPE_CHECKING:
-    from .base import (
+    from .model import (
         Model,
-        field,
+        model_settings,
+    )
+    from .fields import (
+        field
+    )
+    from .utils import (
         validator,
         is_field,
         is_model,
-        model_settings
     )
-    from .pydantic import (
+    from .extensions.pydantic.converters import (
         convert_to_pydantic_model,
-        convert_to_pydantic_field
+        convert_to_pydantic_field,
+        is_pydantic_model_class
     )
 
 
 __all__ = (
-    # hammad.models.base
+    # hammad.lib.data.models.model
     "Model",
+    "model_settings",
+
+    # hammad.lib.data.models.fields
     "field",
+
+    # hammad.lib.data.models.utils
     "validator",
     "is_field",
     "is_model",
     "model_settings",
 
-    # hammad.models.pydantic
+    # hammad.lib.data.models.extensions.pydantic.converters
     "convert_to_pydantic_model",
     "convert_to_pydantic_field",
+    "is_pydantic_model_class",
 )
 
 
@@ -41,4 +52,4 @@ __getattr__ = create_getattr_importer(__all__)
 
 
 def __dir__() -> list[str]:
-    return list(__all__)
+    return list(__all__)

hammad/data/models/extensions/__init__.py

@@ -0,0 +1,4 @@
+"""hammad.models.extensions
+
+Contains a collection of resources specifically for external schemas or
+definitions for models."""

hammad/data/models/{pydantic → extensions/pydantic}/__init__.py

@@ -1,19 +1,12 @@
-"""hammad.models.pydantic
+"""hammad.data.models.extensions.pydantic
 
 Contains both models and pydantic **specific** utiltiies / resources
 meant for general case usage."""
 
 from typing import TYPE_CHECKING
-from ....performance.imports import create_getattr_importer
+from ....._internal import create_getattr_importer
 
 if TYPE_CHECKING:
-    from .models import (
-        ArbitraryModel,
-        CacheableModel,
-        FastModel,
-        FunctionModel,
-        SubscriptableModel,
-    )
     from .converters import (
         convert_to_pydantic_model,
         convert_to_pydantic_field,
@@ -27,14 +20,8 @@ if TYPE_CHECKING:
     )
 
 
-__all__ = (
-    # hammad.models.pydantic.models
-    "ArbitraryModel",
-    "CacheableModel",
-    "FastModel",
-    "FunctionModel",
-    "SubscriptableModel",
-    # hammad.models.pydantic.converters
+__all__ = [
+    # hammad.lib.pydantic.converters
     "convert_to_pydantic_model",
     "convert_to_pydantic_field",
     "convert_dataclass_to_pydantic_model",
@@ -44,7 +31,7 @@ __all__ = (
     "convert_type_to_pydantic_model",
     "create_confirmation_pydantic_model",
     "create_selection_pydantic_model",
-)
+]
 
 
 __getattr__ = create_getattr_importer(__all__)
@@ -52,4 +39,4 @@ __getattr__ = create_getattr_importer(__all__)
 
 def __dir__() -> list[str]:
     """Get the attributes of the models module."""
-    return list(__all__)
+    return __all__

hammad/data/models/{pydantic → extensions/pydantic}/converters.py

@@ -1,4 +1,4 @@
-"""hammad.data.models.pydantic.converters
+"""hammad.data.models.extensions.pydantic.converters
 
 Contains various converters for converting various objects into
 a Pydantic model. These converters are used to convert
@@ -28,8 +28,6 @@ from typing import (
 )
 from pydantic import BaseModel, Field, create_model
 
-from ....cache.decorators import cached
-
 from typing import get_origin, get_args
 from typing_inspect import is_generic_type
 
@@ -79,6 +77,38 @@ A mapping of types to their string representations. Used for hinting & JSON sche
 generation.
 """
 
+TYPE_NAME_MAPPING: Dict[Type, str] = {
+    int: "Integer",
+    float: "Float",
+    bool: "Boolean",
+    str: "String",
+    bytes: "Bytes",
+    list: "List",
+    tuple: "Tuple",
+    dict: "Dict",
+    set: "Set",
+    frozenset: "FrozenSet",
+}
+"""
+A mapping of basic types to their semantic model names.
+"""
+
+FIELD_NAME_MAPPING: Dict[Type, str] = {
+    int: "value",
+    float: "value",
+    bool: "flag",
+    str: "text",
+    bytes: "data",
+    list: "items",
+    tuple: "values",
+    dict: "mapping",
+    set: "elements",
+    frozenset: "elements",
+}
+"""
+A mapping of basic types to their semantic field names.
+"""
+
 
 # -----------------------------------------------------------------------------
 # Pydantic Model Utils
@@ -92,6 +122,104 @@ def is_pydantic_model_class(obj: Any) -> bool:
     return isinstance(obj, type) and issubclass(obj, BaseModel)
 
 
+def generate_semantic_model_name(type_hint: Type) -> str:
+    """
+    Generates a semantic model name based on the type.
+
+    Examples:
+        int -> "Integer"
+        str -> "String"
+        List[int] -> "IntegerList"
+        Dict[str, int] -> "StringIntegerDict"
+        Optional[int] -> "OptionalInteger"
+        Union[str, int] -> "StringIntegerUnion"
+    """
+    # Handle basic types
+    if type_hint in TYPE_NAME_MAPPING:
+        return TYPE_NAME_MAPPING[type_hint]
+
+    # Handle Optional types
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    if origin is Union:
+        # Check if it's Optional (Union with None)
+        if type(None) in args and len(args) == 2:
+            # This is Optional[T]
+            inner_type = next(arg for arg in args if arg is not type(None))
+            return f"Optional{generate_semantic_model_name(inner_type)}"
+        else:
+            # Regular Union
+            type_names = [
+                generate_semantic_model_name(arg)
+                for arg in args
+                if arg is not type(None)
+            ]
+            return "".join(type_names) + "Union"
+
+    # Handle generic types
+    if origin is not None:
+        origin_name = TYPE_NAME_MAPPING.get(origin, origin.__name__.capitalize())
+
+        if args:
+            # Generate names for type arguments
+            arg_names = [generate_semantic_model_name(arg) for arg in args]
+            if origin in (list, set, frozenset):
+                # For collections, append the element type
+                return f"{arg_names[0]}{origin_name}"
+            elif origin is dict:
+                # For dict, include both key and value types
+                return f"{arg_names[0]}{arg_names[1]}Dict"
+            elif origin is tuple:
+                # For tuple, join all types
+                return "".join(arg_names) + "Tuple"
+            else:
+                # For other generics, prepend type arguments
+                return "".join(arg_names) + origin_name
+
+        return origin_name
+
+    # Fallback to the type's name
+    if hasattr(type_hint, "__name__"):
+        return type_hint.__name__.capitalize()
+
+    return "GeneratedModel"
+
+
+def generate_semantic_field_name(type_hint: Type) -> str:
+    """
+    Generates a semantic field name based on the type.
+
+    Examples:
+        int -> "value"
+        str -> "text"
+        List[int] -> "items"
+        Dict[str, int] -> "mapping"
+        Optional[str] -> "text"
+    """
+    # Handle basic types
+    if type_hint in FIELD_NAME_MAPPING:
+        return FIELD_NAME_MAPPING[type_hint]
+
+    # Handle Optional types - use the inner type's field name
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    if origin is Union:
+        # Check if it's Optional (Union with None)
+        if type(None) in args and len(args) == 2:
+            # This is Optional[T] - use inner type's field name
+            inner_type = next(arg for arg in args if arg is not type(None))
+            return generate_semantic_field_name(inner_type)
+
+    # Handle generic types - use the origin's field name
+    if origin is not None and origin in FIELD_NAME_MAPPING:
+        return FIELD_NAME_MAPPING[origin]
+
+    # Default fallback
+    return "value"
+
+
 def get_pydantic_fields_from_function(func: Callable) -> Dict[str, Tuple[Type, Field]]:
     """
     Extracts Pydantic fields from a function's signature and docstring.
@@ -143,7 +271,6 @@ def get_pydantic_fields_from_function(func: Callable) -> Dict[str, Tuple[Type, F
         return {}
 
 
-@cached
 def convert_to_pydantic_field(
     type_hint: Type,
     index: Optional[int] = None,
@@ -155,8 +282,14 @@ def convert_to_pydantic_field(
     Returns a dictionary mapping a generated field name to its (type, Field) tuple.
     """
     try:
-        base_name, _ = JSON_TYPE_MAPPING.get(type_hint, ("value", type_hint))
-        field_name = f"value_{index}" if index is not None else "value"
+        # Use semantic field name if no index is provided
+        if index is None:
+            field_name = generate_semantic_field_name(type_hint)
+        else:
+            # Use indexed field name for sequences
+            base_name = generate_semantic_field_name(type_hint)
+            field_name = f"{base_name}_{index}"
+
         return {
             field_name: (
                 type_hint,
@@ -178,7 +311,6 @@ def convert_to_pydantic_field(
 # -----------------------------------------------------------------------------
 
 
-@cached
 def convert_dataclass_to_pydantic_model(
     target: Union[Type, Any],  # NOTE: DATACLASS TYPE OR INSTANCE
     init: bool,
@@ -229,7 +361,6 @@ def convert_dataclass_to_pydantic_model(
     return model_class
 
 
-@cached
 def convert_type_to_pydantic_model(
     target: Type,
     name: Optional[str],
@@ -237,19 +368,20 @@ def convert_type_to_pydantic_model(
     field_name: Optional[str],
     default: Any,
 ) -> Type[BaseModel]:
-    model_name = name or "GeneratedModel"
+    # Use semantic naming if no name is provided
+    model_name = name or generate_semantic_model_name(target)
+
     field_mapping = convert_to_pydantic_field(
         target, description=description, default=default
     )
 
-    if field_name:  # Override default field name "value"
+    if field_name:  # Override default field name if explicitly provided
         current_field_def = list(field_mapping.values())[0]
         field_mapping = {field_name: current_field_def}
 
     return create_model(model_name, __doc__=(description or ""), **field_mapping)
 
 
-@cached
 def convert_function_to_pydantic_model(
     target: Callable,
     name: Optional[str],
@@ -263,7 +395,6 @@ def convert_function_to_pydantic_model(
     return create_model(model_name, __doc__=model_doc, **fields)
 
 
-@cached
 def convert_sequence_to_pydantic_model(
     target: Sequence[Type],
     name: Optional[str],
@@ -308,7 +439,6 @@ def convert_sequence_to_pydantic_model(
     return create_model(model_name, __doc__=(description or ""), **pydantic_fields)
 
 
-@cached
 def convert_dict_to_pydantic_model(
     target: Dict[str, Any],
     init: bool,
@@ -330,7 +460,6 @@ def convert_dict_to_pydantic_model(
     return model_class
 
 
-@cached
 def _reconvert_to_pydantic_model_from_basemodel_instance(
     target: BaseModel,
     name: Optional[str],
@@ -563,7 +692,6 @@ def convert_to_pydantic_model(
 # -----------------------------------------------------------------------------
 
 
-@cached
 def create_selection_pydantic_model(
     fields: List[str],
     name: str = "Selection",
@@ -605,7 +733,6 @@ def create_selection_pydantic_model(
     )
 
 
-@cached
 def create_confirmation_pydantic_model(
     name: str = "Confirmation",
     description: Optional[str] = None,

hammad/data/models/{base/fields.py → fields.py}

@@ -1,4 +1,4 @@
-"""hammad.base.fields"""
+"""hammad.data.models.fields"""
 
 import re
 from dataclasses import dataclass

hammad/data/models/{base/model.py → model.py}

@@ -1,4 +1,4 @@
-"""hammad.base.model"""
+"""hammad.data.models.model"""
 
 import copy
 from functools import lru_cache

hammad/data/models/{base/utils.py → utils.py}

@@ -1,4 +1,4 @@
-"""hammad.base.utils"""
+"""hammad.data.models.utils"""
 
 from functools import lru_cache
 from typing import Any, Callable, Optional, Union, Tuple, Dict

hammad/data/sql/__init__.py

@@ -0,0 +1,23 @@
+"""hammad.data.sql"""
+
+from typing import TYPE_CHECKING
+from ..._internal import create_getattr_importer
+
+if TYPE_CHECKING:
+    from .types import DatabaseItemType, DatabaseItem
+    from .database import Database
+
+
+__all__ = (
+    "DatabaseItemType",
+    "DatabaseItem",
+    "Database",
+)
+
+
+__getattr__ = create_getattr_importer(__all__)
+
+
+def __dir__() -> list[str]:
+    """Get the attributes of the hammad.data.sql module."""
+    return list(__all__)