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

hammad/data/types/__init__.py

@@ -1,33 +0,0 @@
-"""hammad.data.types
-
-Contains various explicit data models and definitions for
-various file types, data formats, and other data related
-concepts."""
-
-from typing import TYPE_CHECKING
-from ...based.utils import auto_create_lazy_loader
-
-if TYPE_CHECKING:
-    from .files.audio import Audio
-    from .files.configuration import Configuration
-    from .files.document import Document
-    from .files.file import File, FileSource
-    from .files.image import Image
-
-
-__all__ = (
-    "Audio",
-    "Configuration",
-    "Document",
-    "File",
-    "FileSource",
-    "Image",
-)
-
-
-__getattr__ = auto_create_lazy_loader(__all__)
-
-
-def __dir__() -> list[str]:
-    """Get the attributes of the data.types module."""
-    return list(__all__)

hammad/data/types/files/__init__.py

@@ -1 +0,0 @@
-"""hammad.data.types.files"""

hammad/data/types/files/document.py

@@ -1,195 +0,0 @@
-"""hammad.data.types.files.document"""
-
-import httpx
-from typing import Any, Self, Iterator
-from markdown_it import MarkdownIt
-
-from .file import File, FileSource
-from ....based.fields import basedfield
-
-__all__ = ("Document",)
-
-
-class Document(File):
-    """A representation of a document, that is loadable from both a URL, file path
-    or bytes. This document can additionally be used to represent web pages, as well
-    as implement markdown formatting for both documents and web pages."""
-
-    # Cached properties for text processing
-    _lines: list[str] | None = basedfield(default=None)
-    _content: str | None = basedfield(default=None)
-    _md_parser: MarkdownIt | None = basedfield(default=None)
-    metadata: dict[str, Any] = basedfield(default_factory=dict)
-
-    @property
-    def content(self) -> str:
-        """Get the document content as string."""
-        if self._content is None:
-            data = self.read()
-            self._content = (
-                data
-                if isinstance(data, str)
-                else data.decode(self.source.encoding or "utf-8")
-            )
-        return self._content
-
-    @property
-    def lines(self) -> list[str]:
-        """Get lines of the document (cached for efficiency)."""
-        if self._lines is None:
-            self._lines = self.content.splitlines(keepends=False)
-        return self._lines
-
-    @property
-    def line_count(self) -> int:
-        """Get the number of lines in the document."""
-        return len(self.lines)
-
-    @property
-    def word_count(self) -> int:
-        """Get the word count of the document."""
-        return len(self.content.split())
-
-    @property
-    def char_count(self) -> int:
-        """Get the character count of the document."""
-        return len(self.content)
-
-    @property
-    def is_markdown(self) -> bool:
-        """Check if the document is a markdown file."""
-        return self.extension in {".md", ".markdown", ".mdown", ".mkd", ".mdx"}
-
-    @property
-    def md_parser(self) -> MarkdownIt:
-        """Get the markdown parser (lazy initialization)."""
-        if self._md_parser is None:
-            self._md_parser = MarkdownIt()
-        return self._md_parser
-
-    def iter_lines(self, *, strip: bool = False) -> Iterator[str]:
-        """Iterate over lines in the document.
-
-        Args:
-            strip: If True, strip whitespace from each line.
-
-        Yields:
-            Lines from the document.
-        """
-        for line in self.lines:
-            yield line.strip() if strip else line
-
-    def iter_paragraphs(self) -> Iterator[str]:
-        """Iterate over paragraphs (text blocks separated by empty lines)."""
-        paragraph = []
-        for line in self.lines:
-            if line.strip():
-                paragraph.append(line)
-            elif paragraph:
-                yield "\n".join(paragraph)
-                paragraph = []
-        if paragraph:
-            yield "\n".join(paragraph)
-
-    def search(
-        self, pattern: str, *, case_sensitive: bool = False
-    ) -> list[tuple[int, str]]:
-        """Search for a pattern in the document.
-
-        Args:
-            pattern: The pattern to search for.
-            case_sensitive: If True, search is case-sensitive.
-
-        Returns:
-            List of tuples (line_number, line_content) for matching lines.
-        """
-        results = []
-        search_pattern = pattern if case_sensitive else pattern.lower()
-
-        for i, line in enumerate(self.lines):
-            search_line = line if case_sensitive else line.lower()
-            if search_pattern in search_line:
-                results.append((i + 1, line))  # 1-indexed line numbers
-
-        return results
-
-    def render_markdown(self) -> str:
-        """Render markdown content to HTML."""
-        if not self.is_markdown:
-            return self.content
-        return self.md_parser.render(self.content)
-
-    def extract_headers(self) -> list[tuple[int, str]]:
-        """Extract headers from markdown documents.
-
-        Returns:
-            List of tuples (level, text) for each header.
-        """
-        headers = []
-        if self.is_markdown:
-            tokens = self.md_parser.parse(self.content)
-            i = 0
-            while i < len(tokens):
-                if tokens[i].type == "heading_open":
-                    level = int(tokens[i].tag[1])  # h1 -> 1, h2 -> 2, etc.
-                    # Next token should be inline with the content
-                    if i + 1 < len(tokens) and tokens[i + 1].type == "inline":
-                        headers.append((level, tokens[i + 1].content))
-                i += 1
-        else:
-            # For non-markdown files, look for common header patterns
-            for line in self.lines:
-                stripped = line.strip()
-                if stripped.startswith("#"):
-                    level = len(line) - len(line.lstrip("#"))
-                    text = line.lstrip("#").strip()
-                    headers.append((level, text))
-        return headers
-
-    @classmethod
-    def from_url(
-        cls,
-        url: str,
-        *,
-        lazy: bool = True,
-        timeout: float = 30.0,
-    ) -> Self:
-        """Download and create a document from a URL.
-
-        Args:
-            url: The URL to download from.
-            lazy: If True, defer loading content until needed.
-            timeout: Request timeout in seconds.
-
-        Returns:
-            A new Document instance.
-        """
-        data = None
-        size = None
-        encoding = None
-        type = None
-
-        if not lazy:
-            with httpx.Client(timeout=timeout) as client:
-                response = client.get(url)
-                response.raise_for_status()
-
-                # Always get text for documents
-                data = response.text
-                size = len(data.encode("utf-8"))
-                encoding = response.encoding
-
-                # Get content type
-                content_type = response.headers.get("content-type", "")
-                type = content_type.split(";")[0] if content_type else "text/plain"
-
-        return cls(
-            data=data,
-            type=type,
-            source=FileSource(
-                is_url=True,
-                url=url,
-                size=size,
-                encoding=encoding,
-            ),
-        )

hammad/text/utils/__init__.py

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

hammad/text/utils/converters.py

@@ -1,229 +0,0 @@
-"""hammad.text.utils.converters"""
-
-from docstring_parser import parse
-from typing import (
-    Any,
-    Optional,
-)
-
-from ...typing import (
-    inspection,
-    is_pydantic_basemodel,
-    is_msgspec_struct,
-    is_dataclass,
-)
-
-__all__ = [
-    "convert_type_to_text",
-    "convert_docstring_to_text",
-]
-
-
-def convert_type_to_text(cls: Any) -> str:
-    """Converts a type into a clean & human readable text representation.
-
-    This function uses `typing_inspect` exclusively to infer nested types
-    within `Optional`, `Union` types, for the cleanest possible string
-    representation of a type.
-
-    Args:
-        cls: The type to convert to a text representation.
-
-    Returns:
-        A clean, human-readable string representation of the type.
-    """
-    # Handle None type
-    if cls is None or cls is type(None):
-        return "None"
-
-    # Get origin and args using typing_inspect for better type handling
-    origin = inspection.get_origin(cls)
-    args = inspection.get_args(cls)
-
-    if origin is not None:
-        # Handle Optional (Union[T, None])
-        if inspection.is_optional_type(cls):
-            # Recursively get the name of the inner type (the one not None)
-            inner_type = args[0]
-            inner_type_name = convert_type_to_text(inner_type)
-            return f"Optional[{inner_type_name}]"
-
-        # Handle other Union types
-        if inspection.is_union_type(cls):
-            # Recursively get names of all arguments in the Union
-            args_str = ", ".join(convert_type_to_text(arg) for arg in args)
-            return f"Union[{args_str}]"
-
-        # Handle other generic types (List, Dict, Tuple, Set, etc.)
-        # Use origin.__name__ for built-in generics like list, dict, tuple, set
-        origin_name = getattr(origin, "__name__", str(origin).split(".")[-1])
-        if origin_name.startswith("_"):  # Handle internal typing names like _List
-            origin_name = origin_name[1:]
-
-        # Convert to lowercase for built-in types to match modern Python style
-        if origin_name in ["List", "Dict", "Tuple", "Set"]:
-            origin_name = origin_name.lower()
-
-        if args:  # If there are type arguments
-            # Recursively get names of type arguments
-            args_str = ", ".join(convert_type_to_text(arg) for arg in args)
-            return f"{origin_name}[{args_str}]"
-        else:  # Generic without arguments (e.g., typing.List)
-            return origin_name
-
-    # Handle special cases with typing_inspect
-    if inspection.is_typevar(cls):
-        return str(cls)
-    if inspection.is_forward_ref(cls):
-        return str(cls)
-    if inspection.is_literal_type(cls):
-        return f"Literal[{', '.join(str(arg) for arg in args)}]"
-    if inspection.is_final_type(cls):
-        return f"Final[{convert_type_to_text(args[0])}]" if args else "Final"
-    if inspection.is_new_type(cls):
-        return str(cls)
-
-    # Handle Pydantic BaseModel types
-    if is_pydantic_basemodel(cls):
-        if hasattr(cls, "__name__"):
-            return cls.__name__
-        return "BaseModel"
-
-    # Handle msgspec Struct types
-    if is_msgspec_struct(cls):
-        if hasattr(cls, "__name__"):
-            return cls.__name__
-        return "Struct"
-
-    # Handle dataclass types
-    if is_dataclass(cls):
-        if hasattr(cls, "__name__"):
-            return cls.__name__
-        return "dataclass"
-
-    # Handle basic types with __name__ attribute
-    if hasattr(cls, "__name__") and cls.__name__ != "<lambda>":
-        return cls.__name__
-
-    # Special handling for Optional type string representation
-    if str(cls).startswith("typing.Optional"):
-        # Extract the inner type from the string representation
-        inner_type_str = str(cls).replace("typing.Optional[", "").rstrip("]")
-        return f"Optional[{inner_type_str}]"
-
-    # Fallback for any other types
-    # Clean up 'typing.' prefix and handle other common representations
-    return str(cls).replace("typing.", "").replace("__main__.", "")
-
-
-def convert_docstring_to_text(
-    obj: Any,
-    *,
-    params_override: Optional[str] = None,
-    returns_override: Optional[str] = None,
-    raises_override: Optional[str] = None,
-    examples_override: Optional[str] = None,
-    params_prefix: Optional[str] = None,
-    returns_prefix: Optional[str] = None,
-    raises_prefix: Optional[str] = None,
-    exclude_params: bool = False,
-    exclude_returns: bool = False,
-    exclude_raises: bool = False,
-    exclude_examples: bool = False,
-) -> str:
-    """
-    Convert an object's docstring to formatted text using docstring_parser.
-
-    Args:
-        obj: The object to extract docstring from
-        params_override: Override text for parameters section
-        returns_override: Override text for returns section
-        raises_override: Override text for raises section
-        examples_override: Override text for examples section
-        params_prefix: Prefix for parameters section
-        returns_prefix: Prefix for returns section
-        raises_prefix: Prefix for raises section
-        exclude_params: Whether to exclude parameters section
-        exclude_returns: Whether to exclude returns section
-        exclude_raises: Whether to exclude raises section
-        exclude_examples: Whether to exclude examples section
-
-    Returns:
-        Formatted text representation of the docstring
-    """
-    # Get the raw docstring
-    doc = getattr(obj, "__doc__", None)
-    if not doc:
-        return ""
-
-    try:
-        # Parse the docstring using docstring_parser
-        parsed = parse(doc)
-
-        parts = []
-
-        # Add short description
-        if parsed.short_description:
-            parts.append(parsed.short_description)
-
-        # Add long description
-        if parsed.long_description:
-            parts.append("")  # Empty line separator
-            parts.append(parsed.long_description)
-
-        # Add parameters section
-        if not exclude_params and (params_override or parsed.params):
-            parts.append("")  # Empty line separator
-            if params_override:
-                parts.append(params_override)
-            else:
-                prefix = params_prefix or "Parameters:"
-                parts.append(prefix)
-                for param in parsed.params:
-                    param_line = f"  {param.arg_name}"
-                    if param.type_name:
-                        param_line += f" ({param.type_name})"
-                    if param.description:
-                        param_line += f": {param.description}"
-                    parts.append(param_line)
-
-        # Add returns section
-        if not exclude_returns and (returns_override or parsed.returns):
-            parts.append("")  # Empty line separator
-            if returns_override:
-                parts.append(returns_override)
-            else:
-                prefix = returns_prefix or "Returns:"
-                parts.append(prefix)
-                if parsed.returns:
-                    return_line = "  "
-                    if parsed.returns.type_name:
-                        return_line += f"{parsed.returns.type_name}: "
-                    if parsed.returns.description:
-                        return_line += parsed.returns.description
-                    parts.append(return_line)
-
-        # Add raises section
-        if not exclude_raises and (raises_override or parsed.raises):
-            parts.append("")  # Empty line separator
-            if raises_override:
-                parts.append(raises_override)
-            else:
-                prefix = raises_prefix or "Raises:"
-                parts.append(prefix)
-                for exc in parsed.raises:
-                    exc_line = f"  {exc.type_name or 'Exception'}"
-                    if exc.description:
-                        exc_line += f": {exc.description}"
-                    parts.append(exc_line)
-
-        # Add examples section (if available in parsed docstring)
-        if not exclude_examples and examples_override:
-            parts.append("")  # Empty line separator
-            parts.append(examples_override)
-
-        return "\n".join(parts)
-
-    except Exception:
-        # Fallback to raw docstring if parsing fails
-        return doc.strip()

hammad/text/utils/markdown/__init__.py

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