hammad-python 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

hammad/data/sql/types.py

@@ -17,11 +17,11 @@ import uuid
 
 __all__ = (
     "DatabaseItemType",
-    "DatabaseItemFilters", 
+    "DatabaseItemFilters",
     "DatabaseItem",
     "QueryOperator",
     "QueryCondition",
-    "QueryFilter"
+    "QueryFilter",
 )
 
 
@@ -35,21 +35,21 @@ DatabaseItemFilters: TypeAlias = Dict[str, object]
 
 
 QueryOperator = Literal[
-    "eq",      # equal
-    "ne",      # not equal
-    "gt",      # greater than
-    "gte",     # greater than or equal
-    "lt",      # less than
-    "lte",     # less than or equal
-    "in",      # in list
+    "eq",  # equal
+    "ne",  # not equal
+    "gt",  # greater than
+    "gte",  # greater than or equal
+    "lt",  # less than
+    "lte",  # less than or equal
+    "in",  # in list
     "not_in",  # not in list
-    "like",    # SQL LIKE
-    "ilike",   # case insensitive LIKE
-    "is_null", # IS NULL
-    "is_not_null", # IS NOT NULL
-    "contains", # for JSON contains
-    "startswith", # string starts with
-    "endswith",   # string ends with
+    "like",  # SQL LIKE
+    "ilike",  # case insensitive LIKE
+    "is_null",  # IS NULL
+    "is_not_null",  # IS NOT NULL
+    "contains",  # for JSON contains
+    "startswith",  # string starts with
+    "endswith",  # string ends with
 ]
 """Supported query operators for database queries."""
 
@@ -57,24 +57,24 @@ QueryOperator = Literal[
 @dataclass
 class QueryCondition:
     """Represents a single query condition for database filtering."""
-    
+
     field: str
     """The field name to filter on."""
-    
+
     operator: QueryOperator
     """The operator to use for comparison."""
-    
+
     value: Any = None
     """The value to compare against (not needed for is_null/is_not_null)."""
 
 
-@dataclass  
+@dataclass
 class QueryFilter:
     """Represents a collection of query conditions with logical operators."""
-    
+
     conditions: list[QueryCondition] = field(default_factory=list)
     """List of individual query conditions."""
-    
+
     logic: Literal["and", "or"] = "and"
     """Logical operator to combine conditions."""
 
@@ -83,52 +83,37 @@ class QueryFilter:
 class DatabaseItem(Generic[DatabaseItemType]):
     """Base class for all items that can be stored within a database."""
 
-    id: str = field(
-        default_factory=lambda: str(uuid.uuid4())
-    )
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
     """The unique identifier for this item."""
 
-    item: DatabaseItemType = field(
-        default_factory=lambda: None
-    )
+    item: DatabaseItemType = field(default_factory=lambda: None)
     """The item that is stored within this database item."""
 
-    created_at: datetime = field(
-        default_factory=lambda: datetime.now(timezone.utc)
-    )
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     """The timestamp when this item was created."""
 
-    updated_at: datetime = field(
-        default_factory=lambda: datetime.now(timezone.utc)
-    )
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     """The timestamp when this item was last updated."""
 
-    ttl: Optional[int] = field(
-        default=None
-    )
+    ttl: Optional[int] = field(default=None)
     """The time to live for this item in seconds."""
 
-    filters: DatabaseItemFilters = field(
-        default_factory=dict
-    )
+    filters: DatabaseItemFilters = field(default_factory=dict)
     """The filters that are associated with this item."""
-    
-    table_name: str = field(
-        default="default"
-    )
+
+    table_name: str = field(default="default")
     """The table/collection name where this item is stored."""
-    
-    score: Optional[float] = field(
-        default=None
-    )
+
+    score: Optional[float] = field(default=None)
     """The similarity score for this item (used in vector search results)."""
 
     def is_expired(self) -> bool:
         """Check if this item has expired based on its TTL."""
         if self.ttl is None:
             return False
-        
+
         from datetime import timedelta
+
         expires_at = self.created_at + timedelta(seconds=self.ttl)
         return datetime.now(timezone.utc) >= expires_at
 
@@ -136,6 +121,7 @@ class DatabaseItem(Generic[DatabaseItemType]):
         """Calculate when this item will expire."""
         if self.ttl is None:
             return None
-        
+
         from datetime import timedelta
-        return self.created_at + timedelta(seconds=self.ttl)
+
+        return self.created_at + timedelta(seconds=self.ttl)

hammad/formatting/__init__.py

@@ -16,5 +16,6 @@ __all__ = (
 
 __getattr__ = create_getattr_importer(__all__)
 
+
 def __dir__() -> list[str]:
-    return list(__all__)
+    return list(__all__)

hammad/formatting/json/converters.py

@@ -153,6 +153,6 @@ def convert_to_json_schema(t: Any) -> dict:
 
 
 def convert_to_json(
-    target : Any,
+    target: Any,
 ) -> str:
-    return encode_json(target).decode()
+    return encode_json(target).decode()

hammad/genai/__init__.py

@@ -3,76 +3,136 @@
 from typing import TYPE_CHECKING
 from .._internal import create_getattr_importer
 
+
 if TYPE_CHECKING:
-    from .embedding_models import (
+    from .agents import (
+        Agent,
+        AgentEvent,
+        AgentResponse,
+        AgentStream,
+        AgentContext,
+        AgentMessages,
+        AgentResponseChunk,
+    )
+    from .agents.run import (
+        run_agent,
+        run_agent_iter,
+        async_run_agent,
+        async_run_agent_iter,
+    )
+    from .models.embeddings import (
+        Embedding,
         EmbeddingModel,
-        EmbeddingModelRequest,
         EmbeddingModelResponse,
+        EmbeddingModelSettings,
         run_embedding_model,
-        async_run_embedding_model
+        async_run_embedding_model,
     )
-    from .language_models import (
+    from .models.language import (
         LanguageModel,
+        LanguageModelInstructorMode,
+        LanguageModelMessages,
+        LanguageModelName,
         LanguageModelRequest,
         LanguageModelResponse,
+        LanguageModelResponseChunk,
+        LanguageModelSettings,
+        LanguageModelStream,
         run_language_model,
         async_run_language_model,
     )
-    from .rerank_models import (
-        run_rerank_model,
-        async_run_rerank_model,
-    )
-    from .multimodal_models import (
-        run_image_generation_model,
-        async_run_image_generation_model,
+    from .models.reranking import run_reranking_model, async_run_reranking_model
+    from .models.multimodal import (
         run_image_edit_model,
-        async_run_image_edit_model,
+        run_image_generation_model,
         run_image_variation_model,
-        async_run_image_variation_model,
-
-        run_tts_model,
-        async_run_tts_model,
         run_transcription_model,
+        run_tts_model,
+        async_run_image_edit_model,
+        async_run_image_generation_model,
+        async_run_image_variation_model,
         async_run_transcription_model,
+        async_run_tts_model,
+    )
+    from .types.base import (
+        BaseGenAIModel,
+        BaseGenAIModelEvent,
+        BaseGenAIModelResponse,
+        BaseGenAIModelSettings,
+        BaseGenAIModelStream,
+    )
+    from .types.history import History
+    from .types.tools import (
+        Tool,
+        define_tool,
+        execute_tools_from_language_model_response,
     )
 
 
-__all__ = (
-    # hammad.genai.embedding_models
+__all__ = [
+    # hammad.genai.agents.agent
+    "Agent",
+    "AgentEvent",
+    "AgentResponse",
+    "AgentStream",
+    "AgentContext",
+    "AgentMessages",
+    "AgentResponseChunk",
+    # hammad.genai.agents.run
+    "run_agent",
+    "run_agent_iter",
+    "async_run_agent",
+    "async_run_agent_iter",
+    # hammad.genai.models.embeddings
+    "Embedding",
     "EmbeddingModel",
-    "EmbeddingModelRequest",
     "EmbeddingModelResponse",
+    "EmbeddingModelSettings",
     "run_embedding_model",
     "async_run_embedding_model",
-
-    # hammad.genai.language_models
+    # hammad.genai.models.language
     "LanguageModel",
+    "LanguageModelInstructorMode",
+    "LanguageModelMessages",
+    "LanguageModelName",
     "LanguageModelRequest",
     "LanguageModelResponse",
+    "LanguageModelResponseChunk",
+    "LanguageModelSettings",
+    "LanguageModelStream",
     "run_language_model",
     "async_run_language_model",
-
-    # hammad.genai.rerank_models
-    "run_rerank_model",
-    "async_run_rerank_model",
-
-    # hammad.genai.multimodal_models
-    "run_image_generation_model",
-    "async_run_image_generation_model",
+    # hammad.genai.models.reranking
+    "run_reranking_model",
+    "async_run_reranking_model",
+    # hammad.genai.models.multimodal
     "run_image_edit_model",
-    "async_run_image_edit_model",
+    "run_image_generation_model",
     "run_image_variation_model",
-    "async_run_image_variation_model",
-    "run_tts_model",
-    "async_run_tts_model",
     "run_transcription_model",
+    "run_tts_model",
+    "async_run_image_edit_model",
+    "async_run_image_generation_model",
+    "async_run_image_variation_model",
     "async_run_transcription_model",
-)
+    "async_run_tts_model",
+    # hammad.genai.types.base
+    "BaseGenAIModel",
+    "BaseGenAIModelEvent",
+    "BaseGenAIModelResponse",
+    "BaseGenAIModelSettings",
+    "BaseGenAIModelStream",
+    # hammad.genai.types.history
+    "History",
+    # hammad.genai.types.tools
+    "Tool",
+    "define_tool",
+    "execute_tools_from_language_model_response",
+]
 
 
 __getattr__ = create_getattr_importer(__all__)
 
 
 def __dir__() -> list[str]:
-    """Get the attributes of the genai module."""
-    return list(__all__)
+    return __all__

hammad/genai/agents/__init__.py

@@ -1 +1,47 @@
-"""hammad.genai.agents"""
+"""hammad.genai.agents"""
+
+from typing import TYPE_CHECKING
+from ..._internal import create_getattr_importer
+
+
+if TYPE_CHECKING:
+    from .agent import Agent
+
+    # Types
+    from .types.agent_context import AgentContext
+    from .types.agent_event import AgentEvent
+    from .types.agent_hooks import HookManager, HookDecorator
+    from .types.agent_messages import AgentMessages
+    from .types.agent_response import (
+        AgentResponse,
+        _create_agent_response_from_language_model_response,
+    )
+    from .types.agent_stream import AgentStream, AgentResponseChunk
+
+
+__all__ = [
+    # hammad.genai.agents.agent
+    "Agent",
+    # hammad.genai.agents.types.agent_context
+    "AgentContext",
+    # hammad.genai.agents.types.agent_event
+    "AgentEvent",
+    # hammad.genai.agents.types.agent_hooks
+    "HookManager",
+    "HookDecorator",
+    # hammad.genai.agents.types.agent_messages
+    "AgentMessages",
+    # hammad.genai.agents.types.agent_response
+    "AgentResponse",
+    "_create_agent_response_from_language_model_response",
+    # hammad.genai.agents.types.agent_stream
+    "AgentStream",
+    "AgentResponseChunk",
+]
+
+
+__getattr__ = create_getattr_importer(__all__)
+
+
+def __dir__() -> list[str]:
+    return __all__