hammad-python 0.0.31__tar.gz → 0.0.33__tar.gz

{hammad_python-0.0.31 → hammad_python-0.0.33}/.gitignore

@@ -11,8 +11,6 @@ dev/
 # For Dev
 tester.py
 .z/
-# internal publisih script
-publish.sh
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{hammad_python-0.0.31 → hammad_python-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammad-python
-Version: 0.0.31
+Version: 0.0.33
 Summary: Personal Python utilities and tools
 Author-email: Hammad Saeed <hammadaidev@gmail.com>
 License: MIT License
@@ -26,10 +26,10 @@ License: MIT License
         SOFTWARE.
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: hammad-python-core>=0.0.1
-Requires-Dist: hammad-python-data>=0.0.1
-Requires-Dist: hammad-python-genai>=0.0.1
-Requires-Dist: hammad-python-http>=0.0.1
+Requires-Dist: hammad-python-core>=0.0.2
+Requires-Dist: hammad-python-data>=0.0.2
+Requires-Dist: hammad-python-genai>=0.0.2
+Requires-Dist: hammad-python-http>=0.0.2
 Description-Content-Type: text/markdown
 
 ## hammad-python

hammad_python-0.0.33/ham/__init__.py

@@ -0,0 +1,200 @@
+"""ham
+
+```markdown
+## `hammad-python`
+
+Fun bunch of stuff ***:)***
+
+This module is a collection over various sub-packages that
+define the `ham` namespace. These packages include:
+
+- `hammad-python-core`
+- `hammad-python-data`
+- `hammad-python-genai`
+- `hammad-python-http`
+```
+
+You can access a variety of the primary resources from these modules
+directly from this top level module.
+"""
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+
+from typing import TYPE_CHECKING
+
+try:
+    from ham.core._internal import type_checking_importer
+except ImportError:
+    from .core._internal import type_checking_importer  # type: ignore
+
+
+if TYPE_CHECKING:
+    try:
+        # ham.core
+        from ham.core._internal._logging import set_debug, set_verbose
+        from ham.core.cache import cached, auto_cached
+        from ham.core.cli import print, animate, input, log, log_iterable, log_progress
+        from ham.core.conversion import (
+            convert_to_text,
+            convert_to_json_schema,
+            convert_to_model,
+            convert_to_pydantic_model,
+        )
+        from ham.core.logging import get_logger, trace, trace_http
+
+        # ham.data
+        from ham.data.collections import (
+            create_collection,
+        )
+
+        # ham.genai
+        from ham.genai.models.embeddings import run_embedding_model
+        from ham.genai.models.language import run_language_model
+        from ham.genai.models.reranking import run_reranking_model
+        from ham.genai.models.multimodal import (
+            run_image_generation_model,
+            run_transcription_model,
+            run_tts_model,
+        )
+        from ham.genai.agents import create_agent, run_agent, run_agent_iter
+        from ham.genai.graphs import (
+            # NOTE: lol... uh i just really wanted everything to be lowercase..
+            # this may need a once over
+            BaseGraph as basegraph,
+            action as graphaction,
+        )
+        from ham.genai.prompted import (
+            prompted_fn as prompted,
+            contextualize,
+            itemize,
+            select,
+            tool,
+        )
+        from ham.genai.a2a import as_a2a_app
+
+        # ham.http
+        from ham.http import (
+            create_client,
+            create_openapi_client,
+            create_http_client,
+            create_mcp_client,
+            create_server,
+            create_fast_service,
+            function_server,
+            function_mcp_server,
+            run_web_request,
+            read_web_page,
+            read_web_pages,
+            run_web_search,
+            run_news_search,
+            extract_web_page_links,
+            create_search_client,
+        )
+    except ImportError:
+        from ham.core._internal import (  # type: ignore
+            set_debug,
+            set_verbose,
+        )
+        from ham.data import (  # type: ignore
+            create_collection,
+        )
+        from ham.genai import (  # type: ignore
+            create_agent,
+            run_agent,
+            run_agent_iter,
+            run_embedding_model,
+            run_language_model,
+            run_reranking_model,
+            run_image_generation_model,
+            run_transcription_model,
+            run_tts_model,
+            basegraph,
+            graphaction,
+            prompted,
+            contextualize,
+            itemize,
+            select,
+            tool,
+        )
+        from ham.http import (  # type: ignore
+            create_client,
+            create_openapi_client,
+            create_http_client,
+            create_mcp_client,
+            create_server,
+            create_fast_service,
+            function_server,
+            function_mcp_server,
+            run_web_request,
+            read_web_page,
+            read_web_pages,
+            run_web_search,
+            run_news_search,
+            extract_web_page_links,
+            create_search_client,
+        )
+
+
+__all__ = (
+    # ham.core
+    "set_debug",
+    "set_verbose",
+    "cached",
+    "auto_cached",
+    "print",
+    "animate",
+    "input",
+    "log",
+    "log_iterable",
+    "log_progress",
+    "convert_to_text",
+    "convert_to_json_schema",
+    "convert_to_model",
+    "convert_to_pydantic_model",
+    "get_logger",
+    "trace",
+    "trace_http",
+    # ham.data
+    "create_collection",
+    # ham.genai
+    "create_agent",
+    "run_agent",
+    "run_agent_iter",
+    "run_embedding_model",
+    "run_language_model",
+    "run_reranking_model",
+    "run_image_generation_model",
+    "run_transcription_model",
+    "run_tts_model",
+    "basegraph",
+    "graphaction",
+    "prompted",
+    "contextualize",
+    "itemize",
+    "select",
+    "tool",
+    # ham.http
+    "create_client",
+    "create_openapi_client",
+    "create_http_client",
+    "create_mcp_client",
+    "create_server",
+    "create_fast_service",
+    "function_server",
+    "function_mcp_server",
+    "run_web_request",
+    "read_web_page",
+    "read_web_pages",
+    "run_web_search",
+    "run_news_search",
+    "extract_web_page_links",
+    "create_search_client",
+)
+
+
+__getattr__ = type_checking_importer(__all__)
+
+
+def __dir__() -> list[str]:
+    """Get the attributes of the hammad module."""
+    return __all__

{hammad_python-0.0.31 → hammad_python-0.0.33}/libs/hammad-python-core/ham/core/__init__.py

@@ -41,6 +41,7 @@ if TYPE_CHECKING:
         convert_to_model,
         convert_to_text,
         convert_type_to_text,
+        convert_to_pydantic_model,
     )
     from .logging import (
         Logger,
@@ -94,6 +95,7 @@ __all__ = (
     "convert_to_model",
     "convert_to_text",
     "convert_type_to_text",
+    "convert_to_pydantic_model",
     # ham.core.logging
     "Logger",
     "LoggerLevelName",

{hammad_python-0.0.31 → hammad_python-0.0.33}/libs/hammad-python-core/ham/core/_internal/_import_utils.py

@@ -96,32 +96,47 @@ def _parse_type_checking_imports(source_code: str) -> dict[str, tuple[str, str]]
                         is_type_checking = True
 
                 if is_type_checking:
-                    # Process imports in this block
-                    for stmt in node.body:
-                        if isinstance(stmt, ast.ImportFrom) and stmt.module:
-                            # Only add '.' prefix for relative imports
-                            # If stmt.level > 0, it's already a relative import
-                            # If stmt.level == 0 and module doesn't start with '.', it's absolute
-                            if stmt.level > 0:
-                                # Already relative import
-                                module_path = "." * stmt.level + (stmt.module or "")
-                            elif stmt.module.startswith("."):
-                                # Explicit relative import
-                                module_path = stmt.module
-                            elif any(
-                                stmt.module.startswith(name)
-                                for name in ["litellm", "openai", "instructor", "httpx"]
-                            ):
-                                # Known absolute third-party imports
-                                module_path = stmt.module
-                            else:
-                                # Default to relative import for internal modules
-                                module_path = f".{stmt.module}"
-
-                            for alias in stmt.names:
-                                original_name = alias.name
-                                local_name = alias.asname or original_name
-                                imports[local_name] = (module_path, original_name)
+                    # Process imports in this block (recursively handle nested blocks)
+                    def process_import_statements(statements):
+                        for stmt in statements:
+                            if isinstance(stmt, ast.ImportFrom) and stmt.module:
+                                # Only add '.' prefix for relative imports
+                                # If stmt.level > 0, it's already a relative import
+                                # If stmt.level == 0 and module doesn't start with '.', it's absolute
+                                if stmt.level > 0:
+                                    # Already relative import
+                                    module_path = "." * stmt.level + (stmt.module or "")
+                                elif stmt.module.startswith("."):
+                                    # Explicit relative import
+                                    module_path = stmt.module
+                                elif any(
+                                    stmt.module.startswith(name)
+                                    for name in [
+                                        "litellm",
+                                        "openai",
+                                        "instructor",
+                                        "httpx",
+                                        "ham",
+                                    ]
+                                ):
+                                    # Known absolute imports (third-party and internal ham modules)
+                                    module_path = stmt.module
+                                else:
+                                    # Default to relative import for other internal modules
+                                    module_path = f".{stmt.module}"
+
+                                for alias in stmt.names:
+                                    original_name = alias.name
+                                    local_name = alias.asname or original_name
+                                    imports[local_name] = (module_path, original_name)
+                            elif isinstance(stmt, ast.Try):
+                                # Recursively process try blocks
+                                process_import_statements(stmt.body)
+                                # Also process except blocks
+                                for except_handler in stmt.handlers:
+                                    process_import_statements(except_handler.body)
+
+                    process_import_statements(node.body)
 
         return imports
 

{hammad_python-0.0.31 → hammad_python-0.0.33}/libs/hammad-python-core/ham/core/conversion/__init__.py

@@ -12,6 +12,7 @@ from .._internal import type_checking_importer
 if TYPE_CHECKING:
     from .models.converters import convert_to_model
     from .json import convert_to_json_schema
+    from .pydantic.converters import convert_to_pydantic_model, is_pydantic_model_class
     from .text import convert_to_text, convert_type_to_text, convert_docstring_to_text
 
 
@@ -20,6 +21,9 @@ __all__ = (
     "convert_to_model",
     # ham.core.conversion.json
     "convert_to_json_schema",
+    # ham.core.conversion.pydantic
+    "convert_to_pydantic_model",
+    "is_pydantic_model_class",
     # ham.core.conversion.text
     "convert_to_text",
     "convert_type_to_text",

hammad_python-0.0.33/libs/hammad-python-core/ham/core/conversion/pydantic/__init__.py

@@ -0,0 +1,42 @@
+"""ham.core.conversion.pydantic
+
+Contains both models and pydantic **specific** utiltiies / resources
+meant for general case usage."""
+
+from typing import TYPE_CHECKING
+from ..._internal import type_checking_importer
+
+if TYPE_CHECKING:
+    from .converters import (
+        convert_to_pydantic_model,
+        convert_to_pydantic_field,
+        convert_dataclass_to_pydantic_model,
+        convert_dict_to_pydantic_model,
+        convert_function_to_pydantic_model,
+        convert_sequence_to_pydantic_model,
+        convert_type_to_pydantic_model,
+        create_confirmation_pydantic_model,
+        create_selection_pydantic_model,
+    )
+
+
+__all__ = [
+    # hammad.lib.pydantic.converters
+    "convert_to_pydantic_model",
+    "convert_to_pydantic_field",
+    "convert_dataclass_to_pydantic_model",
+    "convert_dict_to_pydantic_model",
+    "convert_function_to_pydantic_model",
+    "convert_sequence_to_pydantic_model",
+    "convert_type_to_pydantic_model",
+    "create_confirmation_pydantic_model",
+    "create_selection_pydantic_model",
+]
+
+
+__getattr__ = type_checking_importer(__all__)
+
+
+def __dir__() -> list[str]:
+    """Get the attributes of the models module."""
+    return __all__