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

hammad/web/utils.py

@@ -0,0 +1,472 @@
+"""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",
+    "run_web_search",
+    "read_web_page",
+    "read_web_pages",
+    "run_news_search",
+    "extract_web_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 run_web_search(
+    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 _run_web_search_async():
+        client = _get_search_client()
+        return await client.web_search(
+            query=query,
+            max_results=max_results,
+            region=region,
+            safesearch=safesearch,
+            timelimit=timelimit,
+            backend=backend,
+        )
+
+    return asyncio.run(_run_web_search_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 run_news_search(
+    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 _run_news_search_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(_run_news_search_async())
+
+
+def extract_web_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_web_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_web_page_links_async())

{hammad_python-0.0.15.dist-info → hammad_python-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammad-python
-Version: 0.0.15
+Version: 0.0.16
 Author-email: Hammad Saeed <hammadaidev@gmail.com>
 License: MIT License
         
@@ -39,6 +39,13 @@ Provides-Extra: ai
 Requires-Dist: instructor>=1.9.0; extra == 'ai'
 Requires-Dist: litellm>=1.73.6; extra == 'ai'
 Requires-Dist: qdrant-client>=1.14.3; extra == 'ai'
+Provides-Extra: all
+Requires-Dist: fastapi>=0.115.6; extra == 'all'
+Requires-Dist: instructor>=1.9.0; extra == 'all'
+Requires-Dist: litellm>=1.73.6; extra == 'all'
+Requires-Dist: mcp>=1.10.1; extra == 'all'
+Requires-Dist: qdrant-client>=1.14.3; extra == 'all'
+Requires-Dist: uvicorn>=0.34.0; extra == 'all'
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.10.1; extra == 'mcp'
 Provides-Extra: serve

hammad_python-0.0.16.dist-info/RECORD

@@ -0,0 +1,110 @@
+hammad/__init__.py,sha256=oFJJe9k2BTTPxkvJwsbr7d_HejtUl9clSsgxsHPU_Mk,3619
+hammad/_internal.py,sha256=00ZXmXIlE3P_cewYrPsJuO38vYqhHY2XnFzFpzXgoyY,7871
+hammad/cache/__init__.py,sha256=29vI8UkVITtiEe7fTr9UR5Q0lV7tr_SVe7tLlJmm1Ks,954
+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=DkBgA8zkdsOmReoPI5dqni5l5DGkaA7TzrIFvmy5MIo,785
+hammad/cli/_runner.py,sha256=hZVS_hQbxazfdWFog9V1pQeD11XU7pT7H8_Gop8Xd5c,9539
+hammad/cli/animations.py,sha256=h68OuJBkDiYTLdB5pLPgQ2gpPT2c3dNulkDv2BtKHFA,19507
+hammad/cli/plugins.py,sha256=433XcqVmNB50_CqeL2_HOziFwacU9tQeluys7ZegZ4s,30802
+hammad/cli/styles/__init__.py,sha256=Ok7J_uhJgyswNkBWnDw50oTX9Xk1HPksUl3UbmT1qTI,1363
+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=hIpQcDFjyJpRE0gp3RRXVlWfZ83hMGAKD_uQZmAIwrk,28292
+hammad/data/__init__.py,sha256=5htef4M7fsd0wPuGIT0bpBpHeImYEn8pBsS7SxG4Tkk,1827
+hammad/data/collections/__init__.py,sha256=xC1DzECEdL6WU01WDu41eAIcVadUGLWctcD_xspdxb4,1045
+hammad/data/collections/collection.py,sha256=Qg1Kq9nhe6x0U60UXvosVBU08Boxi1qsZZ3SmfqtkT0,10779
+hammad/data/collections/indexes/__init__.py,sha256=MKwemZ59F1No5deRYpft_Dg6x9yUcz0PC0fvEE7eF9o,959
+hammad/data/collections/indexes/qdrant/__init__.py,sha256=yFS70aPt9QRYVjRT5hU8_29OqMNMgmujtMyY1vIStBE,48
+hammad/data/collections/indexes/qdrant/index.py,sha256=KJVON-RDgMJbhTIGvRT6mFIV2cGKLI21g3IZRsMkUGU,26665
+hammad/data/collections/indexes/qdrant/settings.py,sha256=hr5eXTAbesGHDcseA6whIIAUfWMm7zcvIQbRVMlzBdQ,2505
+hammad/data/collections/indexes/qdrant/utils.py,sha256=kqLo1yRhpF20L0t1k54PG3BqG8m7sbXqkov_H9FktDA,6576
+hammad/data/collections/indexes/tantivy/__init__.py,sha256=ugbv5tChrgyM5jN-czXOu5DLsweMgWiqKt5YAKFayDw,45
+hammad/data/collections/indexes/tantivy/index.py,sha256=m02-NPlnSnKrGysZt8L2BtudFZtthNwo6yKcQzgbaO0,13954
+hammad/data/collections/indexes/tantivy/settings.py,sha256=ACR67704pqLsTwCvSpLhi52Oun5s9E5LpUH_OrQwlM4,1397
+hammad/data/collections/indexes/tantivy/utils.py,sha256=fi0EckbRdvLUKSWAAhId8j6JrQ7iI76Y3Ytm3g7udsM,5599
+hammad/data/configurations/__init__.py,sha256=1vJMpKKItA_aCDtOV7ouNpNAwOXhCJ28H_8dilrAzz0,834
+hammad/data/configurations/configuration.py,sha256=ijm2FAyQjZ66Jo2RlT5hjCiAZdC9EnnghmR7Pj5z0Gw,17737
+hammad/data/models/__init__.py,sha256=1s7_qeAA94i0-1wKkfAi4Ee83EZwNaNldJKOvBpPiBE,1172
+hammad/data/models/fields.py,sha256=6H5SbrXhC0KEge5PJNFqN-Ek8RKxt7-eRKC2E7xmoe8,19180
+hammad/data/models/model.py,sha256=gBH6fL9TjSYfAyDHuw-VJdTorML62iisokvTlVzOnhY,39128
+hammad/data/models/utils.py,sha256=KNtr1PlxBizs14gmZqQeG1A7EQ6JHPRrRN0pTr3ucR8,9964
+hammad/data/models/extensions/__init__.py,sha256=dfVDCMBKZYtaMHJRQBShaoMHFcQ6VJcD_5q5Fcc77mQ,128
+hammad/data/models/extensions/pydantic/__init__.py,sha256=2ipoelO4knYSug47Vdt0URHtBNCQIFixJ3tTcawaCtE,1205
+hammad/data/models/extensions/pydantic/converters.py,sha256=_485-4EUQe7-fxlPG2o1wnaU8SDA79AhxMitiUMoIYY,24545
+hammad/data/sql/__init__.py,sha256=ewHFbnGeqYr2Fs51du5dqepUC98qa4eBSQWnbtuYq40,452
+hammad/data/sql/database.py,sha256=S2-MCmgYzgtjwFGzFQjVBUxZMrtdvBj9IGZxh_mKnGo,18780
+hammad/data/sql/types.py,sha256=B89Xu6x0qQCxlRNe8ob-lJAWfHONKCeFUK0TIjyFB5E,3707
+hammad/data/types/__init__.py,sha256=LeyrRKKBbDP2VaTaNEiyJU_1rs52LofD18WUS8rl5gw,758
+hammad/data/types/file.py,sha256=l1mXtyxsmbx0P_U_rnjkgc4N_UQBevAESTAZmBc8eVc,11111
+hammad/data/types/text.py,sha256=rATiwkTsAJ8pWzZ7OBsWX7rDNoKvkeuWsGWd_sbuUaM,33369
+hammad/data/types/multimodal/__init__.py,sha256=LQzomOVQFYnmkQT7hFIxcM261FDXtV3i0uEHB7GXIwU,427
+hammad/data/types/multimodal/audio.py,sha256=rn1G1vwDlt4d30ZumzYBeO0f0OhdtIQBJRCaSkyPHRA,2786
+hammad/data/types/multimodal/image.py,sha256=xp9aWeGkg6FReuFLA63CQ81tv74nFxVtgVjpoDZNjjw,2274
+hammad/formatting/__init__.py,sha256=CkPXIGHLP7xUfRiIPsqBZUCw98uW5HnD1H7uQXZHl8k,346
+hammad/formatting/json/__init__.py,sha256=V4uODCUQdptfyw_D96R3XDopw1bgNIR2ogiEG-Z-FtQ,525
+hammad/formatting/json/converters.py,sha256=usnqYc5N9GHOkTIJKNKiJ3GO9oQo5zYOGmupvJkqUjk,5597
+hammad/formatting/text/__init__.py,sha256=ZAA7D4pwKFjeUxHsnm21QKSTtQ7Fj8ncO__m5Ry_eHY,1506
+hammad/formatting/text/converters.py,sha256=g3z-ZGTaKNVbLFFKBSh6qN2Uz0BSkdxCaN3LR9cAyV8,23806
+hammad/formatting/text/markdown.py,sha256=D17NOoGkoXUBhoOGKelKHwi72iqsAwPU5HEFjRJtLQI,3407
+hammad/formatting/yaml/__init__.py,sha256=4dBeXPi0jx7ELT2_sC2fUYaiY8b8wFiUScLODc9ISEw,462
+hammad/formatting/yaml/converters.py,sha256=zvSB8QGb56uvwO0KjXllfTj9g1FmNINOKR06DTjvXw8,153
+hammad/genai/__init__.py,sha256=tDBxnxcDfa1M2LVGfyj8YnY47yg197aTvW4qWVwTFjM,1952
+hammad/genai/multimodal_models.py,sha256=nBoc-KiWkeOXotAiYiZRnU9DrbDR7Gex0mgYvt6QTbo,1291
+hammad/genai/rerank_models.py,sha256=JFiIQ8AuQVoYcFQHR9iuq_tiocwvlIq1bFTWbGF-_T0,434
+hammad/genai/agents/__init__.py,sha256=AyFkBd70jrLGWa6va1BoiNPutdkwySgeCv_lo97aZB4,25
+hammad/genai/agents/types/__init__.py,sha256=vrIY5_Z2gYINnd5BO5ZbxKS0mW7aqcTWW_1icYFn1Ew,618
+hammad/genai/agents/types/history.py,sha256=YN7vudPkhI1mnQgtf12nw-p2xaqxc4rtc9lruo_RWCw,10043
+hammad/genai/agents/types/tool.py,sha256=EqPaJ2c8z6S5poA-eq8ex6acJ0Vc2_kQ2ePY5triwlU,16780
+hammad/genai/embedding_models/__init__.py,sha256=GAjlkZjX2tMRKqP6AKY0rokRSiRZRpa4T-NbtpldEfc,1085
+hammad/genai/embedding_models/embedding_model.py,sha256=9JiJLarsl2PwP_IGPXPU1Vkh6CpQZJVN7y1VAXPYS-U,6968
+hammad/genai/embedding_models/embedding_model_name.py,sha256=bsHc-3Xx6X5EU6LuiPPlkyZa4W_oTwW4AJhm4hBAs8Y,2504
+hammad/genai/embedding_models/embedding_model_request.py,sha256=nZyUmUaNHR4OTJXFLDE9BACFJ-D8QMECxcDxtlVWPWg,1562
+hammad/genai/embedding_models/embedding_model_response.py,sha256=xrHDej5Ic-R-JAyc6LeDqomCL88w-nv3B42cBZIdTnE,1809
+hammad/genai/embedding_models/run.py,sha256=mq_G5kGkZYf7ZdpCeh7mtyb5GBjrK67065C6R9TgrvY,5083
+hammad/genai/language_models/__init__.py,sha256=BbIFRpC-z02kvUHmPHP7Yo3wrXUkwPGcskB84N3Qz74,1103
+hammad/genai/language_models/_streaming.py,sha256=Rmjnhl_QRu1FpaBBSbX8ijZbyqpNKOJxjyGZ1sY_UYw,23884
+hammad/genai/language_models/_types.py,sha256=9VorMf71rOV5ftBEItsMJmgBocZZPKWrP8yhncA-wd0,8906
+hammad/genai/language_models/language_model.py,sha256=ZOBJjZd0kpHda9hCUcTlxR7-9WB-ZX5wGGJcMZasthY,28782
+hammad/genai/language_models/language_model_request.py,sha256=blGgLaZvEfFUVmT2NHPH9OuCQrfhHQhenRk6QLeTWeI,4378
+hammad/genai/language_models/language_model_response.py,sha256=epq9_kM-KPDoRXWk9SiD07w_i7rOXdCtdOHRGUJgA6g,7709
+hammad/genai/language_models/language_model_response_chunk.py,sha256=2-hJfW0wSdxXTRKxmYZH97PjC9oiOtghzPt4FhPWXRE,1735
+hammad/genai/language_models/run.py,sha256=dA7Ws44H0rpB_WAyWIPKoR5XfHva9FjMC1tNYKOh8mk,21239
+hammad/genai/language_models/_utils/__init__.py,sha256=MjS_wQ5AaGvP806cQ3EboOABHJH3EHkm7Llpdf6uYQM,789
+hammad/genai/language_models/_utils/_completions.py,sha256=nDPMKrIjiMO2FKrxbLgOc4oitiVcAk-c3iVDXKLb3PY,3777
+hammad/genai/language_models/_utils/_messages.py,sha256=WupMWUbEC_QDuDp3ML-AfbCqK8HBRGptn3PqX7ywA0Y,2684
+hammad/genai/language_models/_utils/_requests.py,sha256=_-6wK-3nkHYiVMEN2yxDur5ALOXeiK5wX96MvCTQS5w,7200
+hammad/genai/language_models/_utils/_structured_outputs.py,sha256=Uo60SMM6r6SDtdJnh2tmvdgs9znmmpRvzfMgnAkm8zs,3880
+hammad/logging/__init__.py,sha256=VtskZx0bKEAJ9FHTMflhB1CzeFUxLpDT5HPgcecAXUo,701
+hammad/logging/decorators.py,sha256=VbI1x3P4ft0-0BGjXq7nQgiuNqcXAA51CGmoSn47iSw,30122
+hammad/logging/logger.py,sha256=GQ2SvrRe0igWlVExZKS99QtCENtwP9uX-5FbsvUAazY,31475
+hammad/mcp/__init__.py,sha256=5oTU-BLYjfz6fBHDH9cyWg3DpQ6Qar-jodbCR05SuWo,1123
+hammad/mcp/client/__init__.py,sha256=i6aAYLoMkm78hOog4OssnT7jgkUXHDBQsdtvDLirSmA,795
+hammad/mcp/client/client.py,sha256=ZAyeBEZKXg_ft7wirri1R4w4RXlMuet_z0yDuLxH3-M,20637
+hammad/mcp/client/client_service.py,sha256=quJp02n9tp70l0SJd9jkIuRkdSPeWegzusk-eiV41b0,14990
+hammad/mcp/client/settings.py,sha256=7bLpJYyiUT_H7zp3SDwLyAt9fmiQwL3L89qVTAZYpi8,5913
+hammad/mcp/servers/__init__.py,sha256=5S5JrdkzMRmW1iIlZeQOblx7SFj8sTpG6w0tKLZrNMM,583
+hammad/mcp/servers/launcher.py,sha256=jQDQOqz-cKK2PSEOxoPBCVsBeTABNNjcwTXSWE4-LQA,41606
+hammad/runtime/__init__.py,sha256=qXmY4zP75nv7tRGDe-AizHB76KfDNdXHafnGQCiho8Y,667
+hammad/runtime/decorators.py,sha256=5T56nAwwfH0ZKfnLlDGkDNFYaGBBSrH1i4_yX3Dt5GA,4524
+hammad/runtime/run.py,sha256=VFzoXieSaEg1KlDTTepDIsSyISkWXuxHpNs_AgHX5nM,10802
+hammad/service/__init__.py,sha256=B7wnQkT8e2kFwaigpAcXI_PJ8jlQzxcgTtDDH1p4KSU,1222
+hammad/service/create.py,sha256=Z0Vy-nQUKk_zqLuVOKJye6gLdVSU5HNlPgm4irvRgu8,16224
+hammad/service/decorators.py,sha256=bw-fgnvIjivLjbXUrBxcx-fsEZZI4Evl5zxNnC1HA-o,9940
+hammad/typing/__init__.py,sha256=P9XCKrn-kxyfSLHpY9vraOLV9vyoBz_DzEm6eIH5xWY,11712
+hammad/web/__init__.py,sha256=qg1DcwWRtDhRdQKwEiS2I-GT8ftdHhQ_WYpWzldSJ4Y,1053
+hammad/web/models.py,sha256=LivyMeLnjyRYqCNYzJRu_--IYjOzBiySYXYB9obqlnU,6421
+hammad/web/utils.py,sha256=o-ys9anLDtOTkqvk0Z8gxc-V0lhp0LB03DHFpoj6Ous,15863
+hammad/web/http/__init__.py,sha256=jn9Rn7Yg2cypD7duTTNFuW2wQZx9B63Bde4RJJeDYU0,22
+hammad/web/http/client.py,sha256=LWBSVjvHEuHmOOWq5EUT4zN5w6zSG45bOTk6FiSPHuA,33082
+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=T1--L-EWe8AA9nZPxEehhHTNmWkGCcbQrhZxY84zTYs,36964
+hammad_python-0.0.16.dist-info/METADATA,sha256=viS2fJ0oeUr6yjSPwlfVzK0_6K_jPtlG5h7uJcPDW9c,6214
+hammad_python-0.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hammad_python-0.0.16.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
+hammad_python-0.0.16.dist-info/RECORD,,

hammad_python-0.0.15.dist-info/RECORD

@@ -1,4 +0,0 @@
-hammad_python-0.0.15.dist-info/METADATA,sha256=76e_P5ZnWxhhfnyhA0B91cnlFtAxepwavtFancGsUuw,5907
-hammad_python-0.0.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hammad_python-0.0.15.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
-hammad_python-0.0.15.dist-info/RECORD,,