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

hammad/text/utils/__init__.py

@@ -0,0 +1 @@
+"""hammad.text.utils"""

hammad/{utils/text → text/utils}/converters.py

@@ -1,4 +1,4 @@
-"""hammad.utils.text.converters"""
+"""hammad.text.utils.converters"""
 
 from docstring_parser import parse
 from typing import (
@@ -6,7 +6,7 @@ from typing import (
     Optional,
 )
 
-from ..typing.utils import (
+from ...typing import (
     inspection,
     is_pydantic_basemodel,
     is_msgspec_struct,

hammad/text/utils/markdown/__init__.py

@@ -0,0 +1 @@
+"""hammad.text.utils.markdown"""

hammad/{utils → text/utils}/markdown/converters.py

@@ -1,4 +1,4 @@
-"""hammad.utils.markdown.converters"""
+"""hammad.text.utils.markdown.converters"""
 
 import json
 import logging
@@ -15,12 +15,12 @@ from typing import (
     Union,
 )
 
-from ..typing.utils import (
+from ....typing import (
     is_pydantic_basemodel,
     is_pydantic_basemodel_instance,
     is_msgspec_struct,
 )
-from ..text.converters import convert_type_to_text as convert_type_to_string
+from ...utils.converters import convert_type_to_text as convert_type_to_string
 from .formatting import (
     bold,
     italic,

hammad/{utils → text/utils}/markdown/formatting.py

@@ -1,4 +1,4 @@
-"""hammad.utils.markdown.formatting"""
+"""hammad.text.utils.markdown.formatting"""
 
 from typing import (
     List,

hammad/{utils/typing/utils.py → typing/__init__.py}

@@ -1,4 +1,4 @@
-"""hammad.utils.typing.utils
+"""hammad.utils.typing
 
 Contains various utility functions in regards to typing or working
 with type hints. These utils are also exposed in:
@@ -11,7 +11,7 @@ hammad.typing.get_type_description(Optional[int])
 ```
 """
 
-from typing import Any
+from typing import Any, TYPE_CHECKING
 import typing_inspect as inspection
 from typing_inspect import (
     is_callable_type,
@@ -63,6 +63,10 @@ __all__ = (
     "is_union_origin",
     "inspect_annotation",
     "get_literal_values",
+    "get_last_args",
+    "get_last_origin",
+    "get_generic_bases",
+    "get_typed_dict_keys",
 )
 
 
@@ -278,3 +282,72 @@ def get_type_description(t: Any) -> str:
         return f"typevar({t.__name__})"
 
     return str(t)
+
+
+if TYPE_CHECKING:
+    pass
+
+
+def create_lazy_loader(imports_dict: dict[str, str], package: str):
+    """Create a lazy loader function for __getattr__.
+
+    Args:
+        imports_dict: Dictionary mapping attribute names to their module paths
+        package: The package name for import_module
+
+    Returns:
+        A __getattr__ function that lazily imports modules
+    """
+
+    def __getattr__(name: str):
+        if name in imports_dict:
+            from importlib import import_module
+
+            module = import_module(imports_dict[name], package)
+            return getattr(module, name)
+        raise AttributeError(f"module '{package}' has no attribute '{name}'")
+
+    return __getattr__
+
+
+def parse_type_checking_imports(source_code: str) -> dict[str, str]:
+    """Parse TYPE_CHECKING imports from source code to build import map.
+
+    This is a simple parser that extracts import information from
+    TYPE_CHECKING blocks to automatically build the module map.
+
+    Args:
+        source_code: The source code containing TYPE_CHECKING imports
+
+    Returns:
+        Dictionary mapping imported names to their module paths
+    """
+    import ast
+    import re
+
+    # Parse the source code
+    tree = ast.parse(source_code)
+
+    imports_map = {}
+    in_type_checking = False
+
+    for node in ast.walk(tree):
+        # Check if we're in a TYPE_CHECKING block
+        if isinstance(node, ast.If):
+            if (
+                isinstance(node.test, ast.Name) and node.test.id == "TYPE_CHECKING"
+            ) or (
+                isinstance(node.test, ast.Attribute)
+                and isinstance(node.test.value, ast.Name)
+                and node.test.value.id == "typing"
+                and node.test.attr == "TYPE_CHECKING"
+            ):
+                # Process imports in the TYPE_CHECKING block
+                for stmt in node.body:
+                    if isinstance(stmt, ast.ImportFrom):
+                        module = stmt.module or ""
+                        for alias in stmt.names:
+                            name = alias.asname or alias.name
+                            imports_map[name] = f".{module}"
+
+    return imports_map

hammad/web/__init__.py

@@ -0,0 +1,42 @@
+"""hammad.web"""
+
+from typing import TYPE_CHECKING
+from ..based.utils import auto_create_lazy_loader
+
+if TYPE_CHECKING:
+    from .utils import (
+        run_web_request,
+        read_web_page,
+        read_web_pages,
+        search_web,
+        search_news,
+        extract_page_links,
+    )
+    from .http.client import AsyncHttpClient, HttpClient, create_http_client
+    from .openapi.client import AsyncOpenAPIClient, OpenAPIClient, create_openapi_client
+    from .search.client import AsyncSearchClient, SearchClient, create_search_client
+
+__all__ = (
+    "run_web_request",
+    "read_web_page",
+    "read_web_pages",
+    "search_web",
+    "search_news",
+    "extract_page_links",
+    "AsyncHttpClient",
+    "HttpClient",
+    "create_http_client",
+    "AsyncOpenAPIClient",
+    "OpenAPIClient",
+    "create_openapi_client",
+    "AsyncSearchClient",
+    "SearchClient",
+    "create_search_client",
+)
+
+__getattr__ = auto_create_lazy_loader(__all__)
+
+
+def __dir__() -> list[str]:
+    """Get the attributes of the web module."""
+    return list(__all__)

hammad/web/http/__init__.py

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