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

hammad/service/decorators.py

@@ -0,0 +1,285 @@
+"""hammad.service.decorators"""
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Type,
+    Union,
+    ParamSpec,
+    TypeVar,
+)
+
+
+ServiceFunctionParams = ParamSpec("ServiceFunctionParams")
+ServiceFunctionReturn = TypeVar("ServiceFunctionReturn")
+
+
+def serve(
+    func: Optional[Callable[ServiceFunctionParams, ServiceFunctionReturn]] = None,
+    *,
+    # Overrides
+    name: Optional[str] = None,
+    method: Literal[
+        "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"
+    ] = "POST",
+    path: str = "/",
+    # Server configuration
+    host: str = "0.0.0.0",
+    port: int = 8000,
+    log_level: str = "info",
+    reload: bool = False,
+    workers: int = 1,
+    timeout_keep_alive: int = 5,
+    access_log: bool = True,
+    use_colors: bool = True,
+    auto_start: bool = True,
+    # FastAPI
+    include_in_schema: bool = True,
+    dependencies: Optional[List[Callable[..., Any]]] = None,
+    tags: Optional[List[str]] = None,
+    description: Optional[str] = None,
+) -> Union[Callable[ServiceFunctionParams, ServiceFunctionReturn], Callable]:
+    """Decorator to serve a function as a FastAPI endpoint.
+
+    Can be used as a decorator (@serve) or as a function (serve(func)).
+
+    Args:
+        func: Function to serve (when used as decorator, this is None initially)
+        name: Service name (defaults to function name)
+        method: HTTP method to use
+        path: API endpoint path
+        host: Host to bind to
+        port: Port to bind to
+        log_level: Uvicorn log level
+        reload: Enable auto-reload
+        workers: Number of worker processes
+        timeout_keep_alive: Keep-alive timeout
+        access_log: Enable access logging
+        use_colors: Use colored logs
+        auto_start: Automatically start the server
+        include_in_schema: Include in OpenAPI schema
+        dependencies: FastAPI dependencies
+        tags: API tags
+        description: API description
+
+    Returns:
+        The original function (when used as decorator)
+    """
+    from .create import create_service
+    from ..mcp.servers.launcher import find_next_free_port
+
+    def decorator(
+        f: Callable[ServiceFunctionParams, ServiceFunctionReturn],
+    ) -> Callable[ServiceFunctionParams, ServiceFunctionReturn]:
+        # Find next available port if auto_start is True
+        actual_port = port
+        if auto_start:
+            actual_port = find_next_free_port(port, host)
+
+        # Handle dependencies - convert raw functions to FastAPI Depends
+        processed_dependencies = None
+        if dependencies is not None:
+            from fastapi import Depends
+
+            processed_dependencies = [
+                Depends(dep) if callable(dep) else dep for dep in dependencies
+            ]
+
+        # Store the service configuration on the function
+        f._service_config = {
+            "name": name or f.__name__,
+            "method": method,
+            "path": path,
+            "host": host,
+            "port": actual_port,
+            "log_level": log_level,
+            "reload": reload,
+            "workers": workers,
+            "timeout_keep_alive": timeout_keep_alive,
+            "access_log": access_log,
+            "use_colors": use_colors,
+            "auto_start": auto_start,
+            "include_in_schema": include_in_schema,
+            "dependencies": processed_dependencies,
+            "tags": tags,
+            "description": description,
+        }
+
+        # Create and start the service immediately if auto_start is True
+        if auto_start:
+            create_service(f, **f._service_config)
+
+        return f
+
+    if func is None:
+        # Called as @serve(...)
+        return decorator
+    else:
+        # Called as @serve (without parentheses)
+        return decorator(func)
+
+
+def serve_mcp(
+    func_or_funcs: Optional[Union[Callable, List[Callable]]] = None,
+    *,
+    # MCP Server configuration
+    name: Optional[str] = None,
+    instructions: Optional[str] = None,
+    transport: Literal["stdio", "sse", "streamable-http"] = "stdio",
+    # Server settings (for sse/http transports)
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    mount_path: str = "/",
+    sse_path: str = "/sse",
+    message_path: str = "/messages/",
+    streamable_http_path: str = "/mcp",
+    json_response: bool = False,
+    stateless_http: bool = False,
+    warn_on_duplicate_resources: bool = True,
+    warn_on_duplicate_tools: bool = True,
+    # FastMCP settings
+    dependencies: Optional[List[str]] = None,
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
+    debug_mode: bool = False,
+    cwd: Optional[str] = None,
+    # Launch settings
+    auto_restart: bool = False,
+    check_interval: float = 1.0,
+    # Function-specific parameters (only when single function)
+    single_func_name: Optional[str] = None,
+    single_func_description: Optional[str] = None,
+) -> Union[Callable, List[Callable]]:
+    """Decorator/function to serve functions as MCP server tools.
+
+    Can be used in multiple ways:
+    1. As a decorator: @serve_mcp
+    2. As a decorator with params: @serve_mcp(name="MyServer")
+    3. As a function with single function: serve_mcp(my_func)
+    4. As a function with multiple functions: serve_mcp([func1, func2])
+
+    Args:
+        func_or_funcs: Function or list of functions to serve
+        name: MCP server name
+        instructions: Server instructions
+        transport: Transport type (stdio, sse, streamable-http)
+        host: Host for HTTP transports
+        port: Starting port for HTTP transports
+        mount_path: Mount path for HTTP servers
+        sse_path: SSE endpoint path
+        message_path: Message endpoint path
+        streamable_http_path: StreamableHTTP endpoint path
+        json_response: Use JSON responses for HTTP
+        stateless_http: Use stateless HTTP mode
+        warn_on_duplicate_resources: Warn on duplicate resources
+        warn_on_duplicate_tools: Warn on duplicate tools
+        dependencies: FastMCP dependencies
+        log_level: Logging level
+        debug_mode: Enable debug mode
+        cwd: Working directory
+        auto_restart: Automatically restart failed servers
+        check_interval: Health check interval in seconds
+        single_func_name: Name override for single function
+        single_func_description: Description for single function
+
+    Returns:
+        Original function(s) unchanged
+    """
+    from ..mcp.servers.launcher import (
+        launch_mcp_servers,
+        MCPServerStdioSettings,
+        MCPServerSseSettings,
+        MCPServerStreamableHttpSettings,
+    )
+
+    def _create_server_config(
+        tools: List[Callable], server_name: str, server_instructions: Optional[str]
+    ):
+        """Create the appropriate server configuration based on transport type."""
+        base_config = {
+            "name": server_name,
+            "instructions": server_instructions,
+            "tools": tools,
+            "dependencies": dependencies or [],
+            "log_level": log_level,
+            "debug_mode": debug_mode,
+            "cwd": cwd,
+        }
+
+        if transport == "stdio":
+            return MCPServerStdioSettings(**base_config)
+        elif transport == "sse":
+            return MCPServerSseSettings(
+                **base_config,
+                host=host,
+                start_port=port,
+                mount_path=mount_path,
+                sse_path=sse_path,
+                message_path=message_path,
+                json_response=json_response,
+                stateless_http=stateless_http,
+                warn_on_duplicate_resources=warn_on_duplicate_resources,
+                warn_on_duplicate_tools=warn_on_duplicate_tools,
+            )
+        elif transport == "streamable-http":
+            return MCPServerStreamableHttpSettings(
+                **base_config,
+                host=host,
+                start_port=port,
+                mount_path=mount_path,
+                streamable_http_path=streamable_http_path,
+                json_response=json_response,
+                stateless_http=stateless_http,
+                warn_on_duplicate_resources=warn_on_duplicate_resources,
+                warn_on_duplicate_tools=warn_on_duplicate_tools,
+            )
+        else:
+            raise ValueError(f"Unsupported transport: {transport}")
+
+    def _launch_server(server_config):
+        """Launch the MCP server with the given configuration."""
+        launch_mcp_servers(
+            servers=[server_config],
+            check_interval=check_interval,
+            auto_restart=auto_restart,
+        )
+
+    def decorator(f: Callable) -> Callable:
+        """Decorator for single function."""
+        func_name = single_func_name or name or f.__name__
+        func_instructions = single_func_description or instructions or f.__doc__
+
+        # Create server configuration and launch
+        server_config = _create_server_config([f], func_name, func_instructions)
+        _launch_server(server_config)
+
+        return f
+
+    def handle_multiple_functions(funcs: List[Callable]) -> List[Callable]:
+        """Handle multiple functions."""
+        server_name = name or "MCPServer"
+        server_instructions = instructions or f"MCP server with {len(funcs)} tools"
+
+        # Create server configuration and launch
+        server_config = _create_server_config(funcs, server_name, server_instructions)
+        _launch_server(server_config)
+
+        return funcs
+
+    # Handle different call patterns
+    if func_or_funcs is None:
+        # Called as @serve_mcp(...) - return decorator
+        return decorator
+    elif callable(func_or_funcs):
+        # Called as @serve_mcp (no parentheses) or serve_mcp(single_func)
+        return decorator(func_or_funcs)
+    elif isinstance(func_or_funcs, list):
+        # Called as serve_mcp([func1, func2, ...])
+        return handle_multiple_functions(func_or_funcs)
+    else:
+        raise TypeError(
+            f"Expected callable or list of callables, got {type(func_or_funcs)}"
+        )

hammad/web/__init__.py

@@ -1,7 +1,7 @@
 """hammad.web"""
 
 from typing import TYPE_CHECKING
-from .._core._utils._import_utils import _auto_create_getattr_loader
+from ..performance.imports import create_getattr_importer
 
 if TYPE_CHECKING:
     from .utils import (
@@ -35,7 +35,7 @@ __all__ = (
 )
 
 
-__getattr__ = _auto_create_getattr_loader(__all__)
+__getattr__ = create_getattr_importer(__all__)
 
 
 def __dir__() -> list[str]:

hammad/web/http/client.py

@@ -1,4 +1,4 @@
-"""Base HTTP toolkit implementation with clean type hints and semantic error handling."""
+"""hammad.web.http.client"""
 
 from __future__ import annotations
 

hammad/web/openapi/__init__.py

@@ -0,0 +1 @@
+"""hammad.web.openapi"""

{hammad_python-0.0.13.dist-info → hammad_python-0.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammad-python
-Version: 0.0.13
+Version: 0.0.14
 Summary: hammad - *Nightly* hyper-fast opinionated resources and modules built for quick development.
 Author-email: Hammad Saeed <hammadaidev@gmail.com>
 License-File: LICENSE
@@ -34,5 +34,37 @@ Requires-Dist: sse-starlette>=1.1.0; extra == 'serve'
 Requires-Dist: uvicorn>=0.34.0; extra == 'serve'
 Description-Content-Type: text/markdown
 
-# hammad-python
-hammadpy - *Nightly* hyper-fast opinionated resources and modules built for quick development.
+## hammad-python
+
+> __Happily Accelerated Micro-Modules (_for_) Application Development__
+
+## Introduction
+
+The `hammad-python` library, is a mix of a love letter and collection of mixed resources for
+developing Python applications. This library is meant to be used for rapid prototyping and
+development, and is focused on providing styled placeholder tools for common patterns, tasks
+and workflows.
+
+The package is currently built into the following structures:
+
+- `hammad-python` : Contains most core functionality and resources.
+- `hammad-python[ai]` : Contains easy to use resources for Generative AI related tasks such as
+   generating completions with language models, or creating embeddings.
+
+## Installation
+
+You can install the package using `pip` or `uv`:
+
+```bash
+pip install hammad-python
+
+# or install the `ai` extension
+# pip install 'hammad-python[ai]'
+```
+
+```bash
+uv pip install hammad-python
+
+# or install the `ai` extension
+# uv pip install 'hammad-python[ai]'
+```

hammad_python-0.0.14.dist-info/RECORD

@@ -0,0 +1,99 @@
+hammad/__init__.py,sha256=jlLAU-UQOE0szthvDBf3u77U6I-4quzZZ8_PWuGVPJ4,20
+hammad/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hammad/ai/__init__.py,sha256=6COUrJFQoIqJIRy6tUhi5Lpml_e4qMxXWYTIIacqtoM,16
+hammad/ai/_utils.py,sha256=axsCHv66zfjjhlEbxaF_049fClHjQgHtUReXs8nsMwc,3950
+hammad/ai/completions/__init__.py,sha256=3MHiUWn7AVlbXh4vmH1ILG4MYPEYp0-CYSlZR18QO4w,1115
+hammad/ai/completions/client.py,sha256=4M40D_a4sbJmakBZD-lusRyEGp5YGaAKcmwBKJEroF4,26679
+hammad/ai/completions/create.py,sha256=o1XLpRUPoQs6q4w2DHpdUVAzQA1TqeaIr4ct1rcTMpk,31909
+hammad/ai/completions/settings.py,sha256=pM9ft62rMzlG2JBqQU6j-9skT6edbkbK_stajeLfFM0,3093
+hammad/ai/completions/types.py,sha256=o6ki8aA9SZ-bVgmUZykKIoGgeI-GqO-rddMpIyZGcsk,28140
+hammad/ai/completions/utils.py,sha256=lLEec1XdYBG2rBEALSfsRq88yK6gsU2uBOWH97UbxnI,17305
+hammad/ai/embeddings/__init__.py,sha256=HmJBRWdzASa0nEa37GIkJiSbAaLXV-k48omra374kmA,1090
+hammad/ai/embeddings/create.py,sha256=voVD6WLvoyIgqIMYOmJKJFxUho8ZIl0YDfbgM4X6B6w,6590
+hammad/ai/embeddings/types.py,sha256=FCr2r4IYN-xYBmRXadocDQhDC2foC49X940UTVi9bgo,1772
+hammad/ai/embeddings/client/__init__.py,sha256=F2SO89Q6xOYQWNfvAONBJdDLoXIsCxON6I1BxpjEkGQ,34
+hammad/ai/embeddings/client/base_embeddings_client.py,sha256=EMT8jDMa0TKIV9XA9Tx9ze7eJ882OuCLL9KucI2EezQ,600
+hammad/ai/embeddings/client/fastembed_text_embeddings_client.py,sha256=EWiaS9U-K7gnc2g8qHN-3lHCCgsEaCc-1Hny-DV3rf4,6956
+hammad/ai/embeddings/client/litellm_embeddings_client.py,sha256=EMl7V6XiGUGaDs9N_HZaJ2GUJwW8LpWquiNF_yXzP3o,10042
+hammad/cache/__init__.py,sha256=Ab97dA3tUUy4fts5kMOlSoVoYPydDShTJSMve6emGgY,964
+hammad/cache/base_cache.py,sha256=kYJS2IcQtxhzT7BQBFtOWnhw4VkvAapPhAVkfbW5IeY,6353
+hammad/cache/cache.py,sha256=bzDXxjSolrSdIxqES2VMfVZZGTk_8k4x9n0AW4tlifs,4621
+hammad/cache/decorators.py,sha256=olYLK5x4JkxHpA8WIiplI45QYmNIzyGjNMrTKNRCSQg,9599
+hammad/cache/file_cache.py,sha256=XjLJxM4Ql65OABxz8q1DtA_s8HZQJKywCw6MNVnC6YE,2485
+hammad/cache/ttl_cache.py,sha256=-0pJ4lkVgg1OIb98bQFub9n6f4zgWVs-dQfKZe_DmpE,2153
+hammad/cli/__init__.py,sha256=Tz0OyzLJHeW6wnKwX-xnA0oN4FE1Z2zm3WntFzE2RNI,743
+hammad/cli/animations.py,sha256=q8rMyboRUwmgBwHutPj4oveDjw9BPTu1UjL53XlOb-U,19514
+hammad/cli/plugins.py,sha256=61cljGF_V03_6xrBhO0tR-rrlgB44veHh5HXcxMTM3Y,26932
+hammad/cli/styles/__init__.py,sha256=PDQEHlMhujetCVurTGRW3LOKZLr7338DQvKCFt4Fyjs,1373
+hammad/cli/styles/settings.py,sha256=irChf9RsMij3djx_n9D9duoVIzxLCpd9-BlKl6U_OLk,5532
+hammad/cli/styles/types.py,sha256=vNIeQY_23m10K8qVT7Iy-PMwosGL-La-UAZKszHJjEE,7911
+hammad/cli/styles/utils.py,sha256=BGFwQIEJHWlTAXed8ZxHeI_phLfEdh-_Mok2fe-jn7g,19356
+hammad/data/__init__.py,sha256=0PKUAZMYUk3eb5JAg7e1pUJwb0NtWMhicIo-O7TU-o4,1380
+hammad/data/collections/__init__.py,sha256=trapmRN7MUEgLZsJfCanU2rbn8-hSw3uIGjD-uwz-fg,823
+hammad/data/collections/base_collection.py,sha256=ZRht7OZjLIT8GxNvMgNxTarbCTY6EUUurEkGHZ3Rsy4,1419
+hammad/data/collections/collection.py,sha256=MWjyY3YqZa3U9WH3Br8v-Q_FLP5XWf3p0lIMGzfIeJ4,15758
+hammad/data/collections/searchable_collection.py,sha256=vCV_JgMwB57QRi4Cri6dfEUzLCyTBN58_JfWEKL2h_0,21361
+hammad/data/collections/vector_collection.py,sha256=x3-pFoi6v9uRCpCmLdcVwJpo-6FVIVw_JTLWV4pYAiY,20901
+hammad/data/configurations/__init__.py,sha256=-qd2LClmGgoCvucePfpZVJDP0sXR95b4J3x9lK3MX_o,838
+hammad/data/configurations/configuration.py,sha256=M3JBpPjynOMdhjJrV9HiIzuTPKqo6i9dh7NiaCbp_L0,17739
+hammad/data/databases/__init__.py,sha256=xlQFbwW9O0UzjZS5uh2BipgRzMFcwz1q7Bg0aDdqFuU,410
+hammad/data/databases/database.py,sha256=7ngi-oWAsmAdtLTvpT4axw5ftcMzqsCtJmfmjzw5etk,31160
+hammad/data/models/__init__.py,sha256=kGErTmEmWS5fqTRd-ESsetf_aRZTEUgt5k3uYWAx_fw,895
+hammad/data/models/base/__init__.py,sha256=uCltlgyHVMk1GdAbqArPBC2xjRVE5U7BGaAfoBrPPcY,812
+hammad/data/models/base/fields.py,sha256=n02Qqq1AkcxwGCGEjcBSu63uWSkcyfxisATr7nwc7DA,19173
+hammad/data/models/base/model.py,sha256=_qyJ3IRJTwRXqZsYMpuYP8FTbMfLgh75VbTrTt1Wqx8,39121
+hammad/data/models/base/utils.py,sha256=kmdWqDcCTB7y4w5pdAfyrOfpzqj1hjKILIklAwbvNxM,9957
+hammad/data/models/pydantic/__init__.py,sha256=uv2KhaxACJf5rUURlUjB3gXWcb0EDEDXF98QoK_KQTI,1501
+hammad/data/models/pydantic/converters.py,sha256=ePV4GXco_eEZ5cTYH0vk2bv3ywZztvAzwEgenUeQicA,20544
+hammad/data/models/pydantic/models/__init__.py,sha256=tEjSun4IPyUfVvYst8e8l9JgvRanAvJt0iLNYiigHdc,670
+hammad/data/models/pydantic/models/arbitrary_model.py,sha256=xgCt4e7CyD0CF8Ozk9TNNLa_Kxue4K1QAs8vj6S-WQY,1536
+hammad/data/models/pydantic/models/cacheable_model.py,sha256=xnv-5Bf7uf6ELQ-amuZghRDfuuX1eFmaDh7Lz5IRpdU,2821
+hammad/data/models/pydantic/models/fast_model.py,sha256=RiVyutUS296tQp7gK7IrHXeLWVtSx9wKU_vf9keuYuU,11728
+hammad/data/models/pydantic/models/function_model.py,sha256=6YTGzHAtwlybn3M46dry6JgfGjuo1TntXtHVZ5pqrHQ,6312
+hammad/data/models/pydantic/models/subscriptable_model.py,sha256=K5ZqxrDxikKv2iMv7_Xt3liG9AZ73cSNhzuOZpjed7w,1718
+hammad/data/types/__init__.py,sha256=asGaCmHSYo7r5mXR8tWA0b3ermLCMGAuZDXXDkR6W3w,770
+hammad/data/types/file.py,sha256=gBpQxQCJJJVOFeUS_7NRkhA1pB54b6Wy3NzOH-fmnWY,11116
+hammad/data/types/text.py,sha256=rATiwkTsAJ8pWzZ7OBsWX7rDNoKvkeuWsGWd_sbuUaM,33369
+hammad/data/types/multimodal/__init__.py,sha256=FrQJ7GoUfI-zen5m2oayzXfDlShKqqSQG4zLXlL-3Nw,431
+hammad/data/types/multimodal/audio.py,sha256=HAKWi96F2kJ2dLMDXTeVLYlXPhaFZAH55TCROuirMzo,2786
+hammad/data/types/multimodal/image.py,sha256=oI9DMHw6XxV2ma3XIWqK-jwczi5HUNszGzIl_BtEuxA,2274
+hammad/formatting/__init__.py,sha256=J4VSLnZk2ImZCBtVg2el0KZFcwQNmU1UyF4wdiz-i5E,776
+hammad/formatting/json/__init__.py,sha256=Sv-p-85VFcmVE3vHbgu23jGZB0tzJRFX0HKJDYLc6KA,472
+hammad/formatting/json/converters.py,sha256=4AYKxsqDftKtjfxFTIY9mQ0_CbrUmAK_6EBpD2X40pU,5502
+hammad/formatting/text/__init__.py,sha256=lpDcwMpKN0ZyMYxGBNd52fAWQ0UhOTkjkNP1WqJ1xjM,1516
+hammad/formatting/text/converters.py,sha256=g3z-ZGTaKNVbLFFKBSh6qN2Uz0BSkdxCaN3LR9cAyV8,23806
+hammad/formatting/text/markdown.py,sha256=D17NOoGkoXUBhoOGKelKHwi72iqsAwPU5HEFjRJtLQI,3407
+hammad/formatting/yaml/__init__.py,sha256=EEkOsh6DYH0F2mIU-mzFXgNqcc_GmqHaIPlKGCnj2tg,472
+hammad/formatting/yaml/converters.py,sha256=zvSB8QGb56uvwO0KjXllfTj9g1FmNINOKR06DTjvXw8,153
+hammad/logging/__init__.py,sha256=2fMnpKO20HWcyYbgQnGzV02g1t0kbH_c8wLmHIV5Hrk,711
+hammad/logging/decorators.py,sha256=xhHRA7WhesgdVMSwK_JvqZhGb90GF3TbYco13Y7aY0w,30119
+hammad/logging/logger.py,sha256=8q-7anLeZk07QlPszdt_qzsQPaeuZyDHevV8C6R_okk,31451
+hammad/mcp/__init__.py,sha256=aaXwQOI4kJ8Dkbsg9rb8kZ5NJ6NqeT7aDmfQKPJcOAM,1133
+hammad/mcp/client/__init__.py,sha256=FdvJqHaup6KgonBRvE570B2X-_GwY-ZlEtsXBLXubcw,24
+hammad/mcp/client/client.py,sha256=kRPKAcTenUSp1aL7oCnrOw0AoSqU9dVdf1H_r1rkDaY,17959
+hammad/mcp/client/client_service.py,sha256=lZUkNJo9BBrwR8qUtDByzofMx6aJJuer9w2uHZFBCW0,14874
+hammad/mcp/client/settings.py,sha256=7bLpJYyiUT_H7zp3SDwLyAt9fmiQwL3L89qVTAZYpi8,5913
+hammad/mcp/servers/__init__.py,sha256=lxlhxoBPPhlFAJl87AL-11Qbl1Jhit27lmPDC03Ww8I,25
+hammad/mcp/servers/launcher.py,sha256=jQDQOqz-cKK2PSEOxoPBCVsBeTABNNjcwTXSWE4-LQA,41606
+hammad/performance/__init__.py,sha256=hAbp_40Uw5LqGy-K2MCoiee1DUazb8GT49_GJ7LQGKs,789
+hammad/performance/imports.py,sha256=WwbrufLOkrvqJh3CLp8H_7nmGEE8vcWNbJN74Dk_gGg,7814
+hammad/performance/runtime/__init__.py,sha256=xk7rdpDb_s2EIxu2bvpOlhAZh5ZV1ckRIviSapL9wFM,672
+hammad/performance/runtime/decorators.py,sha256=TC6JL5MVu9ak2XUNpuzpwPY6nirKDLgbd-iuUNI0YIA,4536
+hammad/performance/runtime/run.py,sha256=K6GS6SGs8ktztiBAAgU8oaPpycravjPAgJD_tXAjQpA,10814
+hammad/service/__init__.py,sha256=U8wxhj5l9JdeJZXIPT7Eo7gZacxJ2PQ-xN58gy5Lb5g,1232
+hammad/service/create.py,sha256=x9N3uAzWeoInnq7HJpUTf3m87sYCFP5jLQK3S91ArLo,16423
+hammad/service/decorators.py,sha256=QBZ7iZK1c-tTNoKt6vqnNFN2BT-FdLaGz_f6vOmeY1w,10028
+hammad/typing/__init__.py,sha256=jQEwoJVMdgk1VQTLyMiJaU7l5P8JIvcvwcjMazE7iSo,10923
+hammad/web/__init__.py,sha256=CbHQXPfybL1qv2yi0_HmeOqNkjzz9xSdXKmot2gSub8,1063
+hammad/web/models.py,sha256=q9d4_3UPvHcvG_HuULxKHQuNrllA2S-3CSP3HdU21Cs,5637
+hammad/web/utils.py,sha256=7jf_esoIwctKg1qxSaN6yAgzeo70HT1IdSVqoNdHFSQ,15815
+hammad/web/http/__init__.py,sha256=jn9Rn7Yg2cypD7duTTNFuW2wQZx9B63Bde4RJJeDYU0,22
+hammad/web/http/client.py,sha256=J_W0d1vop92uANQ7YD1o72XAp95Ma67Uz1YolNDF19M,33086
+hammad/web/openapi/__init__.py,sha256=JhJQ6_laBmB2djIYFc0vgGha2GsdUe4FP1LDdZCQ5J4,25
+hammad/web/openapi/client.py,sha256=1pXz7KAO_0pN4kQZoWKWskXDYGiJ535TsPO1GGCiC0E,26816
+hammad/web/search/__init__.py,sha256=e9A6znPIiZCz-4secyHbUs0uUGf5yAqW6wGacgx961U,24
+hammad/web/search/client.py,sha256=4VEhctFf_4LRxM2TXsEssSW6tbaZnu0NYaIVMYQrJNs,35434
+hammad_python-0.0.14.dist-info/METADATA,sha256=ECSnj__tLbSE19XURH8fuHtt_iplioxoNN0QbSmBWtw,2302
+hammad_python-0.0.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hammad_python-0.0.14.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
+hammad_python-0.0.14.dist-info/RECORD,,

hammad/_core/__init__.py

@@ -1 +0,0 @@
-"""hammad._core"""

hammad/_core/_utils/__init__.py

@@ -1,4 +0,0 @@
-"""hammad._core._utils
-
-Contains internal utility functions use at a low level for various cases
-throughout the `hammad` package."""