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

hammad/genai/language_models/run.py

@@ -0,0 +1,530 @@
+"""hammad.genai.language_models.run
+
+Standalone functions for running language models with full parameter typing.
+"""
+
+from typing import Any, List, TypeVar, Union, Optional, Type, overload, Dict, TYPE_CHECKING, Callable
+from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from httpx import Timeout
+
+    try:
+        from openai.types.chat import (
+            ChatCompletionMessageParam,
+            ChatCompletionModality,
+            ChatCompletionPredictionContentParam,
+            ChatCompletionAudioParam,
+        )
+    except ImportError:
+        ChatCompletionMessageParam = Any
+        ChatCompletionModality = Any
+        ChatCompletionPredictionContentParam = Any
+        ChatCompletionAudioParam = Any
+
+from ._types import LanguageModelName, LanguageModelInstructorMode
+from .language_model import LanguageModel
+from .language_model_request import LanguageModelMessagesParam
+from .language_model_response import LanguageModelResponse
+from ._streaming import Stream, AsyncStream
+
+__all__ = [
+    "run_language_model",
+    "async_run_language_model",
+]
+
+T = TypeVar("T")
+
+
+# Overloads for run_language_model - String output, non-streaming
+@overload
+def run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Streaming settings
+    stream: Literal[False] = False,
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> LanguageModelResponse[str]: ...
+
+
+# Overloads for run_language_model - String output, streaming
+@overload
+def run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Streaming settings
+    stream: Literal[True],
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> Stream[str]: ...
+
+
+# Overloads for run_language_model - Structured output, non-streaming
+@overload
+def run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Structured output settings
+    type: Type[T],
+    instructor_mode: Optional[LanguageModelInstructorMode] = "tool_call",
+    response_field_name: Optional[str] = None,
+    response_field_instruction: Optional[str] = None,
+    response_model_name: Optional[str] = None,
+    max_retries: Optional[int] = None,
+    strict: Optional[bool] = None,
+    validation_context: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    completion_kwargs_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_response_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_error_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_last_attempt_hooks: Optional[List[Callable[..., None]]] = None,
+    parse_error_hooks: Optional[List[Callable[..., None]]] = None,
+    # Streaming settings
+    stream: Literal[False] = False,
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> LanguageModelResponse[T]: ...
+
+
+# Overloads for run_language_model - Structured output, streaming
+@overload
+def run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Structured output settings
+    type: Type[T],
+    instructor_mode: Optional[LanguageModelInstructorMode] = "tool_call",
+    response_field_name: Optional[str] = None,
+    response_field_instruction: Optional[str] = None,
+    response_model_name: Optional[str] = None,
+    max_retries: Optional[int] = None,
+    strict: Optional[bool] = None,
+    validation_context: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    completion_kwargs_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_response_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_error_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_last_attempt_hooks: Optional[List[Callable[..., None]]] = None,
+    parse_error_hooks: Optional[List[Callable[..., None]]] = None,
+    # Streaming settings
+    stream: Literal[True],
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> Stream[T]: ...
+
+
+def run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    **kwargs: Any,
+) -> Union[LanguageModelResponse[Any], Stream[Any]]:
+    """Run a language model request with full parameter support.
+    
+    Args:
+        messages: The input messages/content for the request
+        instructions: Optional system instructions to prepend
+        **kwargs: All request parameters from LanguageModelRequest
+        
+    Returns:
+        LanguageModelResponse or Stream depending on parameters
+    """
+    # Extract model parameter or use default
+    model = kwargs.pop("model", "openai/gpt-4o-mini")
+    
+    # Create language model instance
+    language_model = LanguageModel(model=model)
+    
+    # Forward to the instance method
+    return language_model.run(messages, instructions, **kwargs)
+
+
+# Async overloads for async_run_language_model - String output, non-streaming
+@overload
+async def async_run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Streaming settings
+    stream: Literal[False] = False,
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> LanguageModelResponse[str]: ...
+
+
+# Async overloads for async_run_language_model - String output, streaming
+@overload
+async def async_run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Streaming settings
+    stream: Literal[True],
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> AsyncStream[str]: ...
+
+
+# Async overloads for async_run_language_model - Structured output, non-streaming
+@overload
+async def async_run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Structured output settings
+    type: Type[T],
+    instructor_mode: Optional[LanguageModelInstructorMode] = "tool_call",
+    response_field_name: Optional[str] = None,
+    response_field_instruction: Optional[str] = None,
+    response_model_name: Optional[str] = None,
+    max_retries: Optional[int] = None,
+    strict: Optional[bool] = None,
+    validation_context: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    completion_kwargs_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_response_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_error_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_last_attempt_hooks: Optional[List[Callable[..., None]]] = None,
+    parse_error_hooks: Optional[List[Callable[..., None]]] = None,
+    # Streaming settings
+    stream: Literal[False] = False,
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> LanguageModelResponse[T]: ...
+
+
+# Async overloads for async_run_language_model - Structured output, streaming
+@overload
+async def async_run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    *,
+    # Provider settings
+    model: LanguageModelName = "openai/gpt-4o-mini",
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_version: Optional[str] = None,
+    organization: Optional[str] = None,
+    deployment_id: Optional[str] = None,
+    model_list: Optional[List[Any]] = None,
+    extra_headers: Optional[Dict[str, str]] = None,
+    # Structured output settings
+    type: Type[T],
+    instructor_mode: Optional[LanguageModelInstructorMode] = "tool_call",
+    response_field_name: Optional[str] = None,
+    response_field_instruction: Optional[str] = None,
+    response_model_name: Optional[str] = None,
+    max_retries: Optional[int] = None,
+    strict: Optional[bool] = None,
+    validation_context: Optional[Dict[str, Any]] = None,
+    context: Optional[Dict[str, Any]] = None,
+    completion_kwargs_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_response_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_error_hooks: Optional[List[Callable[..., None]]] = None,
+    completion_last_attempt_hooks: Optional[List[Callable[..., None]]] = None,
+    parse_error_hooks: Optional[List[Callable[..., None]]] = None,
+    # Streaming settings
+    stream: Literal[True],
+    stream_options: Optional[Dict[str, Any]] = None,
+    # Extended settings
+    timeout: Optional[Union[float, str, "Timeout"]] = None,
+    temperature: Optional[float] = None,
+    top_p: Optional[float] = None,
+    n: Optional[int] = None,
+    stop: Optional[str] = None,
+    max_completion_tokens: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    modalities: Optional[List["ChatCompletionModality"]] = None,
+    prediction: Optional["ChatCompletionPredictionContentParam"] = None,
+    audio: Optional["ChatCompletionAudioParam"] = None,
+    presence_penalty: Optional[float] = None,
+    frequency_penalty: Optional[float] = None,
+    logit_bias: Optional[Dict[str, float]] = None,
+    user: Optional[str] = None,
+    reasoning_effort: Optional[str] = None,
+    seed: Optional[int] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    thinking: Optional[Dict[str, Any]] = None,
+    web_search_options: Optional[Dict[str, Any]] = None,
+    # Tools settings
+    tools: Optional[List[Any]] = None,
+    tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+    parallel_tool_calls: Optional[bool] = None,
+    functions: Optional[List[Any]] = None,
+    function_call: Optional[str] = None,
+) -> AsyncStream[T]: ...
+
+
+async def async_run_language_model(
+    messages: LanguageModelMessagesParam,
+    instructions: Optional[str] = None,
+    **kwargs: Any,
+) -> Union[LanguageModelResponse[Any], AsyncStream[Any]]:
+    """Run an async language model request with full parameter support.
+    
+    Args:
+        messages: The input messages/content for the request
+        instructions: Optional system instructions to prepend
+        **kwargs: All request parameters from LanguageModelRequest
+        
+    Returns:
+        LanguageModelResponse or AsyncStream depending on parameters
+    """
+    # Extract model parameter or use default
+    model = kwargs.pop("model", "openai/gpt-4o-mini")
+    
+    # Create language model instance
+    language_model = LanguageModel(model=model)
+    
+    # Forward to the instance method
+    return await language_model.async_run(messages, instructions, **kwargs)

hammad/genai/multimodal_models.py

@@ -0,0 +1,48 @@
+"""hammad.genai.multimodal_models"""
+
+# simple litellm refs
+# thanks litellm :)
+
+from typing import TYPE_CHECKING
+from .._internal import create_getattr_importer
+
+
+if TYPE_CHECKING:
+    from litellm import (
+        # images / image editing
+        image_generation as run_image_generation_model,
+        aimage_generation as async_run_image_generation_model,
+        image_edit as run_image_edit_model,
+        aimage_edit as async_run_image_edit_model,
+        image_variation as run_image_variation_model,
+        aimage_variation as async_run_image_variation_model,
+        
+        # audio / speech
+        speech as run_tts_model,
+        aspeech as async_run_tts_model,
+        transcription as run_transcription_model,
+        atranscription as async_run_transcription_model,
+    )
+
+
+__all__ = (
+    # images / image editing
+    "run_image_generation_model",
+    "async_run_image_generation_model",
+    "run_image_edit_model",
+    "async_run_image_edit_model",
+    "run_image_variation_model",
+    "async_run_image_variation_model",
+    
+    # audio / speech
+    "run_tts_model",
+    "async_run_tts_model",
+    "run_transcription_model",
+    "async_run_transcription_model",
+)
+
+
+__getattr__ = create_getattr_importer(__all__)
+
+def __dir__() -> list[str]:
+    return list(__all__)    

hammad/genai/rerank_models.py

@@ -0,0 +1,26 @@
+"""hammad.genai.rerank_models"""
+
+# yay litellm
+
+from typing import TYPE_CHECKING
+from .._internal import create_getattr_importer
+
+
+if TYPE_CHECKING:
+    from litellm import (
+        rerank as run_rerank_model,
+        arerank as async_run_rerank_model,
+    )
+
+
+__all__ = (
+    "run_rerank_model",
+    "async_run_rerank_model",
+)
+
+
+__getattr__ = create_getattr_importer(__all__)
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

hammad/logging/__init__.py

@@ -1,7 +1,7 @@
 """hammad.logging"""
 
 from typing import TYPE_CHECKING
-from ..performance.imports import create_getattr_importer
+from .._internal import create_getattr_importer
 
 if TYPE_CHECKING:
     from .logger import Logger, create_logger, create_logger_level, LoggerLevelName

hammad/logging/decorators.py

@@ -1,4 +1,4 @@
-"""hammad.logging.tracers"""
+"""hammad.logging.decorators"""
 
 from functools import wraps
 from typing import (

hammad/logging/logger.py

@@ -293,7 +293,7 @@ class Logger:
     def __init__(
         self,
         name: Optional[str] = None,
-        level: Optional[Union[str, int]] = None,
+        level: Optional[Union[LoggerLevelName, int]] = None,
         rich: bool = True,
         display_all: bool = False,
         level_styles: Optional[Dict[str, LoggerLevelSettings]] = None,
@@ -899,7 +899,7 @@ def create_logger_level(
 
 def create_logger(
     name: Optional[str] = None,
-    level: Optional[Union[str, int]] = None,
+    level: Optional[Union[LoggerLevelName, int]] = None,
     rich: bool = True,
     display_all: bool = False,
     levels: Optional[Dict[LoggerLevelName, LoggerLevelSettings]] = None,

hammad/mcp/__init__.py

@@ -3,7 +3,7 @@ hammad.mcp
 """
 
 from typing import TYPE_CHECKING
-from ..performance.imports import create_getattr_importer
+from .._internal import create_getattr_importer
 
 if TYPE_CHECKING:
     from .client.client import (

hammad/mcp/client/__init__.py

@@ -1 +1,36 @@
 """hammad.mcp.client"""
+
+from typing import TYPE_CHECKING
+from ..._internal import create_getattr_importer
+
+if TYPE_CHECKING:
+    from .client import (
+        MCPClient,
+        MCPClientService,
+    )
+    from .settings import (
+        MCPClientSettings,
+        MCPClientSseSettings,
+        MCPClientStreamableHttpSettings,
+        MCPClientStdioSettings
+    )
+
+__all__ = (
+    # hammad.mcp.client
+    "MCPClient",
+
+    # hammad.mcp.client.client_service
+    "MCPClientService",
+
+    # hammad.mcp.client.settings
+    "MCPClientSettings",
+    "MCPClientSseSettings",
+    "MCPClientStreamableHttpSettings",
+    "MCPClientStdioSettings",
+)
+
+__getattr__ = create_getattr_importer(__all__)
+
+def __dir__() -> list[str]:
+    """Get the attributes of the client module."""
+    return list(__all__)