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

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

@@ -1,4 +1,4 @@
-"""hammad.text.utils.markdown.formatting"""
+"""hammad.text.utils.markdown"""
 
 from typing import (
     List,
@@ -7,60 +7,62 @@ from typing import (
 )
 
 __all__ = (
-    "bold",
-    "italic",
-    "code",
-    "code_block",
-    "heading",
-    "link",
-    "list_item",
-    "table_row",
-    "blockquote",
-    "horizontal_rule",
-    "table",
+    "markdown_bold",
+    "markdown_italic",
+    "markdown_code",
+    "markdown_code_block",
+    "markdown_heading",
+    "markdown_link",
+    "markdown_list_item",
+    "markdown_table_row",
+    "markdown_blockquote",
+    "markdown_horizontal_rule",
+    "markdown_table",
 )
 
 
-def bold(text: str) -> str:
+def markdown_bold(text: str) -> str:
     """Format text as bold in Markdown."""
     return f"**{text}**"
 
 
-def italic(text: str) -> str:
+def markdown_italic(text: str) -> str:
     """Format text as italic in Markdown."""
     return f"*{text}*"
 
 
-def code(text: str) -> str:
+def markdown_code(text: str) -> str:
     """Format text as inline code in Markdown."""
     return f"`{text}`"
 
 
-def code_block(text: str, language: str = "") -> str:
+def markdown_code_block(text: str, language: str = "") -> str:
     """Format text as a code block in Markdown."""
     return f"```{language}\n{text}\n```"
 
 
-def heading(text: str, level: int = 1) -> str:
+def markdown_heading(text: str, level: int = 1) -> str:
     """Format text as a heading in Markdown."""
     if not 1 <= level <= 6:
         level = 1
     return f"{'#' * level} {text}"
 
 
-def link(text: str, url: str) -> str:
+def markdown_link(text: str, url: str) -> str:
     """Format text as a link in Markdown."""
     return f"[{text}]({url})"
 
 
-def list_item(text: str, level: int = 0, ordered: bool = False, index: int = 1) -> str:
+def markdown_list_item(
+    text: str, level: int = 0, ordered: bool = False, index: int = 1
+) -> str:
     """Format text as a list item in Markdown."""
     indent = "  " * level
     marker = f"{index}." if ordered else "-"
     return f"{indent}{marker} {text}"
 
 
-def table_row(cells: List[str], is_header: bool = False) -> str:
+def markdown_table_row(cells: List[str], is_header: bool = False) -> str:
     """Format a table row in Markdown."""
     row = "| " + " | ".join(cells) + " |"
     if is_header:
@@ -69,19 +71,19 @@ def table_row(cells: List[str], is_header: bool = False) -> str:
     return row
 
 
-def blockquote(text: str, level: int = 1) -> str:
+def markdown_blockquote(text: str, level: int = 1) -> str:
     """Format text as a blockquote in Markdown."""
     prefix = ">" * level + " "
     lines = text.split("\n")
     return "\n".join(f"{prefix}{line}" for line in lines)
 
 
-def horizontal_rule() -> str:
+def markdown_horizontal_rule() -> str:
     """Create a horizontal rule in Markdown."""
     return "---"
 
 
-def table(
+def markdown_table(
     headers: List[str],
     rows: List[List[str]],
     alignment: Optional[List[Literal["left", "center", "right"]]] = None,

hammad/text/text.py

@@ -25,13 +25,11 @@ from typing import (
     Generic,
 )
 
-from .utils.markdown.formatting import (
-    heading as md_heading,
-    code_block as md_code_block,
-)
-from .utils.markdown.converters import (
-    convert_to_markdown,
+from .markdown import (
+    markdown_heading,
+    markdown_code_block,
 )
+from .converters import convert_to_text
 
 
 # -----------------------------------------------------------------------------
@@ -234,7 +232,7 @@ class BaseText(ABC):
             if isinstance(self.content, str):
                 parts.append(self.content)
             else:
-                parts.append(convert_to_markdown(self.content, **kwargs))
+                parts.append(convert_to_text(self.content, **kwargs))
 
         # Handle subsections
         for section in self.sections:
@@ -250,7 +248,7 @@ class BaseText(ABC):
 
         # Handle title
         if self.title:
-            parts.append(md_heading(self.title, self.heading_level))
+            parts.append(markdown_heading(self.title, self.heading_level))
 
         # Handle description
         if self.description:
@@ -261,7 +259,7 @@ class BaseText(ABC):
             if isinstance(self.content, str):
                 parts.append(self.content)
             else:
-                parts.append(convert_to_markdown(self.content, **kwargs))
+                parts.append(convert_to_text(self.content, **kwargs))
 
         # Add table of contents if requested (only for top-level documents)
         if kwargs.get("add_toc", False) and self.heading_level == 1:
@@ -271,9 +269,9 @@ class BaseText(ABC):
                     toc_headings.append((section.heading_level, section.title))
 
             if toc_headings:
-                from .utils.markdown.converters import create_markdown_toc
+                from .markdown import markdown_table
 
-                parts.append(create_markdown_toc(toc_headings))
+                parts.append(markdown_table(toc_headings))
 
         # Handle subsections
         for section in self.sections:
@@ -437,13 +435,13 @@ class CodeSection(BaseText):
         parts = []
 
         if self.title:
-            parts.append(md_heading(self.title, self.heading_level))
+            parts.append(markdown_heading(self.title, self.heading_level))
 
         if self.description:
             parts.append(self.description)
 
         if self.content:
-            parts.append(md_code_block(str(self.content), self.language or ""))
+            parts.append(markdown_code_block(str(self.content), self.language or ""))
 
         # Handle subsections
         for section in self.sections:
@@ -466,7 +464,7 @@ class SchemaSection(BaseText):
     def _to_markdown(self, **kwargs) -> str:
         """Convert schema to Markdown documentation."""
         if self.schema_object:
-            return convert_to_markdown(
+            return convert_to_text(
                 self.schema_object,
                 name=self.title,
                 description=self.description,

hammad/types/__init__.py

@@ -0,0 +1,11 @@
+"""hammad.types
+
+Contains functional aliases, types and model-like objects that are used
+internally within the `hammad` package, as well as usable for
+various other cases."""
+
+from typing import TYPE_CHECKING
+from .._core._utils._import_utils import _auto_create_getattr_loader
+
+if TYPE_CHECKING:
+    from .file import File, FileSource

hammad/{data/types/files → types}/file.py

@@ -1,4 +1,4 @@
-"""hammad.data.types.files.file"""
+"""hammad.types.file"""
 
 from pathlib import Path
 import httpx
@@ -6,8 +6,8 @@ from typing import Any, Self
 import mimetypes
 from urllib.parse import urlparse
 
-from ....based.model import BasedModel
-from ....based.fields import basedfield
+from ..base.model import Model
+from ..base.fields import field
 
 __all__ = ("File", "FileSource")
 
@@ -26,41 +26,41 @@ _mime_cache: dict[str, str] = {}
 """Cache for MIME types."""
 
 
-class FileSource(BasedModel, kw_only=True, dict=True, frozen=True):
+class FileSource(Model, kw_only=True, dict=True, frozen=True):
     """Represents the source of a `File` object."""
 
-    is_file: bool = basedfield(default=False)
+    is_file: bool = field(default=False)
     """Whether this data represents a file."""
-    is_dir: bool = basedfield(default=False)
+    is_dir: bool = field(default=False)
     """Whether this data represents a directory."""
-    is_url: bool = basedfield(default=False)
+    is_url: bool = field(default=False)
     """Whether this data originates from a URL."""
-    path: Path | None = basedfield(default=None)
+    path: Path | None = field(default=None)
     """The file path if this is file-based data."""
-    url: str | None = basedfield(default=None)
+    url: str | None = field(default=None)
     """The URL if this is URL-based data."""
-    size: int | None = basedfield(default=None)
+    size: int | None = field(default=None)
     """Size in bytes if available."""
-    encoding: str | None = basedfield(default=None)
+    encoding: str | None = field(default=None)
     """Text encoding if applicable."""
 
 
-class File(BasedModel, kw_only=True, dict=True):
+class File(Model, kw_only=True, dict=True):
     """Base object for all file-like structure types within
     the `hammad` ecosystem."""
 
-    data: Any | None = basedfield(default=None)
+    data: Any | None = field(default=None)
     """The actual data content (bytes, string, path object, etc.)"""
-    type: str | None = basedfield(default=None)
+    type: str | None = field(default=None)
     """The MIME type or identifier for the data."""
 
-    source: FileSource = basedfield(default_factory=FileSource)
+    source: FileSource = field(default_factory=FileSource)
     """The source of the data. Contains metadata as well."""
 
     # Private cached attributes
-    _name: str | None = basedfield(default=None)
-    _extension: str | None = basedfield(default=None)
-    _repr: str | None = basedfield(default=None)
+    _name: str | None = field(default=None)
+    _extension: str | None = field(default=None)
+    _repr: str | None = field(default=None)
 
     @property
     def name(self) -> str | None:

hammad/typing/__init__.py

@@ -1,18 +1,18 @@
-"""hammad.utils.typing
+"""hammad.typing
 
-Contains various utility functions in regards to typing or working
-with type hints. These utils are also exposed in:
-
-```python
-import hammad
-
-hammad.typing.get_type_description(Optional[int])
-...
-```
-"""
+'Namespace' package extension for various **CORE** typing resources and
+types. This is not a collection of built types, rather resources from the
+core `typing` module, `typing_extensions`, `typing_inspect` and other
+resources."""
 
 from typing import Any, TYPE_CHECKING
 import typing_inspect as inspection
+
+try:
+    from typing_extensions import *
+except ImportError:
+    from typing import *
+
 from typing_inspect import (
     is_callable_type,
     is_classvar,
@@ -40,6 +40,129 @@ from typing_inspection.introspection import (
 from dataclasses import is_dataclass
 
 __all__ = (
+    # Super-special typing primitives.
+    "Any",
+    "ClassVar",
+    "Concatenate",
+    "Final",
+    "LiteralString",
+    "ParamSpec",
+    "ParamSpecArgs",
+    "ParamSpecKwargs",
+    "Self",
+    "Type",
+    "TypeVar",
+    "TypeVarTuple",
+    "Unpack",
+    # ABCs (from collections.abc).
+    "Awaitable",
+    "AsyncIterator",
+    "AsyncIterable",
+    "Coroutine",
+    "AsyncGenerator",
+    "AsyncContextManager",
+    "Buffer",
+    "ChainMap",
+    # Concrete collection types.
+    "ContextManager",
+    "Counter",
+    "Deque",
+    "DefaultDict",
+    "NamedTuple",
+    "OrderedDict",
+    "TypedDict",
+    # Structural checks, a.k.a. protocols.
+    "SupportsAbs",
+    "SupportsBytes",
+    "SupportsComplex",
+    "SupportsFloat",
+    "SupportsIndex",
+    "SupportsInt",
+    "SupportsRound",
+    "Reader",
+    "Writer",
+    # One-off things.
+    "Annotated",
+    "assert_never",
+    "assert_type",
+    "clear_overloads",
+    "dataclass_transform",
+    "deprecated",
+    "Doc",
+    "evaluate_forward_ref",
+    "get_overloads",
+    "final",
+    "Format",
+    "get_annotations",
+    "get_args",
+    "get_origin",
+    "get_original_bases",
+    "get_protocol_members",
+    "get_type_hints",
+    "IntVar",
+    "is_protocol",
+    "is_typeddict",
+    "Literal",
+    "NewType",
+    "overload",
+    "override",
+    "Protocol",
+    "Sentinel",
+    "reveal_type",
+    "runtime",
+    "runtime_checkable",
+    "Text",
+    "TypeAlias",
+    "TypeAliasType",
+    "TypeForm",
+    "TypeGuard",
+    "TypeIs",
+    "TYPE_CHECKING",
+    "Never",
+    "NoReturn",
+    "ReadOnly",
+    "Required",
+    "NotRequired",
+    "NoDefault",
+    "NoExtraItems",
+    # Pure aliases, have always been in typing
+    "AbstractSet",
+    "AnyStr",
+    "BinaryIO",
+    "Callable",
+    "Collection",
+    "Container",
+    "Dict",
+    "ForwardRef",
+    "FrozenSet",
+    "Generator",
+    "Generic",
+    "Hashable",
+    "IO",
+    "ItemsView",
+    "Iterable",
+    "Iterator",
+    "KeysView",
+    "List",
+    "Mapping",
+    "MappingView",
+    "Match",
+    "MutableMapping",
+    "MutableSequence",
+    "MutableSet",
+    "Optional",
+    "Pattern",
+    "Reversible",
+    "Sequence",
+    "Set",
+    "Sized",
+    "TextIO",
+    "Tuple",
+    "Union",
+    "ValuesView",
+    "cast",
+    "no_type_check",
+    "no_type_check_decorator",
     "TypingError",
     "get_type_description",
     "inspection",
@@ -79,7 +202,7 @@ class TypingError(Exception):
 # ------------------------------------------------------------------------
 
 
-def is_pydantic_basemodel(t: Any) -> bool:
+def is_pydantic_basemodel(t: "Any") -> bool:
     """Check if an object is a Pydantic BaseModel class or instance using duck typing.
 
     This function uses duck typing to identify Pydantic BaseModel objects by checking
@@ -120,7 +243,7 @@ def is_pydantic_basemodel(t: Any) -> bool:
     )
 
 
-def is_pydantic_basemodel_instance(t: Any) -> bool:
+def is_pydantic_basemodel_instance(t: "Any") -> bool:
     """Check if an object is an instance (not class) of a Pydantic BaseModel using duck typing.
 
     This function specifically identifies Pydantic BaseModel instances by ensuring
@@ -151,7 +274,7 @@ def is_pydantic_basemodel_instance(t: Any) -> bool:
     )
 
 
-def is_msgspec_struct(t: Any) -> bool:
+def is_msgspec_struct(t: "Any") -> bool:
     """Check if an object is a msgspec Struct class or instance using duck typing.
 
     This function uses duck typing to identify msgspec Struct objects by checking
@@ -179,7 +302,7 @@ def is_msgspec_struct(t: Any) -> bool:
     return hasattr(t, "__struct_fields__") and hasattr(t, "__struct_config__")
 
 
-def get_type_description(t: Any) -> str:
+def get_type_description(t: "Any") -> str:
     """Creates a human-readable description of a type hint.
 
     Args:
@@ -282,72 +405,3 @@ 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

@@ -1,7 +1,7 @@
 """hammad.web"""
 
 from typing import TYPE_CHECKING
-from ..based.utils import auto_create_lazy_loader
+from .._core._utils._import_utils import _auto_create_getattr_loader
 
 if TYPE_CHECKING:
     from .utils import (
@@ -34,7 +34,8 @@ __all__ = (
     "create_search_client",
 )
 
-__getattr__ = auto_create_lazy_loader(__all__)
+
+__getattr__ = _auto_create_getattr_loader(__all__)
 
 
 def __dir__() -> list[str]: