structx 0.4.8__py3-none-any.whl

structx/utils/usage.py

@@ -0,0 +1,327 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class ExtractionStep(Enum):
+    """
+    Enumeration of extraction process steps.
+
+    Represents the different steps in the extraction pipeline where token usage is tracked.
+    """
+
+    REFINEMENT = "refinement"
+    SCHEMA_GENERATION = "schema_generation"
+    EXTRACTION = "extraction"
+    GUIDE = "guide"
+
+
+class TokenDetails(BaseModel):
+    """
+    Details about token usage with advanced metrics.
+
+    Stores specialized token metrics such as reasoning (thinking) tokens,
+    audio tokens, and cached tokens when available from the LLM provider.
+    """
+
+    audio_tokens: int = 0
+    reasoning_tokens: int = 0
+    cached_tokens: int = 0
+
+
+class StepUsage(BaseModel):
+    """
+    Token usage information for a single step in the extraction process.
+
+    Contains detailed token usage statistics for one step, including both prompt and
+    completion tokens, along with any provider-specific token details.
+    """
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    step: ExtractionStep
+    completion_tokens_details: Optional[TokenDetails] = None
+    prompt_tokens_details: Optional[TokenDetails] = None
+
+    @classmethod
+    def from_completion(
+        cls, completion: Any, step: ExtractionStep
+    ) -> Optional["StepUsage"]:
+        """
+        Create StepUsage from completion object.
+
+        Args:
+            completion: LLM completion response object
+            step: Which extraction step this usage belongs to
+
+        Returns:
+            StepUsage object or None if no usage data is available
+        """
+        if not completion or not hasattr(completion, "usage"):
+            return None
+
+        usage = completion.usage
+        usage_data = {
+            "prompt_tokens": getattr(usage, "prompt_tokens", 0),
+            "completion_tokens": getattr(usage, "completion_tokens", 0),
+            "total_tokens": getattr(usage, "total_tokens", 0),
+            "step": step,
+        }
+
+        # Add token details if available
+        if hasattr(usage, "completion_tokens_details"):
+            details = usage.completion_tokens_details
+            usage_data["completion_tokens_details"] = TokenDetails(
+                audio_tokens=getattr(details, "audio_tokens", 0),
+                reasoning_tokens=getattr(details, "reasoning_tokens", 0),
+            )
+
+        if hasattr(usage, "prompt_tokens_details"):
+            details = usage.prompt_tokens_details
+            usage_data["prompt_tokens_details"] = TokenDetails(
+                audio_tokens=getattr(details, "audio_tokens", 0),
+                cached_tokens=getattr(details, "cached_tokens", 0),
+            )
+
+        return cls(**usage_data)
+
+
+class StepSummary(BaseModel):
+    """
+    Token usage summary for a single step.
+
+    Provides a simple summary of token consumption for a specific step
+    of the extraction process.
+
+    Attributes:
+        tokens: Number of tokens used in this step
+        name: Name of the step (analysis, refinement, etc.)
+    """
+
+    tokens: int
+    name: str
+
+
+class ExtractionSummary(BaseModel):
+    """
+    Token usage summary for extraction steps.
+
+    Extends StepSummary with additional details about individual extraction steps.
+
+    Attributes:
+        tokens: Number of tokens used across all extraction steps
+        name: Always "extraction"
+        steps: Detailed breakdown of individual extraction calls
+    """
+
+    tokens: int
+    name: str = "extraction"
+    steps: List[StepSummary] = []
+
+
+class UsageSummary(BaseModel):
+    """
+    Overall token usage summary across all extraction steps.
+
+    Provides a complete view of token usage throughout the extraction process,
+    including totals and per-step breakdowns.
+
+    Attributes:
+        total_tokens: Total tokens used across all steps
+        prompt_tokens: Total tokens used in prompts
+        completion_tokens: Total tokens generated in completions
+        thinking_tokens: Total thinking/reasoning tokens (if available)
+        cached_tokens: Total cached tokens (if available)
+        steps: List of per-step usage summaries
+    """
+
+    total_tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+    thinking_tokens: Optional[int] = None
+    cached_tokens: Optional[int] = None
+    steps: List[Union[StepSummary, ExtractionSummary]]
+
+    def get_step(
+        self, step_name: str
+    ) -> Optional[Union[StepSummary, ExtractionSummary]]:
+        """
+        Get a step summary by its name.
+
+        Args:
+            step_name: Name of the step to retrieve
+
+        Returns:
+            Step summary or None if not found
+        """
+        for step in self.steps:
+            if step.name == step_name:
+                return step
+        return None
+
+
+class ExtractorUsage(BaseModel):
+    """
+    Aggregated token usage tracking across all extraction steps.
+
+    Stores and manages token usage data for the entire extraction process,
+    providing methods to calculate totals and generate summaries.
+    """
+
+    steps: Dict[ExtractionStep, Union[StepUsage, List[StepUsage]]] = Field(
+        default_factory=dict
+    )
+
+    def add_step_usage(self, usage: Optional[StepUsage]):
+        """Add usage information for a step"""
+        if not usage:
+            return
+
+        if usage.step == ExtractionStep.EXTRACTION:
+            # For extraction steps, collect as a list
+            if ExtractionStep.EXTRACTION not in self.steps:
+                self.steps[ExtractionStep.EXTRACTION] = []
+            extraction_list = self.steps[ExtractionStep.EXTRACTION]
+            if isinstance(extraction_list, list):
+                extraction_list.append(usage)
+        else:
+            # For other steps, store a single usage
+            self.steps[usage.step] = usage
+
+    def _get_attribute_value(self, obj: Any, attr_path: str) -> Optional[int]:
+        """Extract a nested attribute value from an object using a dot-notation path"""
+        value = obj
+        for attr in attr_path.split("."):
+            if not hasattr(value, attr) or getattr(value, attr) is None:
+                return None
+            value = getattr(value, attr)
+        return value if isinstance(value, int) else None
+
+    def _get_token_sum(self, attr_path: str) -> int:
+        """Get sum of tokens across steps for a specific attribute path"""
+        total = 0
+
+        # Process all steps
+        for step_type in ExtractionStep:
+            if step_type not in self.steps:
+                continue
+
+            step_data = self.steps[step_type]
+
+            # Single step case
+            if isinstance(step_data, StepUsage):
+                value = self._get_attribute_value(step_data, attr_path)
+                if value is not None:
+                    total += value
+
+            # Multiple extraction steps case
+            elif isinstance(step_data, list):
+                for item in step_data:
+                    value = self._get_attribute_value(item, attr_path)
+                    if value is not None:
+                        total += value
+
+        return total
+
+    # Simple property accessors using _get_token_sum
+    @property
+    def total_tokens(self) -> int:
+        """Total tokens across all steps"""
+        return self._get_token_sum("total_tokens")
+
+    @property
+    def prompt_tokens(self) -> int:
+        """Total prompt tokens"""
+        return self._get_token_sum("prompt_tokens")
+
+    @property
+    def completion_tokens(self) -> int:
+        """Total completion tokens"""
+        return self._get_token_sum("completion_tokens")
+
+    @property
+    def thinking_tokens(self) -> int:
+        """Total thinking tokens"""
+        return self._get_token_sum("completion_tokens_details.reasoning_tokens")
+
+    @property
+    def cached_tokens(self) -> int:
+        """Total cached tokens"""
+        return self._get_token_sum("prompt_tokens_details.cached_tokens")
+
+    def get_usage_summary(self, detailed: bool = False) -> UsageSummary:
+        """Get structured token usage summary.
+
+        Args:
+            detailed: Whether to include detailed breakdown of extraction steps
+
+        Returns:
+            UsageSummary object with token usage information
+        """
+        # Create step summaries for standard steps
+        step_summaries = []
+        for step_type in [
+            ExtractionStep.REFINEMENT,
+            ExtractionStep.SCHEMA_GENERATION,
+            ExtractionStep.GUIDE,
+        ]:
+            if step_type in self.steps and isinstance(self.steps[step_type], StepUsage):
+                step_summaries.append(
+                    StepSummary(
+                        tokens=self.steps[step_type].total_tokens, name=step_type.value
+                    )
+                )
+            else:
+                step_summaries.append(StepSummary(tokens=0, name=step_type.value))
+
+        # Create extraction summary
+        extraction_summary = None
+        if ExtractionStep.EXTRACTION in self.steps:
+            extraction_steps = self.steps[ExtractionStep.EXTRACTION]
+            if isinstance(extraction_steps, list):
+                # Total tokens
+                total_extraction_tokens = sum(
+                    step.total_tokens for step in extraction_steps
+                )
+
+                # Individual step details if requested
+                extraction_steps_summary = []
+                if detailed:
+                    extraction_steps_summary = [
+                        StepSummary(tokens=step.total_tokens, name=f"extraction_{i}")
+                        for i, step in enumerate(extraction_steps)
+                    ]
+
+                extraction_summary = ExtractionSummary(
+                    tokens=total_extraction_tokens,
+                    name=ExtractionStep.EXTRACTION.value,
+                    steps=extraction_steps_summary,
+                )
+
+        if not extraction_summary:
+            extraction_summary = ExtractionSummary(
+                tokens=0, name=ExtractionStep.EXTRACTION.value
+            )
+
+        step_summaries.append(extraction_summary)
+
+        # Create the complete summary
+        summary = UsageSummary(
+            total_tokens=self.total_tokens,
+            prompt_tokens=self.prompt_tokens,
+            completion_tokens=self.completion_tokens,
+            steps=step_summaries,
+        )
+
+        # Add optional fields if they have values
+        thinking_tokens = self.thinking_tokens
+        if thinking_tokens > 0:
+            summary.thinking_tokens = thinking_tokens
+
+        cached_tokens = self.cached_tokens
+        if cached_tokens > 0:
+            summary.cached_tokens = cached_tokens
+
+        return summary

structx-0.4.8.dist-info/METADATA

@@ -0,0 +1,313 @@
+Metadata-Version: 2.4
+Name: structx
+Version: 0.4.8
+Summary: Structured data extraction from text using LLMs and dynamic model generation
+Author-email: blacksuan19 <py@blacksuan19.dev>
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Documentation
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: instructor
+Requires-Dist: litellm
+Requires-Dist: loguru
+Requires-Dist: omegaconf
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas
+Requires-Dist: pydantic
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: tenacity
+Requires-Dist: tqdm
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Provides-Extra: pdf
+Requires-Dist: pypdf2; extra == "pdf"
+Requires-Dist: instructor[multimodal]; extra == "pdf"
+Requires-Dist: weasyprint; extra == "pdf"
+Requires-Dist: markdown; extra == "pdf"
+Provides-Extra: docx
+Requires-Dist: python-docx; extra == "docx"
+Requires-Dist: docling; extra == "docx"
+Requires-Dist: markdown; extra == "docx"
+Requires-Dist: weasyprint; extra == "docx"
+Provides-Extra: docs
+Requires-Dist: pypdf2; extra == "docs"
+Requires-Dist: python-docx; extra == "docs"
+Requires-Dist: instructor[multimodal]; extra == "docs"
+Requires-Dist: docling; extra == "docs"
+Requires-Dist: weasyprint; extra == "docs"
+Requires-Dist: markdown; extra == "docs"
+Provides-Extra: unstructured
+Requires-Dist: unstructured[all-docs]; extra == "unstructured"
+Provides-Extra: docling
+Requires-Dist: docling; extra == "docling"
+Requires-Dist: markdown; extra == "docling"
+Requires-Dist: weasyprint; extra == "docling"
+Provides-Extra: advanced
+Requires-Dist: pypdf2; extra == "advanced"
+Requires-Dist: python-docx; extra == "advanced"
+Requires-Dist: instructor[multimodal]; extra == "advanced"
+Requires-Dist: docling; extra == "advanced"
+Requires-Dist: weasyprint; extra == "advanced"
+Requires-Dist: markdown; extra == "advanced"
+Requires-Dist: unstructured[all-docs]; extra == "advanced"
+Provides-Extra: mkdocs
+Requires-Dist: mkdocs; extra == "mkdocs"
+Requires-Dist: mkdocs-material; extra == "mkdocs"
+Requires-Dist: mkdocstrings[markdown]; extra == "mkdocs"
+Requires-Dist: mkdocstrings[python]; extra == "mkdocs"
+Requires-Dist: mkdocs-git-revision-date-localized-plugin; extra == "mkdocs"
+Requires-Dist: mkdocs-material[imaging]; extra == "mkdocs"
+Requires-Dist: mkdocs-mermaid2-plugin; extra == "mkdocs"
+Dynamic: license-file
+
+# structx
+
+Advanced structured data extraction from any document using LLMs with multimodal
+support.
+
+[![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg?style=for-the-badge)](https://structx.blacksuan19.dev "Documentation")
+[![PyPI](https://img.shields.io/badge/PyPi-0.4.8-blue?style=for-the-badge)](https://pypi.org/project/structx "Package")
+[![GitHub Actions](https://img.shields.io/badge/github%20actions-%232671E5.svg?style=for-the-badge&logo=githubactions&logoColor=white)](# "Build with GitHub Actions")
+
+`structx` is a powerful Python library for extracting structured data from any
+document or text using Large Language Models (LLMs). It features an innovative
+multimodal PDF processing pipeline that converts any document to PDF and uses
+instructor's vision capabilities for superior extraction quality.
+
+## 🔔 Package rename notice (PyPI)
+
+The PyPI distribution has been renamed from `structx-llm` to `structx`
+(September 2025).
+
+- Imports are unchanged: continue using `import structx`
+- Extras are unchanged: `structx[docs]`, `structx[pdf]`, `structx[docx]`
+- Please update your environments and requirement files to use the new name
+
+Upgrade commands:
+
+```bash
+pip uninstall -y structx-llm
+pip install -U structx
+```
+
+If you previously pinned `structx-llm` in requirements or lock files, replace it
+with `structx`.
+
+## ✨ Key Features
+
+### 🎯 **Advanced Document Processing**
+
+- **� Multimodal PDF Pipeline**: Converts any document (TXT, DOCX, etc.) to PDF
+  for optimal extraction
+- **🖼️ Vision-Enabled Extraction**: Native instructor multimodal support for
+  PDFs and images
+- **🔄 Smart Format Detection**: Automatic processing mode selection for best
+  results
+- **📊 Universal File Support**: CSV, Excel, JSON, Parquet, PDF, DOCX, TXT,
+  Markdown, and more
+
+### 🚀 **Intelligent Data Extraction**
+
+- **🔄 Dynamic Model Generation**: Create type-safe Pydantic models from natural
+  language queries
+- **🎯 Automatic Schema Inference**: Intelligent schema generation and
+  refinement
+- **📊 Complex Data Structures**: Support for nested and hierarchical data
+- **🔄 Natural Language Refinement**: Improve models with conversational
+  instructions
+
+### ⚡ **Performance & Reliability**
+
+- **🚀 High-Performance Processing**: Multi-threaded and async operations
+- **🔄 Robust Error Handling**: Automatic retry mechanism with exponential
+  backoff
+- **📈 Token Usage Tracking**: Detailed step-by-step metrics for cost monitoring
+- **� Flexible Configuration**: Configurable extraction using OmegaConf
+- **🔌 Multiple LLM Providers**: Support through litellm integration
+
+## Installation
+
+```bash
+# Core package with basic extraction capabilities
+pip install structx
+```
+
+### 📄 Enhanced Document Processing (Recommended)
+
+For the best experience with all document types including advanced multimodal
+PDF processing:
+
+```bash
+# Complete document processing support
+pip install structx[docs]
+
+# Individual components
+pip install structx[pdf]   # PDF processing with multimodal support
+pip install structx[docx]  # Advanced DOCX conversion via docling
+```
+
+### 🔧 What Each Extra Provides
+
+- **`[docs]`**: Complete multimodal document processing pipeline
+  - PDF conversion from any document type
+  - Instructor multimodal vision support
+  - Advanced DOCX processing via docling
+  - Enhanced extraction quality
+- **`[pdf]`**: PDF-specific processing
+
+  - Multimodal PDF support via instructor
+  - PDF generation capabilities
+  - Basic PDF text extraction fallback
+
+- **`[docx]`**: Advanced DOCX support
+  - Document conversion via docling
+  - Structure preservation
+  - Markdown-based processing pipeline
+
+## Quick Start
+
+### Basic Text Extraction
+
+```python
+from structx import Extractor
+
+# Initialize extractor
+extractor = Extractor.from_litellm(
+    model="gpt-4o",
+    api_key="your-api-key",
+    max_retries=3,      # Automatically retry on transient errors
+    min_wait=1,         # Start with 1 second wait
+    max_wait=10         # Maximum 10 seconds between retries
+)
+
+# Extract from text
+result = extractor.extract(
+    data="System check on 2024-01-15 detected high CPU usage (92%) on server-01.",
+    query="extract incident date and details"
+)
+
+# Access results
+print(f"Extracted {result.success_count} items")
+print(result.data[0].model_dump_json(indent=2))
+```
+
+### 📄 Document Processing with Multimodal Support
+
+```python
+# Process a PDF invoice directly with vision capabilities
+result = extractor.extract(
+    data="scripts/example_input/S0305SampleInvoice.pdf",      # Direct multimodal processing
+    query="extract the invoice number, total amount, and line items"
+)
+
+# Convert a DOCX contract and process with multimodal support
+result = extractor.extract(
+    data="scripts/example_input/free-consultancy-agreement.docx", # Auto-converted to PDF -> multimodal
+    query="extract parties, effective date, and payment terms"
+)
+```
+
+### 📊 Token Usage Monitoring
+
+```python
+# Check token usage for cost monitoring
+usage = result.get_token_usage()
+if usage:
+    print(f"Total tokens: {usage.total_tokens}")
+    print(f"By step: {[(s.name, s.tokens) for s in usage.steps]}")
+```
+
+## 🚀 Why Multimodal PDF Processing?
+
+The innovative multimodal approach provides significant advantages over
+traditional text-based extraction:
+
+- **📄 Context Preservation**: Full document layout and structure are maintained
+- **🎯 Higher Accuracy**: Vision models can interpret tables, charts, and
+  complex layouts
+- **🔄 No Chunking Issues**: Eliminates problems with information split across
+  chunks
+- **📊 Universal Format**: Any document type becomes processable through PDF
+  conversion
+- **🖼️ Visual Understanding**: Handles documents with visual elements,
+  formatting, and structure
+
+## 📚 Documentation
+
+For comprehensive documentation, examples, and guides, visit our
+[documentation site](https://structx.blacksuan19.dev).
+
+- [Getting Started](https://structx.blacksuan19.dev/getting-started)
+- [Basic Extraction](https://structx.blacksuan19.dev/guides/basic-extraction)
+- [Unstructured Text Processing](https://structx.blacksuan19.dev/guides/unstructured-text)
+- [Async Operations](https://structx.blacksuan19.dev/guides/async-operations)
+- [Multiple Queries](https://structx.blacksuan19.dev/guides/multiple-queries)
+- [Custom Models](https://structx.blacksuan19.dev/guides/custom-models)
+- [Token Usage Tracking](https://structx.blacksuan19.dev/guides/token-tracking)
+- [API Reference](https://structx.blacksuan19.dev/api/extractor)
+
+## Examples
+
+Check out our [example gallery](https://structx.blacksuan19.dev/examples) for
+real-world use cases,
+
+## 📁 Supported File Formats
+
+### 📊 Structured Data (Direct Processing)
+
+- **CSV**: Comma-separated values with custom delimiters
+- **Excel**: .xlsx/.xls with sheet selection and custom options
+- **JSON**: JavaScript Object Notation with nested support
+- **Parquet**: Columnar storage format for large datasets
+- **Feather**: Fast binary format for data frames
+
+### 📄 Unstructured Documents (Multimodal Pipeline)
+
+| Format   | Extensions                                    | Processing Method                     | Quality    |
+| -------- | --------------------------------------------- | ------------------------------------- | ---------- |
+| **PDF**  | `.pdf`                                        | Direct multimodal processing          | ⭐⭐⭐⭐⭐ |
+| **Word** | `.docx`, `.doc`                               | Docling → Markdown → PDF → Multimodal | ⭐⭐⭐⭐⭐ |
+| **Text** | `.txt`, `.md`, `.py`, `.log`, `.xml`, `.html` | Styled PDF → Multimodal               | ⭐⭐⭐⭐   |
+
+### 🔄 Processing Modes
+
+- **Multimodal PDF** (default): Best quality, preserves layout and context
+- **Simple Text**: Fallback mode with chunking for memory-constrained
+  environments
+- **Simple PDF**: Basic PDF text extraction without vision capabilities
+
+## Contributing
+
+Contributions are welcome! Please read our
+[Contributing Guidelines](https://structx.blacksuan19.dev/contributing) for
+details.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
+for details.

structx-0.4.8.dist-info/RECORD

@@ -0,0 +1,29 @@
+structx/__init__.py,sha256=J1IujfdUMitYEYVU7BnZzZ2sBMo_4aqyeZH4hhzWE1g,491
+structx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+structx/core/config.py,sha256=RjrEPc-c195PwUpJYd0Dvsv__DG3UvsGrPsBVhnVoqo,4252
+structx/core/exceptions.py,sha256=hl9CFe5lFzGryILdmOv1xaoj8Bwbqzgw-5U6e8-mWXM,525
+structx/core/models.py,sha256=ynNnWtVbwHe4KiftQ-e0s75DsuOUl9B2Z2yOc0_Xoj0,4607
+structx/extraction/__init__.py,sha256=Z6bmSAlMYAf_HeaeqrPKzg5rC20UqKiD7ZcdaFb6iJI,1001
+structx/extraction/extractor.py,sha256=v29f-BUwdoEUWksi3fB0uQkkd1d_nIqilKXhVihOyok,18998
+structx/extraction/generator.py,sha256=9n6o8FZRtgTiUEG0d-2jL4-K_VEBimOhClyCX8iMdVQ,8550
+structx/extraction/result_manager.py,sha256=k_lLM50-pNjHlwBzpBSnsRbrfE302Q45fAoKXEplUZU,3682
+structx/extraction/core/__init__.py,sha256=VAUGPbtVCcyBvCuqym7ageNpjvhkT3ZPEAbXBbLD_h4,153
+structx/extraction/core/llm_core.py,sha256=pGtCtuoXLZ-lPTIYNItAAwgmLRJr2fI7udLMjXoC92E,6434
+structx/extraction/core/model_utils.py,sha256=anvE1q6w9jhdznOLhr1LJFHBGyl1anysrDFDNLqCHkA,4611
+structx/extraction/engines/__init__.py,sha256=xNnMFX7kS_DGUFXJFKffzou9VzMjS8npd0PCoWxm6Dw,143
+structx/extraction/engines/extraction_engine.py,sha256=uR7UX6GkyOyoHLQwP9SkLfTZ6kD9K9SuSC8qYuJrboQ,8009
+structx/extraction/processors/__init__.py,sha256=x4AFg5ixktVUNget5CNyY9Y9rHOsNUdauNRpeuFqHvo,229
+structx/extraction/processors/data_content.py,sha256=OQNrVyegwCFedRzuhzO75H1BEIc6ebHg0joDWQ8580k,13560
+structx/extraction/processors/model_operations.py,sha256=ty_JdzAVDogoSHObVjXS-s078eEnWmMBX__gLihTUpI,8457
+structx/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+structx/utils/constants.py,sha256=3KMeumm-6q7zNcWyxixHCDmERpmSNIVS01uUo4N4o0I,872
+structx/utils/file_reader.py,sha256=TYQ_G1d2vIaw9BZnVNUne4S3n8UMG48pUOwHqvxVj5A,11612
+structx/utils/helpers.py,sha256=papsgnRYXNDnvo_d7nUaRHJXTLbcHoYXOw36vj4eczg,8078
+structx/utils/prompts.py,sha256=GGfWNUBq8qOBoOz6-h_BINEPAKn5Q5VVkn2LPbMZJ2o,6619
+structx/utils/types.py,sha256=dojNDaX2t3YTYkcG13UU8c9Bs498plH75ypTrMYJGoQ,269
+structx/utils/usage.py,sha256=eA2L_L3eizCBtO2L7D3hLMZdUpsryNxZowXpGl07hKg,10663
+structx-0.4.8.dist-info/licenses/LICENSE,sha256=H6mof4YPl56UolCTeVfkg-HxKUxTXU6nrmhCg0SxUng,1070
+structx-0.4.8.dist-info/METADATA,sha256=WlpZq1aGdy79aXtodoyX19zuVUaDTIcCy9NGg7qPWPA,11688
+structx-0.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+structx-0.4.8.dist-info/top_level.txt,sha256=H2eTQyV33YUusz-yJiJs5YouRw3vPdGRC7WnwLMZw9k,8
+structx-0.4.8.dist-info/RECORD,,

structx-0.4.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

structx-0.4.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abubakar Omer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.