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

hammad/web/utils.py

@@ -1,472 +0,0 @@
-"""hammad.web.utils"""
-
-import asyncio
-from typing import Any, Dict, Optional, Union, Literal, List, overload, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .http.client import HttpResponse
-
-from .models import (
-    SearchResults,
-    NewsResults,
-    WebPageResult,
-    WebPageResults,
-    ExtractedLinks,
-    HttpResponse as HttpResponseModel,
-)
-
-__all__ = (
-    "run_web_request",
-    "search_web",
-    "read_web_page",
-    "read_web_pages",
-    "search_news",
-    "extract_page_links",
-)
-
-
-# Module-level singleton for performance
-_search_client = None
-
-
-def _get_search_client():
-    """Get a SearchClient instance using lazy import and singleton pattern."""
-    global _search_client
-    if _search_client is None:
-        from .search.client import AsyncSearchClient as SearchClient
-
-        _search_client = SearchClient()
-    return _search_client
-
-
-@overload
-def run_web_request(
-    type: Literal["http"],
-    method: Literal["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
-    url: str,
-    *,
-    headers: Optional[Dict[str, str]] = None,
-    params: Optional[Dict[str, Any]] = None,
-    json_data: Optional[Dict[str, Any]] = None,
-    form_data: Optional[Dict[str, Any]] = None,
-    content: Optional[Union[str, bytes]] = None,
-    timeout: Optional[float] = None,
-    follow_redirects: bool = True,
-    base_url: Optional[str] = None,
-    default_headers: Optional[Dict[str, str]] = None,
-    verify_ssl: bool = True,
-    # Semantic authentication parameters
-    api_key: Optional[str] = None,
-    api_key_header: str = "X-API-Key",
-    bearer_token: Optional[str] = None,
-    basic_auth: Optional[tuple[str, str]] = None,
-    user_agent: Optional[str] = None,
-    retry_attempts: int = 0,
-    retry_delay: float = 1.0,
-) -> "HttpResponse": ...
-
-
-@overload
-def run_web_request(
-    type: Literal["openapi"],
-    openapi_spec: Union[str, Dict[str, Any]],
-    operation_id: str,
-    *,
-    parameters: Optional[Dict[str, Any]] = None,
-    request_body: Optional[Dict[str, Any]] = None,
-    headers: Optional[Dict[str, str]] = None,
-    base_url: Optional[str] = None,
-    default_headers: Optional[Dict[str, str]] = None,
-    timeout: float = 30.0,
-    follow_redirects: bool = True,
-    verify_ssl: bool = True,
-    # Semantic authentication parameters
-    api_key: Optional[str] = None,
-    api_key_header: str = "X-API-Key",
-    bearer_token: Optional[str] = None,
-    basic_auth: Optional[tuple[str, str]] = None,
-    user_agent: Optional[str] = None,
-) -> "HttpResponse": ...
-
-
-def run_web_request(
-    type: Literal["http", "openapi"], *args, **kwargs
-) -> "HttpResponse":
-    """
-    Create and execute a request using either HTTP or OpenAPI toolkits.
-
-    This function initializes the appropriate toolkit and sends the request,
-    returning the HTTP response.
-
-    Args:
-        type: Type of request - "http" for direct HTTP requests or "openapi" for OpenAPI operations
-
-    HTTP-specific args:
-        method: HTTP method
-        url: Request URL
-        headers: Request headers
-        params: Query parameters
-        json_data: JSON request body
-        form_data: Form data
-        content: Raw content
-        timeout: Request timeout
-        follow_redirects: Whether to follow redirects
-        base_url: Base URL for requests
-        default_headers: Default headers
-        verify_ssl: Whether to verify SSL certificates
-
-    OpenAPI-specific args:
-        openapi_spec: OpenAPI specification (dict, JSON string, or YAML string)
-        operation_id: OpenAPI operation ID to execute
-        parameters: Operation parameters
-        request_body: Request body for the operation
-        headers: Additional headers
-        base_url: Base URL override
-        default_headers: Default headers
-        timeout: Request timeout
-        follow_redirects: Whether to follow redirects
-        verify_ssl: Whether to verify SSL certificates
-
-    Returns:
-        HttpResponse object containing the response data
-
-    Raises:
-        ValueError: For invalid request type or missing required parameters
-        HttpToolkitError: For HTTP-related errors
-        OpenApiToolkitError: For OpenAPI-related errors
-    """
-
-    async def _run_web_request_async():
-        if type == "http":
-            if len(args) < 2:
-                raise ValueError(
-                    "HTTP requests require method and url as positional arguments"
-                )
-
-            method, url = args[0], args[1]
-
-            # Import here to avoid circular imports
-            from .http.client import HttpClient as HttpToolkit
-
-            # Initialize the HTTP toolkit
-            toolkit = HttpToolkit(
-                base_url=kwargs.get("base_url"),
-                default_headers=kwargs.get("default_headers", {}),
-                timeout=kwargs.get("timeout", 30.0),
-                follow_redirects=kwargs.get("follow_redirects", True),
-                verify_ssl=kwargs.get("verify_ssl", True),
-                api_key=kwargs.get("api_key"),
-                api_key_header=kwargs.get("api_key_header", "X-API-Key"),
-                bearer_token=kwargs.get("bearer_token"),
-                basic_auth=kwargs.get("basic_auth"),
-                user_agent=kwargs.get("user_agent"),
-            )
-
-            # Execute the request based on method
-            if method.upper() == "GET":
-                return await toolkit.get(
-                    url,
-                    headers=kwargs.get("headers"),
-                    params=kwargs.get("params"),
-                    timeout=kwargs.get("timeout"),
-                    retry_attempts=kwargs.get("retry_attempts", 0),
-                    retry_delay=kwargs.get("retry_delay", 1.0),
-                )
-            elif method.upper() == "POST":
-                return await toolkit.post(
-                    url,
-                    headers=kwargs.get("headers"),
-                    json_data=kwargs.get("json_data"),
-                    form_data=kwargs.get("form_data"),
-                    timeout=kwargs.get("timeout"),
-                    retry_attempts=kwargs.get("retry_attempts", 0),
-                )
-            elif method.upper() == "PUT":
-                return await toolkit.put(
-                    url,
-                    headers=kwargs.get("headers"),
-                    json_data=kwargs.get("json_data"),
-                    form_data=kwargs.get("form_data"),
-                    timeout=kwargs.get("timeout"),
-                    retry_attempts=kwargs.get("retry_attempts", 0),
-                )
-            elif method.upper() == "PATCH":
-                return await toolkit.patch(
-                    url,
-                    headers=kwargs.get("headers"),
-                    json_data=kwargs.get("json_data"),
-                    form_data=kwargs.get("form_data"),
-                    timeout=kwargs.get("timeout"),
-                    retry_attempts=kwargs.get("retry_attempts", 0),
-                )
-            elif method.upper() == "DELETE":
-                return await toolkit.delete(
-                    url,
-                    headers=kwargs.get("headers"),
-                    timeout=kwargs.get("timeout"),
-                    retry_attempts=kwargs.get("retry_attempts", 0),
-                )
-            else:
-                raise ValueError(f"Unsupported HTTP method: {method}")
-
-        elif type == "openapi":
-            from .openapi.client import OpenAPIClient as OpenApiToolkit
-
-            if len(args) < 2:
-                raise ValueError(
-                    "OpenAPI requests require openapi_spec and operation_id as positional arguments"
-                )
-
-            openapi_spec, operation_id = args[0], args[1]
-
-            # Initialize the OpenAPI toolkit
-            toolkit = OpenApiToolkit(
-                openapi_spec=openapi_spec,
-                base_url=kwargs.get("base_url"),
-                default_headers=kwargs.get("default_headers"),
-                timeout=kwargs.get("timeout", 30.0),
-                follow_redirects=kwargs.get("follow_redirects", True),
-                verify_ssl=kwargs.get("verify_ssl", True),
-                api_key=kwargs.get("api_key"),
-                api_key_header=kwargs.get("api_key_header", "X-API-Key"),
-                bearer_token=kwargs.get("bearer_token"),
-                basic_auth=kwargs.get("basic_auth"),
-                user_agent=kwargs.get("user_agent"),
-            )
-
-            # Execute the OpenAPI operation
-            return await toolkit.execute_operation(
-                operation_id=operation_id,
-                parameters=kwargs.get("parameters"),
-                request_body=kwargs.get("request_body"),
-                headers=kwargs.get("headers"),
-            )
-
-        else:
-            raise ValueError(
-                f"Invalid request type: {type}. Must be 'http' or 'openapi'"
-            )
-
-    return asyncio.run(_run_web_request_async())
-
-
-def search_web(
-    query: str,
-    *,
-    max_results: int = 10,
-    region: str = "wt-wt",
-    safesearch: Literal["on", "moderate", "off"] = "moderate",
-    timelimit: Optional[Literal["d", "w", "m", "y"]] = None,
-    backend: Literal["auto", "html", "lite"] = "auto",
-    retry_attempts: int = 3,
-    retry_delay: float = 1.0,
-) -> SearchResults:
-    """
-    Search the web using DuckDuckGo search.
-
-    Args:
-        query: Search query string
-        max_results: Maximum number of results to return (default: 10)
-        region: Search region (default: "wt-wt" for worldwide)
-        safesearch: Safe search setting (default: "moderate")
-        timelimit: Time limit for results (d=day, w=week, m=month, y=year)
-        backend: Search backend to use (default: "auto")
-        retry_attempts: Number of retry attempts for rate limit errors (default: 3)
-        retry_delay: Initial delay between retries in seconds (default: 1.0)
-
-    Returns:
-        List of search result dictionaries with 'title', 'href', and 'body' keys
-
-    Raises:
-        ValueError: If query is empty
-        Exception: If search fails after all retries
-    """
-
-    async def _search_web_async():
-        client = _get_search_client()
-        return await client.search_web(
-            query=query,
-            max_results=max_results,
-            region=region,
-            safesearch=safesearch,
-            timelimit=timelimit,
-            backend=backend,
-        )
-
-    return asyncio.run(_search_web_async())
-
-
-def read_web_page(
-    url: str,
-    *,
-    timeout: float = 30.0,
-    headers: Optional[Dict[str, str]] = None,
-    extract_text: bool = True,
-    extract_links: bool = False,
-    extract_images: bool = False,
-    css_selector: Optional[str] = None,
-) -> WebPageResult:
-    """
-    Read and parse a single web page using selectolax.
-
-    Args:
-        url: URL to fetch and parse
-        timeout: Request timeout in seconds (default: 30.0)
-        headers: Optional HTTP headers to send
-        extract_text: Whether to extract text content (default: True)
-        extract_links: Whether to extract links (default: False)
-        extract_images: Whether to extract images (default: False)
-        css_selector: Optional CSS selector to extract specific elements
-
-    Returns:
-        Dictionary containing parsed content and metadata
-
-    Raises:
-        httpx.HTTPError: If request fails
-        Exception: If parsing fails
-    """
-
-    async def _read_web_page_async():
-        client = _get_search_client()
-        return await client.read_web_page(
-            url=url,
-            timeout=timeout,
-            headers=headers,
-            extract_text=extract_text,
-            extract_links=extract_links,
-            extract_images=extract_images,
-            css_selector=css_selector,
-        )
-
-    return asyncio.run(_read_web_page_async())
-
-
-def read_web_pages(
-    urls: List[str],
-    *,
-    timeout: float = 30.0,
-    headers: Optional[Dict[str, str]] = None,
-    extract_text: bool = True,
-    extract_links: bool = False,
-    extract_images: bool = False,
-    css_selector: Optional[str] = None,
-    max_concurrent: int = 5,
-) -> WebPageResults:
-    """
-    Read and parse multiple web pages concurrently using selectolax.
-
-    Args:
-        urls: List of URLs to fetch and parse
-        timeout: Request timeout in seconds (default: 30.0)
-        headers: Optional HTTP headers to send
-        extract_text: Whether to extract text content (default: True)
-        extract_links: Whether to extract links (default: False)
-        extract_images: Whether to extract images (default: False)
-        css_selector: Optional CSS selector to extract specific elements
-        max_concurrent: Maximum number of concurrent requests (default: 5)
-
-    Returns:
-        List of dictionaries containing parsed content and metadata
-
-    Raises:
-        Exception: If any critical error occurs
-    """
-
-    async def _read_web_pages_async():
-        client = _get_search_client()
-        return await client.read_web_pages(
-            urls=urls,
-            timeout=timeout,
-            headers=headers,
-            extract_text=extract_text,
-            extract_links=extract_links,
-            extract_images=extract_images,
-            css_selector=css_selector,
-            max_concurrent=max_concurrent,
-        )
-
-    return asyncio.run(_read_web_pages_async())
-
-
-def search_news(
-    query: str,
-    *,
-    max_results: int = 10,
-    region: str = "wt-wt",
-    safesearch: Literal["on", "moderate", "off"] = "moderate",
-    timelimit: Optional[Literal["d", "w", "m"]] = None,
-) -> NewsResults:
-    """
-    Search for news using DuckDuckGo news search.
-
-    Args:
-        query: Search query string
-        max_results: Maximum number of results to return (default: 10)
-        region: Search region (default: "wt-wt" for worldwide)
-        safesearch: Safe search setting (default: "moderate")
-        timelimit: Time limit for results (d=day, w=week, m=month)
-
-    Returns:
-        List of news result dictionaries with date, title, body, url, image, and source
-
-    Raises:
-        ValueError: If query is empty
-        Exception: If search fails
-    """
-
-    async def _search_news_async():
-        client = _get_search_client()
-        return await client.search_news(
-            query=query,
-            max_results=max_results,
-            region=region,
-            safesearch=safesearch,
-            timelimit=timelimit,
-        )
-
-    return asyncio.run(_search_news_async())
-
-
-def extract_page_links(
-    url: str,
-    *,
-    timeout: float = 30.0,
-    headers: Optional[Dict[str, str]] = None,
-    css_selector: str = "a[href]",
-    include_external: bool = True,
-    include_internal: bool = True,
-    base_url: Optional[str] = None,
-) -> ExtractedLinks:
-    """
-    Extract links from a web page using selectolax.
-
-    Args:
-        url: URL to fetch and extract links from
-        timeout: Request timeout in seconds (default: 30.0)
-        headers: Optional HTTP headers to send
-        css_selector: CSS selector for links (default: "a[href]")
-        include_external: Whether to include external links (default: True)
-        include_internal: Whether to include internal links (default: True)
-        base_url: Base URL for resolving relative links (uses page URL if not provided)
-
-    Returns:
-        List of link dictionaries with href, text, title, and type (internal/external)
-
-    Raises:
-        httpx.HTTPError: If request fails
-        Exception: If parsing fails
-    """
-
-    async def _extract_page_links_async():
-        client = _get_search_client()
-        return await client.extract_page_links(
-            url=url,
-            timeout=timeout,
-            headers=headers,
-            css_selector=css_selector,
-            include_external=include_external,
-            include_internal=include_internal,
-            base_url=base_url,
-        )
-
-    return asyncio.run(_extract_page_links_async())

hammad/yaml/__init__.py

@@ -1,30 +0,0 @@
-"""hammad.yaml
-
-Simply extends the `msgspec.yaml` submodule."""
-
-from typing import TYPE_CHECKING
-from .._core._utils._import_utils import _auto_create_getattr_loader
-
-if TYPE_CHECKING:
-    from .converters import (
-        Yaml,
-        encode_yaml,
-        decode_yaml,
-        read_yaml_file,
-    )
-
-
-__all__ = (
-    "Yaml",
-    "encode_yaml",
-    "decode_yaml",
-    "read_yaml_file",
-)
-
-
-__getattr__ = _auto_create_getattr_loader(__all__)
-
-
-def __dir__() -> list[str]:
-    """Get the attributes of the yaml module."""
-    return list(__all__)

hammad/yaml/converters.py

@@ -1,19 +0,0 @@
-"""hammad.yaml.converters"""
-
-from msgspec.yaml import encode as encode_yaml, decode as decode_yaml
-from ..configuration.configuration import Configuration as Yaml
-
-__all__ = ("encode_yaml", "decode_yaml", "read_yaml_file", "Yaml")
-
-
-def read_yaml_file(path: str) -> Yaml:
-    """Parses a YAML file to return a Configuration object.
-    This utilizes the following file types:
-
-    Args:
-        path (str): The path to the YAML file.
-
-    Returns:
-        Yaml: A Configuration object.
-    """
-    return Yaml.from_file(path)

hammad_python-0.0.13.dist-info/METADATA

@@ -1,38 +0,0 @@
-Metadata-Version: 2.4
-Name: hammad-python
-Version: 0.0.13
-Summary: hammad - *Nightly* hyper-fast opinionated resources and modules built for quick development.
-Author-email: Hammad Saeed <hammadaidev@gmail.com>
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: docstring-parser>=0.16
-Requires-Dist: duckduckgo-search>=8.0.4
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: msgspec>=0.19.0
-Requires-Dist: prompt-toolkit>=3.0.51
-Requires-Dist: pydantic>=2.11.5
-Requires-Dist: python-dotenv>=1.1.0
-Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: rich>=13.9.4
-Requires-Dist: selectolax>=0.3.30
-Requires-Dist: sqlalchemy>=2.0.41
-Requires-Dist: tantivy>=0.24.0
-Requires-Dist: tenacity>=9.0.0
-Requires-Dist: typing-inspect>=0.9.0
-Requires-Dist: uvloop>=0.21.0
-Provides-Extra: ai
-Requires-Dist: instructor>=1.9.0; extra == 'ai'
-Requires-Dist: litellm>=1.72.4; extra == 'ai'
-Requires-Dist: openai-agents>=0.0.19; extra == 'ai'
-Requires-Dist: qdrant-client>=1.14.3; extra == 'ai'
-Provides-Extra: fastembed
-Requires-Dist: fastembed; extra == 'fastembed'
-Provides-Extra: serve
-Requires-Dist: fastapi>=0.115.8; extra == 'serve'
-Requires-Dist: python-multipart>=0.0.19; extra == 'serve'
-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-0.0.13.dist-info/RECORD

@@ -1,85 +0,0 @@
-hammad/__init__.py,sha256=q812SgfUvft8HbB1HLDfuBgt0dBpnTnHc1uprM3HOec,3962
-hammad/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hammad/_core/__init__.py,sha256=AOFUkG80nF2WSgQQSdFE_kehH77gBskKYrzKSNogi8Q,19
-hammad/_core/_utils/__init__.py,sha256=pqNuAShC-0BJ4td85wrwSfXk7zOo1RFde-oO3VUA_iQ,133
-hammad/_core/_utils/_import_utils.py,sha256=uO1XWolUV8Zcu1ZVeTAr6-_Zvwwvxjxew-te968kP0E,6048
-hammad/ai/__init__.py,sha256=vfIDw17dy4ZKL44U7iz4-R5OzUQJFtQs1tAdWaNOWpI,1380
-hammad/ai/_utils.py,sha256=axsCHv66zfjjhlEbxaF_049fClHjQgHtUReXs8nsMwc,3950
-hammad/ai/completions/__init__.py,sha256=7JiR29M-AI5XOcD5lY85GolJcb0B6Jm67I7bbCz6n0g,1058
-hammad/ai/completions/client.py,sha256=ulobB3PTY-hY7JTgMyqiguKhKTE8EivSDW_P1_6H3J8,27387
-hammad/ai/completions/create.py,sha256=jXqBzZ0-K9BzVQX4X70sN8WYYnbcJL_1ZJelgDYd0fw,29970
-hammad/ai/completions/types.py,sha256=9kD_eiZHZ52lKt72y4Nnfb9PmY7jWhq9Ncv5x4spRRI,25575
-hammad/ai/completions/utils.py,sha256=Y9GVl_buljRDrbG0THG9398jJKy4wZc689D4PHiWfJc,13138
-hammad/ai/embeddings/__init__.py,sha256=4KduX3CTfYG8acp9Smhvqhf_24o4eCZsq4c85fE1IXI,1105
-hammad/ai/embeddings/create.py,sha256=voVD6WLvoyIgqIMYOmJKJFxUho8ZIl0YDfbgM4X6B6w,6590
-hammad/ai/embeddings/types.py,sha256=O6MgrGl6431-cH5sRLyNz7BXIehVyfpMDqrCe4wHxyA,1761
-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=814inmH6YgA8mi0hSBKT2P-sCALaiotWNzlsMewQ-Z0,6945
-hammad/ai/embeddings/client/litellm_embeddings_client.py,sha256=7aFspROjacnAA79jm7f0stzlSi4EHwEgZqI7Im2gNic,10031
-hammad/base/__init__.py,sha256=PooFQh69XNCeySLj2bfAuwn5xMI2kesl3WjRmsxukiw,818
-hammad/base/fields.py,sha256=n02Qqq1AkcxwGCGEjcBSu63uWSkcyfxisATr7nwc7DA,19173
-hammad/base/model.py,sha256=_qyJ3IRJTwRXqZsYMpuYP8FTbMfLgh75VbTrTt1Wqx8,39121
-hammad/base/utils.py,sha256=kmdWqDcCTB7y4w5pdAfyrOfpzqj1hjKILIklAwbvNxM,9957
-hammad/cache/__init__.py,sha256=W5CK3JvbfHzS_-KmGIS_ZtjnXuXRjWGmSKaT2eeftEE,1104
-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=81UslbyYQ3-2tJNYQv1pHe5R0_nufAAo6ktpDeuEskQ,758
-hammad/cli/animations.py,sha256=_ILMhyT_02FlLMhROe6br0Fhz2EVEwgOyKHY55qWsJY,20541
-hammad/cli/plugins.py,sha256=61cljGF_V03_6xrBhO0tR-rrlgB44veHh5HXcxMTM3Y,26932
-hammad/cli/styles/__init__.py,sha256=4HE20exLpIQgPGFt6KnCbjiYaK95fXvFJBGGjJZTwMM,1388
-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/configuration/__init__.py,sha256=d1ztew6E-7SsJa_yiBOfXULRAnuFcCCel_MkyrDajXs,852
-hammad/configuration/configuration.py,sha256=Ssty95LALoS9QiviZByXHGyMMe43m63un-Ycz4DFeNw,17732
-hammad/data/__init__.py,sha256=1PzfRx0bsv0AYkGlssCHxWE4zjSpnSTK_tG3uy6RZ-4,884
-hammad/data/collections/__init__.py,sha256=jOl1B1avTYhrHuKi27Iq2n48CDTG9Id8W2xMagEiJ6I,838
-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=f7GIbJdElmIzqcApcCCxmbXgAXng2EY20n2ttBopwE0,21129
-hammad/data/databases/__init__.py,sha256=hPg0ujYlS6cqrNsI5CMqTtXWivXPuxm3nyY7_q63nxs,425
-hammad/data/databases/database.py,sha256=7ngi-oWAsmAdtLTvpT4axw5ftcMzqsCtJmfmjzw5etk,31160
-hammad/json/__init__.py,sha256=-7laMbXoayDBlFDYw9wGgMJSRJ_pnUsI30jJvQsK54M,481
-hammad/json/converters.py,sha256=gXWJRN6OlzqDoL69nZqtyn8ET22Sxv7znso-VVamDR4,5480
-hammad/logging/__init__.py,sha256=NbZO9drdBqYj33MKkISIdSI-xEVqtorxQNAyPL6ySpg,726
-hammad/logging/decorators.py,sha256=xhHRA7WhesgdVMSwK_JvqZhGb90GF3TbYco13Y7aY0w,30119
-hammad/logging/logger.py,sha256=8q-7anLeZk07QlPszdt_qzsQPaeuZyDHevV8C6R_okk,31451
-hammad/multimodal/__init__.py,sha256=58zgdyWQTW9_YNED8mlOKBK6AgBjeuteOcvE3QZANRs,444
-hammad/multimodal/audio.py,sha256=cnmjfnLAQxlh7b8EfDlfk541PzzLL102bOlj5atDSPA,2777
-hammad/multimodal/image.py,sha256=eRlsCu1oSdlRtcJ8zGlD4np77pvqWMCDPU6FNJ6zNmg,2265
-hammad/multithreading/__init__.py,sha256=akEIhZndORW1dg3HvfVjDaYJv4IyB_fP6DQt1fH_ums,10788
-hammad/pydantic/__init__.py,sha256=5ZZfqSrXEapkDcEM5kcOcjs4_tfKlxHyIhK1u-veb3I,1017
-hammad/pydantic/converters.py,sha256=vlxVoPMY6IpwH4U1B0iVnW3p6VC8M7tINx8o9FU1JOI,20203
-hammad/pydantic/models/__init__.py,sha256=N8-B-_pAZ7mGpzEeE1M65hda8iQC-SWjDnzIS3gRTg8,671
-hammad/pydantic/models/arbitrary_model.py,sha256=XSsB2hMC3bCHwyLXepe1D_S3M57yaWG5QUBo3pAoG_M,1524
-hammad/pydantic/models/cacheable_model.py,sha256=JDzV5kZrgEPovE3M2bF4scoCAoGEhISeMhc69cifDfM,2809
-hammad/pydantic/models/fast_model.py,sha256=WVJxcUQydScQLhzMOh88Kn2WIFtN5cel_srI6UL3kVk,11716
-hammad/pydantic/models/function_model.py,sha256=pMtCM2slqJso77L5WuCMoNtm3gO_OMoSe87tgODaZJM,6300
-hammad/pydantic/models/subscriptable_model.py,sha256=yJ-PpaXPu0eKEktNrGizj5rOSHLGclDAGjwtnYYAcgY,1706
-hammad/text/__init__.py,sha256=xt4wjg5XvGMIEkr2mD5s__V6QHLX9C0GTIAtquNiyZM,1853
-hammad/text/converters.py,sha256=LmgyPGrRQrvyNZQlWOiTKfnSQcEtSlTznN7blPIv6Qk,23800
-hammad/text/markdown.py,sha256=13vS7HmBZIrktua5JoI1CBmigQkk7gJzndEzYkMYjvU,3402
-hammad/text/text.py,sha256=Fjp0n6upyXLlzecamcY7xzx1j2rFlda_2qPoiyYinVo,33309
-hammad/types/__init__.py,sha256=0ouYhOy3FydxEn4GUXbWWZ-5FMgLsU2NnQzyaCgKqBQ,336
-hammad/types/file.py,sha256=o3JSqQyCcKmRtAzk4oltnmzXZ60STL0VEiunOGfNVfk,11102
-hammad/typing/__init__.py,sha256=jQEwoJVMdgk1VQTLyMiJaU7l5P8JIvcvwcjMazE7iSo,10923
-hammad/web/__init__.py,sha256=WQYIzWKMG7p1WqONX2P6V-jagmBK2TLe_1N4fio4lUE,1078
-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=N_w9WFwolrb43BTNbmi2feHJBoB7Z8PX-XOsHyS6efo,33147
-hammad/web/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-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/yaml/__init__.py,sha256=0w5YV4fOF33-9AyfKJcWhhCOnzrBOyzJAHXJLvTLml8,547
-hammad/yaml/converters.py,sha256=h2tb7IxlXVvjQs_E2uyTo6LTklUzTVh8lehur-p6iGs,527
-hammad_python-0.0.13.dist-info/METADATA,sha256=172JcN_IATs1WVRuluJTmq3d1qbQR48LKY-HQnxrOp4,1430
-hammad_python-0.0.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hammad_python-0.0.13.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
-hammad_python-0.0.13.dist-info/RECORD,,