smartdocloader 1.0.0__py3-none-any.whl

smartdocloader/__init__.py

@@ -0,0 +1,48 @@
+"""
+smartdocloader - An advanced universal document loader library.
+Load content from multiple file formats with a single smart API.
+Supports: TXT, CSV, JSON, XML, YAML, INI, HTML, PDF, DOCX, PPTX, XLSX
+"""
+
+from .text_loader import load_txt, load_csv, load_json, load_xml, load_yaml, load_ini, load_html
+from .doc_loader import (
+    load_pdf, load_pdf_pages, load_pdf_metadata,
+    load_docx, load_docx_with_styles,
+    load_pptx,
+    load_xlsx, load_xlsx_sheets,
+)
+from .smart_loader import auto_load, batch_load, get_file_info, supported_formats
+from .utils import search_content, convert_to_text, word_count, export_to_json, compare_files
+
+__version__ = "1.0.0"
+
+__all__ = [
+    # text_loader
+    "load_txt",
+    "load_csv",
+    "load_json",
+    "load_xml",
+    "load_yaml",
+    "load_ini",
+    "load_html",
+    # doc_loader
+    "load_pdf",
+    "load_pdf_pages",
+    "load_pdf_metadata",
+    "load_docx",
+    "load_docx_with_styles",
+    "load_pptx",
+    "load_xlsx",
+    "load_xlsx_sheets",
+    # smart_loader
+    "auto_load",
+    "batch_load",
+    "get_file_info",
+    "supported_formats",
+    # utils
+    "search_content",
+    "convert_to_text",
+    "word_count",
+    "export_to_json",
+    "compare_files",
+]

smartdocloader/doc_loader.py

@@ -0,0 +1,192 @@
+"""
+doc_loader module - Load common document formats.
+Supports: .pdf, .docx, .pptx, .xlsx with advanced options
+"""
+
+import openpyxl
+from docx import Document as DocxDocument
+from pptx import Presentation
+from PyPDF2 import PdfReader
+
+
+def load_pdf(filepath, page_range=None):
+    """Load a .pdf file and return all text content as a string.
+
+    Args:
+        filepath: Path to the .pdf file
+        page_range: Optional tuple (start, end) for specific pages (0-indexed).
+                    If None, loads all pages.
+
+    Returns:
+        str: Extracted text from specified pages joined with newlines
+    """
+    reader = PdfReader(filepath)
+    pages = reader.pages
+
+    if page_range:
+        start, end = page_range
+        pages = pages[start:end]
+
+    texts = []
+    for page in pages:
+        text = page.extract_text()
+        if text:
+            texts.append(text)
+    return "\n".join(texts)
+
+
+def load_pdf_pages(filepath):
+    """Load a .pdf file and return text per page as a list.
+
+    Args:
+        filepath: Path to the .pdf file
+
+    Returns:
+        list[str]: List where each element is the text of one page
+    """
+    reader = PdfReader(filepath)
+    pages = []
+    for page in reader.pages:
+        text = page.extract_text()
+        pages.append(text if text else "")
+    return pages
+
+
+def load_pdf_metadata(filepath):
+    """Extract metadata from a PDF file.
+
+    Args:
+        filepath: Path to the .pdf file
+
+    Returns:
+        dict: Metadata including title, author, subject, page_count, etc.
+    """
+    reader = PdfReader(filepath)
+    meta = reader.metadata
+    info = {
+        "title": meta.title if meta else None,
+        "author": meta.author if meta else None,
+        "subject": meta.subject if meta else None,
+        "creator": meta.creator if meta else None,
+        "producer": meta.producer if meta else None,
+        "page_count": len(reader.pages),
+    }
+    return info
+
+
+def load_docx(filepath, include_tables=False):
+    """Load a .docx file and return all paragraph text as a list of strings.
+
+    Args:
+        filepath: Path to the .docx file
+        include_tables: If True, also extract text from tables
+
+    Returns:
+        list[str]: List of paragraph texts (empty paragraphs skipped).
+                   If include_tables=True, table rows are appended as dicts.
+    """
+    doc = DocxDocument(filepath)
+    result = [para.text for para in doc.paragraphs if para.text.strip()]
+
+    if include_tables:
+        for table in doc.tables:
+            headers = [cell.text.strip() for cell in table.rows[0].cells]
+            for row in table.rows[1:]:
+                row_data = {headers[i]: cell.text.strip() for i, cell in enumerate(row.cells)}
+                result.append(row_data)
+
+    return result
+
+
+def load_docx_with_styles(filepath):
+    """Load a .docx file and return paragraphs with their style info.
+
+    Args:
+        filepath: Path to the .docx file
+
+    Returns:
+        list[dict]: Each dict has 'text', 'style', and 'bold' keys
+    """
+    doc = DocxDocument(filepath)
+    result = []
+    for para in doc.paragraphs:
+        if para.text.strip():
+            result.append({
+                "text": para.text,
+                "style": para.style.name if para.style else None,
+                "bold": any(run.bold for run in para.runs),
+            })
+    return result
+
+
+def load_pptx(filepath, include_notes=False):
+    """Load a .pptx file and return slide text as a list of lists.
+
+    Args:
+        filepath: Path to the .pptx file
+        include_notes: If True, include speaker notes for each slide
+
+    Returns:
+        list[dict]: Each dict has 'slide_number', 'text' (list), and optionally 'notes'
+    """
+    prs = Presentation(filepath)
+    slides = []
+    for i, slide in enumerate(prs.slides, 1):
+        slide_text = []
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                for paragraph in shape.text_frame.paragraphs:
+                    text = paragraph.text.strip()
+                    if text:
+                        slide_text.append(text)
+
+        slide_data = {"slide_number": i, "text": slide_text}
+
+        if include_notes and slide.has_notes_slide:
+            notes_frame = slide.notes_slide.notes_text_frame
+            slide_data["notes"] = notes_frame.text.strip() if notes_frame else ""
+
+        slides.append(slide_data)
+    return slides
+
+
+def load_xlsx(filepath, sheet_name=None):
+    """Load a .xlsx file and return data as a list of dictionaries.
+
+    Args:
+        filepath: Path to the .xlsx file
+        sheet_name: Optional sheet name to load. If None, loads the active sheet.
+
+    Returns:
+        list[dict]: Rows as dictionaries with first row as headers
+    """
+    wb = openpyxl.load_workbook(filepath, read_only=True)
+
+    if sheet_name:
+        ws = wb[sheet_name]
+    else:
+        ws = wb.active
+
+    rows = list(ws.iter_rows(values_only=True))
+    wb.close()
+
+    if not rows:
+        return []
+
+    headers = [str(h) if h is not None else f"col_{i}" for i, h in enumerate(rows[0])]
+    return [dict(zip(headers, row)) for row in rows[1:]]
+
+
+def load_xlsx_sheets(filepath):
+    """Get all sheet names from an Excel file.
+
+    Args:
+        filepath: Path to the .xlsx file
+
+    Returns:
+        list[str]: List of sheet names
+    """
+    wb = openpyxl.load_workbook(filepath, read_only=True)
+    sheets = wb.sheetnames
+    wb.close()
+    return sheets

smartdocloader/smart_loader.py

@@ -0,0 +1,116 @@
+"""
+smart_loader module - Unified interface for loading any supported document.
+Auto-detects file type and dispatches to the appropriate loader.
+"""
+
+import os
+from . import text_loader, doc_loader
+
+
+# Map of file extensions to loader functions
+_LOADERS = {
+    ".txt": text_loader.load_txt,
+    ".csv": text_loader.load_csv,
+    ".json": text_loader.load_json,
+    ".xml": text_loader.load_xml,
+    ".yaml": text_loader.load_yaml,
+    ".yml": text_loader.load_yaml,
+    ".ini": text_loader.load_ini,
+    ".cfg": text_loader.load_ini,
+    ".html": text_loader.load_html,
+    ".htm": text_loader.load_html,
+    ".pdf": doc_loader.load_pdf,
+    ".docx": doc_loader.load_docx,
+    ".pptx": doc_loader.load_pptx,
+    ".xlsx": doc_loader.load_xlsx,
+}
+
+
+def auto_load(filepath):
+    """Automatically detect file type and load using the appropriate loader.
+
+    Args:
+        filepath: Path to any supported file
+
+    Returns:
+        Loaded content (type depends on file format)
+
+    Raises:
+        ValueError: If the file format is not supported
+        FileNotFoundError: If the file does not exist
+    """
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+
+    ext = os.path.splitext(filepath)[1].lower()
+
+    if ext not in _LOADERS:
+        raise ValueError(
+            f"Unsupported file format: '{ext}'. "
+            f"Supported formats: {', '.join(sorted(_LOADERS.keys()))}"
+        )
+
+    return _LOADERS[ext](filepath)
+
+
+def batch_load(filepaths):
+    """Load multiple files at once using auto-detection.
+
+    Args:
+        filepaths: List of file paths to load
+
+    Returns:
+        dict: Mapping of filepath -> loaded content.
+              If a file fails, its value will be a dict with 'error' key.
+    """
+    results = {}
+    for fp in filepaths:
+        try:
+            results[fp] = auto_load(fp)
+        except Exception as e:
+            results[fp] = {"error": str(e)}
+    return results
+
+
+def get_file_info(filepath):
+    """Get detailed file metadata.
+
+    Args:
+        filepath: Path to any file
+
+    Returns:
+        dict: File info including name, extension, size, modified time, and whether it's supported
+    """
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"File not found: {filepath}")
+
+    stat = os.stat(filepath)
+    ext = os.path.splitext(filepath)[1].lower()
+
+    return {
+        "name": os.path.basename(filepath),
+        "extension": ext,
+        "size_bytes": stat.st_size,
+        "size_readable": _format_size(stat.st_size),
+        "modified_timestamp": stat.st_mtime,
+        "is_supported": ext in _LOADERS,
+        "absolute_path": os.path.abspath(filepath),
+    }
+
+
+def supported_formats():
+    """Get a list of all supported file formats.
+
+    Returns:
+        list[str]: Sorted list of supported file extensions
+    """
+    return sorted(set(_LOADERS.keys()))
+
+
+def _format_size(size_bytes):
+    """Convert bytes to human-readable size string."""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} TB"

smartdocloader/text_loader.py

@@ -0,0 +1,160 @@
+"""
+text_loader module - Load text-based document formats.
+Supports: .txt, .csv, .json, .xml, .yaml/.yml, .ini, .html
+"""
+
+import csv
+import json
+import configparser
+import xml.etree.ElementTree as ET
+from html.parser import HTMLParser
+
+
+def load_txt(filepath, encoding="utf-8"):
+    """Load a .txt file and return its content as a string.
+
+    Args:
+        filepath: Path to the .txt file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        str: Full text content
+    """
+    with open(filepath, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def load_csv(filepath, delimiter=",", encoding="utf-8"):
+    """Load a .csv file and return its content as a list of dictionaries.
+
+    Args:
+        filepath: Path to the .csv file
+        delimiter: Column separator (default: comma)
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        list[dict]: List of row dictionaries with headers as keys
+    """
+    with open(filepath, "r", encoding=encoding, newline="") as f:
+        reader = csv.DictReader(f, delimiter=delimiter)
+        return list(reader)
+
+
+def load_json(filepath, encoding="utf-8"):
+    """Load a .json file and return parsed data.
+
+    Args:
+        filepath: Path to the .json file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        dict or list: Parsed JSON data
+    """
+    with open(filepath, "r", encoding=encoding) as f:
+        return json.load(f)
+
+
+def load_xml(filepath):
+    """Load a .xml file and return a nested dictionary representation.
+
+    Args:
+        filepath: Path to the .xml file
+
+    Returns:
+        dict: Nested dictionary with tag, attributes, text, and children
+    """
+    tree = ET.parse(filepath)
+    root = tree.getroot()
+
+    def element_to_dict(element):
+        result = {"tag": element.tag}
+        if element.attrib:
+            result["attributes"] = dict(element.attrib)
+        if element.text and element.text.strip():
+            result["text"] = element.text.strip()
+        children = [element_to_dict(child) for child in element]
+        if children:
+            result["children"] = children
+        return result
+
+    return element_to_dict(root)
+
+
+def load_yaml(filepath, encoding="utf-8"):
+    """Load a .yaml/.yml file and return parsed data.
+
+    Args:
+        filepath: Path to the .yaml or .yml file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        dict or list: Parsed YAML data
+
+    Raises:
+        ImportError: If PyYAML is not installed
+    """
+    try:
+        import yaml
+    except ImportError:
+        raise ImportError("PyYAML is required for YAML support. Install it with: pip install pyyaml")
+
+    with open(filepath, "r", encoding=encoding) as f:
+        return yaml.safe_load(f)
+
+
+def load_ini(filepath, encoding="utf-8"):
+    """Load a .ini/.cfg file and return as a nested dictionary.
+
+    Args:
+        filepath: Path to the .ini file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        dict: Nested dict where keys are sections and values are dicts of key-value pairs
+    """
+    config = configparser.ConfigParser()
+    config.read(filepath, encoding=encoding)
+    return {section: dict(config[section]) for section in config.sections()}
+
+
+def load_html(filepath, encoding="utf-8"):
+    """Load an .html file and extract visible text content (strips tags).
+
+    Args:
+        filepath: Path to the .html file
+        encoding: File encoding (default: utf-8)
+
+    Returns:
+        str: Extracted text content without HTML tags
+    """
+
+    class _HTMLTextExtractor(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self._texts = []
+            self._skip_tags = {"script", "style"}
+            self._skip = False
+
+        def handle_starttag(self, tag, attrs):
+            if tag.lower() in self._skip_tags:
+                self._skip = True
+
+        def handle_endtag(self, tag):
+            if tag.lower() in self._skip_tags:
+                self._skip = False
+
+        def handle_data(self, data):
+            if not self._skip:
+                text = data.strip()
+                if text:
+                    self._texts.append(text)
+
+        def get_text(self):
+            return "\n".join(self._texts)
+
+    with open(filepath, "r", encoding=encoding) as f:
+        content = f.read()
+
+    extractor = _HTMLTextExtractor()
+    extractor.feed(content)
+    return extractor.get_text()

smartdocloader/utils.py

@@ -0,0 +1,166 @@
+"""
+utils module - Utility functions for content processing and search.
+"""
+
+import os
+import json
+
+
+def search_content(data, keyword, case_sensitive=False):
+    """Search for a keyword within loaded content.
+
+    Works with strings, lists, and dictionaries returned by loader functions.
+
+    Args:
+        data: Loaded content (str, list, or dict)
+        keyword: Text to search for
+        case_sensitive: Whether search is case-sensitive (default: False)
+
+    Returns:
+        list: Matching items/lines containing the keyword
+    """
+    if not case_sensitive:
+        keyword = keyword.lower()
+
+    matches = []
+
+    if isinstance(data, str):
+        for line in data.splitlines():
+            target = line if case_sensitive else line.lower()
+            if keyword in target:
+                matches.append(line)
+
+    elif isinstance(data, list):
+        for item in data:
+            if isinstance(item, str):
+                target = item if case_sensitive else item.lower()
+                if keyword in target:
+                    matches.append(item)
+            elif isinstance(item, dict):
+                for value in item.values():
+                    target = str(value) if case_sensitive else str(value).lower()
+                    if keyword in target:
+                        matches.append(item)
+                        break
+
+    elif isinstance(data, dict):
+        for key, value in data.items():
+            target = str(value) if case_sensitive else str(value).lower()
+            if keyword in target:
+                matches.append({key: value})
+
+    return matches
+
+
+def convert_to_text(data):
+    """Convert any loaded data to a plain text string.
+
+    Useful for standardizing output from different loaders into a single text format.
+
+    Args:
+        data: Loaded content (str, list, dict, or nested structures)
+
+    Returns:
+        str: Plain text representation of the data
+    """
+    if isinstance(data, str):
+        return data
+
+    if isinstance(data, list):
+        lines = []
+        for item in data:
+            if isinstance(item, str):
+                lines.append(item)
+            elif isinstance(item, dict):
+                lines.append(" | ".join(f"{k}: {v}" for k, v in item.items()))
+            elif isinstance(item, list):
+                lines.append(" | ".join(str(x) for x in item))
+            else:
+                lines.append(str(item))
+        return "\n".join(lines)
+
+    if isinstance(data, dict):
+        lines = []
+        for key, value in data.items():
+            if isinstance(value, dict):
+                lines.append(f"[{key}]")
+                for k, v in value.items():
+                    lines.append(f"  {k}: {v}")
+            else:
+                lines.append(f"{key}: {value}")
+        return "\n".join(lines)
+
+    return str(data)
+
+
+def word_count(data):
+    """Count words in loaded content.
+
+    Args:
+        data: Loaded content (str, list, or dict)
+
+    Returns:
+        int: Total word count
+    """
+    text = convert_to_text(data)
+    return len(text.split())
+
+
+def export_to_json(data, output_path, indent=2):
+    """Export any loaded data to a JSON file.
+
+    Args:
+        data: Loaded content to export
+        output_path: Path for the output JSON file
+        indent: JSON indentation level (default: 2)
+    """
+    # Convert non-serializable types
+    def make_serializable(obj):
+        if isinstance(obj, (str, int, float, bool, type(None))):
+            return obj
+        if isinstance(obj, dict):
+            return {str(k): make_serializable(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [make_serializable(item) for item in obj]
+        return str(obj)
+
+    serializable = make_serializable(data)
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(serializable, f, indent=indent, ensure_ascii=False)
+
+
+def compare_files(filepath1, filepath2):
+    """Compare two files and return differences summary.
+
+    Both files are loaded using auto_load, then compared.
+
+    Args:
+        filepath1: Path to first file
+        filepath2: Path to second file
+
+    Returns:
+        dict: Comparison result with 'identical' flag and details
+    """
+    from .smart_loader import auto_load
+
+    data1 = auto_load(filepath1)
+    data2 = auto_load(filepath2)
+
+    text1 = convert_to_text(data1)
+    text2 = convert_to_text(data2)
+
+    lines1 = text1.splitlines()
+    lines2 = text2.splitlines()
+
+    only_in_first = [l for l in lines1 if l not in lines2]
+    only_in_second = [l for l in lines2 if l not in lines1]
+
+    return {
+        "identical": text1 == text2,
+        "file1_lines": len(lines1),
+        "file2_lines": len(lines2),
+        "file1_words": len(text1.split()),
+        "file2_words": len(text2.split()),
+        "only_in_file1": only_in_first[:20],  # Limit output
+        "only_in_file2": only_in_second[:20],
+    }

smartdocloader-1.0.0.dist-info/METADATA

@@ -0,0 +1,390 @@
+Metadata-Version: 2.4
+Name: smartdocloader
+Version: 1.0.0
+Summary: An advanced universal document loader - load TXT, CSV, JSON, XML, YAML, INI, HTML, PDF, DOCX, PPTX, XLSX with smart auto-detection
+Author: Your Name
+Author-email: your.email@example.com
+License: MIT
+Project-URL: Source, https://github.com/yourusername/smartdocloader
+Keywords: document,loader,pdf,docx,xlsx,csv,json,yaml,parser,reader
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: PyPDF2
+Requires-Dist: python-docx
+Requires-Dist: python-pptx
+Requires-Dist: openpyxl
+Provides-Extra: yaml
+Requires-Dist: pyyaml; extra == "yaml"
+Provides-Extra: all
+Requires-Dist: pyyaml; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# smartdocloader
+
+An advanced universal document loader for Python. Smart auto-detection, batch loading, content search, and support for 11+ file formats.
+
+## Installation
+
+```bash
+pip install smartdocloader
+```
+
+For YAML support:
+```bash
+pip install smartdocloader[yaml]
+```
+
+## Features
+
+- **Auto-detection**: Automatically detects file type and uses the right loader
+- **Batch loading**: Load multiple files in one call
+- **11 formats supported**: TXT, CSV, JSON, XML, YAML, INI, HTML, PDF, DOCX, PPTX, XLSX
+- **Content search**: Search within loaded data
+- **Export**: Convert loaded data to JSON
+- **File comparison**: Compare content of two files
+- **Advanced options**: Page ranges for PDFs, sheet selection for Excel, table extraction from Word
+
+---
+
+## Quick Start
+
+```python
+from smartdocloader import auto_load
+
+# Just pass any file - it auto-detects the format
+data = auto_load("report.pdf")
+data = auto_load("data.csv")
+data = auto_load("config.yaml")
+```
+
+---
+
+## All Supported Formats
+
+| Format | Extensions | Module |
+|--------|-----------|--------|
+| Plain Text | `.txt` | text_loader |
+| CSV | `.csv` | text_loader |
+| JSON | `.json` | text_loader |
+| XML | `.xml` | text_loader |
+| YAML | `.yaml`, `.yml` | text_loader |
+| INI/Config | `.ini`, `.cfg` | text_loader |
+| HTML | `.html`, `.htm` | text_loader |
+| PDF | `.pdf` | doc_loader |
+| Word | `.docx` | doc_loader |
+| PowerPoint | `.pptx` | doc_loader |
+| Excel | `.xlsx` | doc_loader |
+
+---
+
+## Modules & Functions
+
+### Module 1: `text_loader`
+
+| Function | Description |
+|----------|-------------|
+| `load_txt(filepath, encoding)` | Load plain text file |
+| `load_csv(filepath, delimiter, encoding)` | Load CSV as list of dicts |
+| `load_json(filepath, encoding)` | Load and parse JSON |
+| `load_xml(filepath)` | Load XML as nested dict |
+| `load_yaml(filepath, encoding)` | Load YAML data |
+| `load_ini(filepath, encoding)` | Load INI as nested dict |
+| `load_html(filepath, encoding)` | Extract text from HTML |
+
+### Module 2: `doc_loader`
+
+| Function | Description |
+|----------|-------------|
+| `load_pdf(filepath, page_range)` | Extract text from PDF (optional page range) |
+| `load_pdf_pages(filepath)` | Get text per page as a list |
+| `load_pdf_metadata(filepath)` | Get PDF metadata (author, title, etc.) |
+| `load_docx(filepath, include_tables)` | Load Word document paragraphs |
+| `load_docx_with_styles(filepath)` | Load with style/formatting info |
+| `load_pptx(filepath, include_notes)` | Load PowerPoint slides |
+| `load_xlsx(filepath, sheet_name)` | Load Excel data from specific sheet |
+| `load_xlsx_sheets(filepath)` | List all sheet names |
+
+### Module 3: `smart_loader`
+
+| Function | Description |
+|----------|-------------|
+| `auto_load(filepath)` | Auto-detect format and load |
+| `batch_load(filepaths)` | Load multiple files at once |
+| `get_file_info(filepath)` | Get file metadata (size, type, etc.) |
+| `supported_formats()` | List all supported extensions |
+
+### Module 4: `utils`
+
+| Function | Description |
+|----------|-------------|
+| `search_content(data, keyword)` | Search within loaded content |
+| `convert_to_text(data)` | Convert any loaded data to plain text |
+| `word_count(data)` | Count words in loaded content |
+| `export_to_json(data, output_path)` | Export loaded data to JSON file |
+| `compare_files(filepath1, filepath2)` | Compare two files |
+
+---
+
+## Usage Examples
+
+### Auto-Loading (Smart Detection)
+
+```python
+from smartdocloader import auto_load
+
+# Just pass any file path - format is auto-detected
+pdf_content = auto_load("report.pdf")
+csv_data = auto_load("students.csv")
+config = auto_load("settings.yaml")
+
+print(pdf_content[:100])
+```
+
+### Batch Loading Multiple Files
+
+```python
+from smartdocloader import batch_load
+
+files = ["data.csv", "report.pdf", "config.json", "notes.txt"]
+results = batch_load(files)
+
+for filepath, content in results.items():
+    if "error" in content if isinstance(content, dict) else False:
+        print(f"Failed: {filepath} - {content['error']}")
+    else:
+        print(f"Loaded: {filepath}")
+```
+
+### Loading PDFs with Options
+
+```python
+from smartdocloader import load_pdf, load_pdf_pages, load_pdf_metadata
+
+# Load entire PDF
+full_text = load_pdf("book.pdf")
+
+# Load only pages 0-4 (first 5 pages)
+intro = load_pdf("book.pdf", page_range=(0, 5))
+
+# Get text per page
+pages = load_pdf_pages("book.pdf")
+print(f"Page 1: {pages[0][:100]}")
+print(f"Total pages: {len(pages)}")
+
+# Get metadata
+meta = load_pdf_metadata("book.pdf")
+print(f"Author: {meta['author']}")
+print(f"Title: {meta['title']}")
+print(f"Pages: {meta['page_count']}")
+```
+
+### Loading Word Documents
+
+```python
+from smartdocloader import load_docx, load_docx_with_styles
+
+# Basic loading
+paragraphs = load_docx("report.docx")
+for p in paragraphs:
+    print(p)
+
+# With tables included
+content = load_docx("report.docx", include_tables=True)
+for item in content:
+    print(item)
+
+# With style information
+styled = load_docx_with_styles("report.docx")
+for para in styled:
+    if para["bold"]:
+        print(f"[BOLD] {para['text']}")
+    else:
+        print(f"       {para['text']}")
+```
+
+### Loading Excel with Sheet Selection
+
+```python
+from smartdocloader import load_xlsx, load_xlsx_sheets
+
+# See available sheets
+sheets = load_xlsx_sheets("financials.xlsx")
+print(f"Sheets: {sheets}")
+
+# Load specific sheet
+q1_data = load_xlsx("financials.xlsx", sheet_name="Q1")
+for row in q1_data:
+    print(row)
+```
+
+### Loading PowerPoint with Notes
+
+```python
+from smartdocloader import load_pptx
+
+slides = load_pptx("lecture.pptx", include_notes=True)
+for slide in slides:
+    print(f"--- Slide {slide['slide_number']} ---")
+    for text in slide["text"]:
+        print(f"  {text}")
+    if "notes" in slide and slide["notes"]:
+        print(f"  [Notes: {slide['notes']}]")
+```
+
+### Loading YAML Configuration
+
+```python
+from smartdocloader import load_yaml
+
+config = load_yaml("docker-compose.yml")
+print(config["services"])
+```
+
+### Loading INI/Config Files
+
+```python
+from smartdocloader import load_ini
+
+settings = load_ini("app.ini")
+print(settings["database"]["host"])
+print(settings["database"]["port"])
+```
+
+### Loading HTML (Text Extraction)
+
+```python
+from smartdocloader import load_html
+
+text = load_html("page.html")
+print(text)  # Clean text without HTML tags
+```
+
+### Searching Within Loaded Content
+
+```python
+from smartdocloader import auto_load, search_content
+
+# Load any file
+data = auto_load("students.csv")
+
+# Search for a keyword
+matches = search_content(data, "Ahmed")
+print(f"Found {len(matches)} matches:")
+for match in matches:
+    print(f"  {match}")
+```
+
+### Converting to Plain Text
+
+```python
+from smartdocloader import auto_load, convert_to_text
+
+# Load structured data
+data = auto_load("grades.xlsx")
+
+# Convert to flat text
+text = convert_to_text(data)
+print(text)
+```
+
+### Exporting to JSON
+
+```python
+from smartdocloader import auto_load, export_to_json
+
+# Load a Word document
+data = auto_load("report.docx")
+
+# Export as JSON for further processing
+export_to_json(data, "report_output.json")
+```
+
+### Comparing Two Files
+
+```python
+from smartdocloader import compare_files
+
+result = compare_files("version1.txt", "version2.txt")
+print(f"Identical: {result['identical']}")
+print(f"File 1: {result['file1_lines']} lines, {result['file1_words']} words")
+print(f"File 2: {result['file2_lines']} lines, {result['file2_words']} words")
+```
+
+### Getting File Info
+
+```python
+from smartdocloader import get_file_info
+
+info = get_file_info("report.pdf")
+print(f"Name: {info['name']}")
+print(f"Size: {info['size_readable']}")
+print(f"Supported: {info['is_supported']}")
+```
+
+### Listing Supported Formats
+
+```python
+from smartdocloader import supported_formats
+
+formats = supported_formats()
+print(f"Supported: {', '.join(formats)}")
+```
+
+---
+
+## Error Handling
+
+```python
+from smartdocloader import auto_load
+
+try:
+    data = auto_load("unknown.xyz")
+except ValueError as e:
+    print(f"Format error: {e}")
+except FileNotFoundError as e:
+    print(f"File missing: {e}")
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+---
+
+## Requirements
+
+- Python >= 3.7
+- PyPDF2
+- python-docx
+- python-pptx
+- openpyxl
+- pyyaml (optional, for YAML support)
+
+---
+
+## License
+
+MIT

smartdocloader-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+smartdocloader/__init__.py,sha256=F7QQOV_yB811Inqxoepbe0aLSDCCQ7GUmthr4ONlPj4,1265
+smartdocloader/doc_loader.py,sha256=YwWnDnx8i0ZtXifKdVXjj5ZO51vbih4oUqOjINqEqII,5603
+smartdocloader/smart_loader.py,sha256=33854mZ14Z6rIo928FxNzJ-kjUteAeDH9f9lQQeYyOU,3263
+smartdocloader/text_loader.py,sha256=3svOQn6rnabJOw995zneH9fmzejJIhwYf92aGN6ogFM,4572
+smartdocloader/utils.py,sha256=c6g7jIscWUgKMTqGt_ORZrBTA5lvPXLWtcHofNjrlhw,5060
+smartdocloader-1.0.0.dist-info/licenses/LICENSE.txt,sha256=u8nMEhpntc7IP_2mYqSBf-ma-DlZ96r0xQyTAd3G5T8,1062
+smartdocloader-1.0.0.dist-info/METADATA,sha256=6y5EDLuQ1umRIpHBGzmoSqLdgzR9_QlqgPggXOjpYis,10180
+smartdocloader-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+smartdocloader-1.0.0.dist-info/top_level.txt,sha256=H6Vf0XUxub-LDjLTJdtsclakQ6II551OwamRyW-51_c,15
+smartdocloader-1.0.0.dist-info/RECORD,,

smartdocloader-1.0.0.dist-info/WHEEL

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

smartdocloader-1.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2026
+
+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.

smartdocloader-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smartdocloader