hammad-python 0.0.10__py3-none-any.whl → 0.0.11__py3-none-any.whl

hammad/web/utils.py

@@ -0,0 +1,463 @@
+"""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
+
+__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,
+) -> List[Dict[str, str]]:
+    """
+    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,
+) -> Dict[str, Any]:
+    """
+    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,
+) -> List[Dict[str, Any]]:
+    """
+    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,
+) -> List[Dict[str, str]]:
+    """
+    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,
+) -> List[Dict[str, str]]:
+    """
+    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

@@ -0,0 +1,30 @@
+"""hammad.yaml
+
+Simply extends the `msgspec.yaml` submodule."""
+
+from typing import TYPE_CHECKING
+from ..based.utils import auto_create_lazy_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_lazy_loader(__all__)
+
+
+def __dir__() -> list[str]:
+    """Get the attributes of the yaml module."""
+    return list(__all__)

hammad/yaml/converters.py

@@ -0,0 +1,19 @@
+"""hammad.yaml.converters"""
+
+from msgspec.yaml import encode as encode_yaml, decode as decode_yaml
+from ..data.types 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.10.dist-info → hammad_python-0.0.11.dist-info}/METADATA

@@ -1,23 +1,29 @@
 Metadata-Version: 2.4
 Name: hammad-python
-Version: 0.0.10
+Version: 0.0.11
 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>=7.3.0
+Requires-Dist: duckduckgo-search>=8.0.4
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: msgspec>=0.19.0
-Requires-Dist: platformdirs>=4.3.8
+Requires-Dist: prompt-toolkit>=3.0.51
 Requires-Dist: pydantic>=2.11.5
-Requires-Dist: sqlalchemy>=2.0.41
+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: 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.8.3; extra == 'ai'
-Requires-Dist: litellm; extra == 'ai'
-Requires-Dist: memvid; extra == 'ai'
-Requires-Dist: openai-agents; 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: serve
 Requires-Dist: fastapi>=0.115.8; extra == 'serve'
 Requires-Dist: python-multipart>=0.0.19; extra == 'serve'

hammad_python-0.0.11.dist-info/RECORD

@@ -0,0 +1,65 @@
+hammad/__init__.py,sha256=eeb0R0wxMJGlYNT6ksfI_nWrVoFt5Oy7XnwYs0TbDpM,1355
+hammad/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hammad/based/__init__.py,sha256=cqAMf0nN2BzTMldMlh5ZvVrVRhSy5A0W9HxzHsXoLOY,1168
+hammad/based/fields.py,sha256=dVwVx-hjDwxEkuqkndchZxGVWvAAl9B5XuLti2JziYA,19288
+hammad/based/model.py,sha256=ROnby4MWqBDtgLG28Ywp4cmJJtGjXo1a4zjKPDYTWSc,35561
+hammad/based/utils.py,sha256=0kEiHng2ybFk1YrDJHzzhsdwhhectfIbiWk0CvNGhzo,16023
+hammad/cache/__init__.py,sha256=tFoiLMuw150cJ5tZTSMYa-H4n7mzhsCCjtD714RtH-0,515
+hammad/cache/_cache.py,sha256=XBsRoPYT1bVYx9rLYKoD8whTUpepp91PYyJs6lhuB6o,25295
+hammad/cli/__init__.py,sha256=mxlAWQnXBrPDBS0aneWe6j7snrzDgKp6wrd87qI8L9A,496
+hammad/cli/plugins/__init__.py,sha256=1l4e68XzmMIaKXTkzLPoxECXosGaW8IOK1kEaqh9nJ0,25971
+hammad/cli/styles/__init__.py,sha256=G-j_Sx8uOUYR4HjbcOYuA26HXZ5-yd5y8SS3Qj5o_7U,189
+hammad/cli/styles/animations.py,sha256=vYEfOKBvCGvXMNu7jJGkxX8_XUjEuKoMvKCMGKIXMUg,17874
+hammad/cli/styles/settings.py,sha256=i07i7y6YoTr5HkeWbgYRA9JwZv2AKcC0o4KBkHunARA,5409
+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=B1g9mPhe9L6tQ9QbfiUEG16j16-jinaFQa9khTLoOMo,1273
+hammad/data/collections/__init__.py,sha256=vujWqbnhTftqXjrmvKG949cLr6nD-azWHdng1jEpNvw,777
+hammad/data/collections/base_collection.py,sha256=ZRht7OZjLIT8GxNvMgNxTarbCTY6EUUurEkGHZ3Rsy4,1419
+hammad/data/collections/collection.py,sha256=JnOmD7E0GkBA7VBS7yJjXS76Rvo4dAT7KZk9SmLtZ1g,7436
+hammad/data/collections/searchable_collection.py,sha256=vCV_JgMwB57QRi4Cri6dfEUzLCyTBN58_JfWEKL2h_0,21361
+hammad/data/collections/vector_collection.py,sha256=D0aNyRwTe6VOyDAFS9Iyiw_4isvVNjudoGtd1KElSPU,17241
+hammad/data/databases/__init__.py,sha256=NfRKlADRMzOsPrspOCyA0GmmCoHVXXqRfriqOZrDiYw,402
+hammad/data/databases/database.py,sha256=jteV-P8BMsPd9NA_J-jeFkOQN3uFNitaDZN5uwv2yRY,18946
+hammad/data/types/__init__.py,sha256=P_dM1RZf3W0zYpRV0KSZw24pHKQxCAl9tRV51BZwOHk,729
+hammad/data/types/files/__init__.py,sha256=ufxESRe0PYBSxIs4FMhEUWK1DdlLpBFiaHyxsQuRtAg,30
+hammad/data/types/files/audio.py,sha256=T5t4P6UN2oFUgzj-bVkWpEGZ91A8M-HxNxC65peOQjA,2361
+hammad/data/types/files/configuration.py,sha256=PFg5InnHdGRyOMOySNL5u4ufo3uDORYAthgnlX2ATzQ,15457
+hammad/data/types/files/document.py,sha256=9it-VC6gaTXqDGhFjzVenTr9Zb5RkXAcMpPaDWKC_Wk,6305
+hammad/data/types/files/file.py,sha256=LWr5LaUljJfLTWvwDIAj37tuIa3Z7IG4SQcqn87xEwE,11204
+hammad/data/types/files/image.py,sha256=orCnLwtthYV0ohzOLhIhWef6S4NgdBBw4udw-MbSnxI,2281
+hammad/json/__init__.py,sha256=hCyzw5Hyyf7YqsED7P52DtMHM2XvZtdsaxV0y8nSkps,458
+hammad/json/converters.py,sha256=gXWJRN6OlzqDoL69nZqtyn8ET22Sxv7znso-VVamDR4,5480
+hammad/logging/__init__.py,sha256=FwpYFBF8wpYxDKXtRBhQQFP8ymFuNF5bnTBu5DFhK8s,557
+hammad/logging/decorators.py,sha256=Wa3q063UxJDd9Orx-unkLkVF8Mt-KWNcWV6SwS5YOqg,14756
+hammad/logging/logger.py,sha256=jk23wkdAf8qeKStBEUMWxEESuEXR4OWPYChEMsPYyrY,17543
+hammad/pydantic/__init__.py,sha256=0qljzy1ZdTHSSly1KbhgdyLyVPU7JjX5uDKUdFuYFuA,994
+hammad/pydantic/converters.py,sha256=d5fDXHTrxVCpBi3H-OuZShxD_BeCev5hupcsvC6csg8,20199
+hammad/pydantic/models/__init__.py,sha256=HR9sQ_pC0Xaw8o_FgQwW-tT2hqHXRTLhhFxBXXcdKIY,648
+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=5oDbPD74ziwPGew36SXeV0ltwutNyigzVRfj6y0WTfQ,771
+hammad/text/text.py,sha256=F1XD2YvXlbS8N18eH97FTaKN5haODTgAA8vGzuy3dcs,33388
+hammad/text/utils/__init__.py,sha256=c4GEfUadmnhrx3h5T0JT38icULObriObPOucrr1tiL4,24
+hammad/text/utils/converters.py,sha256=cBlOJ5qPGsBhP7q785ITuuLRR0RPhr0HfAyaXGTsiCg,8208
+hammad/text/utils/markdown/__init__.py,sha256=TK4Nm88dkMyemsUmWD8uS8zSo4hDwkFhElIcOyQkVPs,33
+hammad/text/utils/markdown/converters.py,sha256=aZze09fEB__WHiV08DGGxXAZWX4OgR90m0P3bwy6Crk,15406
+hammad/text/utils/markdown/formatting.py,sha256=XCldk1sVfkQF-c1aMZOjkIy8xNIddi0VGwQaOqmrWCY,3209
+hammad/typing/__init__.py,sha256=UMUo_-BsDBGVfk7ByWzymsoaxnAcK-Svp-g3d9BN0CI,10694
+hammad/web/__init__.py,sha256=vh1HjRhhHb0yESYf6JdSyaRjjTZVAn3Q3kJ8vu9uhO8,1054
+hammad/web/utils.py,sha256=B4GAVsdKgFgVUMOGI0L2_3HKVSjeJsFRml4RevTA6Ic,15685
+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=_ifT8RcW6Xibhg8J-ouEc7BRA2cTd0xQO3rzOjM53t0,33692
+hammad/yaml/__init__.py,sha256=HJb_8-xFxizGFEIbELN2sTEfKB-_wQvA6spj_kkXuCo,524
+hammad/yaml/converters.py,sha256=NQHetbxfkTS3jEJyThsz-hnG2IgRSbaGs_TnqNjFciA,510
+hammad_python-0.0.11.dist-info/METADATA,sha256=buxO0GEAaH-EQG7As4C6B6jBs8MyjyHYime5L-WTjCw,1323
+hammad_python-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hammad_python-0.0.11.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
+hammad_python-0.0.11.dist-info/RECORD,,