doclex-cli 0.1.1__py3-none-any.whl

doclex/segmentation/segmenter.py

@@ -0,0 +1,398 @@
+from __future__ import annotations
+
+import hashlib
+import re
+from pathlib import Path
+
+from kreuzberg import ExtractionConfig, extract_file_sync
+from kreuzberg.exceptions import KreuzbergError
+
+from doclex.metadata.models import ExtractedDoc, Segment
+
+# Minimum chars for a segment to be worth indexing
+_MIN_CHARS = 30
+
+# Maximum chars per segment — recursive splitter enforces this
+_MAX_CHARS = 1024
+
+# Headings: Markdown / plain text
+_HEADING_RE = re.compile(
+    r"(?:^|\n)(#{1,3}\s+.+|(?=\S).+\n[=\-]{3,})", re.MULTILINE
+)
+
+# Separators tried in order by the recursive splitter
+_SEPARATORS = ["\n\n", "\n", " "]
+
+
+def segment(doc: ExtractedDoc) -> list[Segment]:
+    """Segment an ExtractedDoc into indexable units based on file type.
+
+    Strategy:
+    1. Structure-based segmentation (headings, pages, sheets, tables)
+    2. Any segment > _MAX_CHARS is recursively split preserving semantic boundaries
+    """
+    suffix = Path(doc.path).suffix.lower()
+
+    if suffix == ".pdf":
+        raw = _segment_pdf(doc)
+    elif suffix in (".xlsx",):
+        raw = _segment_spreadsheet(doc)
+    elif suffix == ".csv":
+        raw = _segment_csv(doc)
+    elif suffix in (".docx", ".md", ".txt"):
+        raw = _segment_text(doc)
+    else:
+        raw = _segment_fallback(doc)
+
+    return _apply_size_limit(raw, _MAX_CHARS)
+
+
+# ------------------------------------------------------------------
+# PDF — page-by-page via form-feed split, fallback to full text
+# ------------------------------------------------------------------
+
+def _segment_pdf(doc: ExtractedDoc) -> list[Segment]:
+    """Segment PDF: markdown-based when precise mode produced headings, otherwise page-based."""
+    segments: list[Segment] = []
+
+    if _has_markdown_headings(doc.text):
+        # precise mode: Kreuzberg returned markdown with heading structure
+        segments = _segment_text(doc)
+    else:
+        pages = doc.text.split("\f")
+        segments = _make_segments(doc, pages, "page", "Page") if len(pages) > 1 else _segment_fallback(doc)
+
+    # Append table segments from precise mode (result.tables)
+    if doc.tables:
+        offset = len(segments)
+        for i, table in enumerate(doc.tables):
+            content = _table_to_text(table)
+            if len(content) >= _MIN_CHARS:
+                label = getattr(table, "name", None) or f"Table {i + 1}"
+                segments.append(_make_segment(doc, content, "table", label, offset + i))
+
+    return segments or _segment_fallback(doc)
+
+
+def _has_markdown_headings(text: str) -> bool:
+    return bool(re.search(r"(?:^|\n)#{1,3} ", text))
+
+
+# ------------------------------------------------------------------
+# XLSX — sheet-by-sheet via Kreuzberg tables
+# ------------------------------------------------------------------
+
+def _segment_spreadsheet(doc: ExtractedDoc) -> list[Segment]:
+    try:
+        config = ExtractionConfig()
+        result = extract_file_sync(doc.path, None, config)
+        if result.tables:
+            segments: list[Segment] = []
+            for i, table in enumerate(result.tables):
+                label = getattr(table, "name", None) or f"Sheet {i + 1}"
+                content = _table_to_text(table)
+                if len(content) >= _MIN_CHARS:
+                    segments.append(_make_segment(doc, content, "sheet", label, i))
+            if segments:
+                return segments
+    except KreuzbergError:
+        pass
+
+    return _segment_fallback(doc)
+
+
+# ------------------------------------------------------------------
+# CSV — table or chunked rows
+# ------------------------------------------------------------------
+
+def _segment_csv(doc: ExtractedDoc) -> list[Segment]:
+    try:
+        config = ExtractionConfig()
+        result = extract_file_sync(doc.path, None, config)
+        if result.tables:
+            content = _table_to_text(result.tables[0])
+            return [_make_segment(doc, content, "table", "Table", 0)]
+    except KreuzbergError:
+        pass
+
+    lines = [l for l in doc.text.splitlines() if l.strip()]
+    if not lines:
+        return []
+
+    chunk_size = 50
+    segments: list[Segment] = []
+    for i in range(0, len(lines), chunk_size):
+        chunk = "\n".join(lines[i : i + chunk_size])
+        label = f"Rows {i + 1}–{min(i + chunk_size, len(lines))}"
+        segments.append(_make_segment(doc, chunk, "table", label, i // chunk_size))
+    return segments
+
+
+# ------------------------------------------------------------------
+# DOCX / MD / TXT — heading-based segmentation
+# ------------------------------------------------------------------
+
+def _segment_text(doc: ExtractedDoc) -> list[Segment]:
+    text = doc.text.strip()
+    if not text:
+        return []
+
+    # Split on Markdown headings (# / ## / ###)
+    parts = re.split(r"\n(?=#{1,3} )", text)
+
+    if len(parts) <= 1:
+        # No headings — split on blank lines, no tree structure
+        parts = re.split(r"\n{2,}", text)
+        segments: list[Segment] = []
+        for i, part in enumerate(parts):
+            part = part.strip()
+            if len(part) < _MIN_CHARS:
+                continue
+            first_line = part.splitlines()[0].lstrip("#").strip()
+            label = first_line[:80] if first_line else f"Block {i + 1}"
+            segments.append(_make_segment(doc, part, "block", label, i))
+        return segments or _segment_fallback(doc)
+
+    # Parse heading parts
+    parsed: list[tuple[int, str, str, str, int]] = []  # (level, title, node_id, content, index)
+    for i, part in enumerate(parts):
+        part = part.strip()
+        if not part:
+            continue
+        first_line = part.splitlines()[0]
+        m = re.match(r"^(#{1,3}) ", first_line)
+        level = len(m.group(1)) if m else 0
+        title = first_line.lstrip("#").strip()[:80] or f"Block {i + 1}"
+        node_id = _segment_id(doc.path, title, i)
+        parsed.append((level, title, node_id, part, i))
+
+    # Create segments with level and section_id
+    segments = []
+    for level, title, node_id, content, i in parsed:
+        if len(content) < _MIN_CHARS:
+            continue
+        location_type = "section" if level <= 2 else "block"
+        segments.append(Segment(
+            id=node_id,
+            file_path=doc.path,
+            content=content,
+            location_type=location_type,
+            location_label=title,
+            location_index=i,
+            char_count=len(content),
+            section_id=node_id,
+            level=level,
+        ))
+
+    return segments or _segment_fallback(doc)
+
+
+# ------------------------------------------------------------------
+# Fallback — whole text as single block
+# ------------------------------------------------------------------
+
+def _segment_fallback(doc: ExtractedDoc) -> list[Segment]:
+    text = doc.text.strip()
+    if len(text) < _MIN_CHARS:
+        return []
+    return [_make_segment(doc, text, "block", "Document", 0)]
+
+
+# ------------------------------------------------------------------
+# Size enforcement — recursive character splitter
+# ------------------------------------------------------------------
+
+def _apply_size_limit(segments: list[Segment], max_chars: int) -> list[Segment]:
+    """Post-process segments: split on internal headings first, then by size."""
+    result: list[Segment] = []
+    for seg in segments:
+        for s in _split_on_internal_headings(seg):
+            result.extend(_split_if_too_long(s, max_chars))
+    return result
+
+
+def _split_on_internal_headings(seg: Segment) -> list[Segment]:
+    """Split a segment on any internal markdown headings it contains.
+
+    Prevents nesting content from different sections under a single heading node.
+    Only applies to heading segments (level > 0).
+    """
+    if seg.level == 0:
+        return [seg]
+
+    parts = re.split(r"\n(?=#{1,3} )", seg.content)
+    if len(parts) <= 1:
+        return [seg]
+
+    result: list[Segment] = []
+    for i, part in enumerate(parts):
+        part = part.strip()
+        if not part:
+            continue
+        first_line = part.splitlines()[0]
+        m = re.match(r"^(#{1,3}) ", first_line)
+
+        if i == 0:
+            # Original segment — keep id and level, update content
+            result.append(Segment(
+                id=seg.id,
+                file_path=seg.file_path,
+                content=part,
+                location_type=seg.location_type,
+                location_label=seg.location_label,
+                location_index=seg.location_index,
+                char_count=len(part),
+                section_id=seg.section_id,
+                level=seg.level,
+            ))
+        elif m:
+            # Internal heading — new sibling segment with its own level
+            level = len(m.group(1))
+            title = first_line.lstrip("#").strip()[:80]
+            node_id = _segment_id(seg.file_path, title, seg.location_index * 1000 + i)
+            result.append(Segment(
+                id=node_id,
+                file_path=seg.file_path,
+                content=part,
+                location_type="section" if level <= 2 else "block",
+                location_label=title,
+                location_index=seg.location_index * 1000 + i,
+                char_count=len(part),
+                section_id=node_id,
+                level=level,
+            ))
+
+    return result if result else [seg]
+
+
+def _split_if_too_long(seg: Segment, max_chars: int) -> list[Segment]:
+    """Return the segment as-is if within limit, or split it recursively."""
+    if len(seg.content) <= max_chars:
+        return [seg]
+
+    chunks = _recursive_split(seg.content, max_chars, _SEPARATORS)
+
+    result: list[Segment] = []
+    for i, chunk in enumerate(chunks):
+        chunk = chunk.strip()
+        if len(chunk) < _MIN_CHARS:
+            continue
+        sub_label = f"{seg.location_label} › {i + 1}"
+        sub_index = seg.location_index * 1000 + i
+        result.append(Segment(
+            id=_segment_id(seg.file_path, sub_label, sub_index),
+            file_path=seg.file_path,
+            content=chunk,
+            location_type=seg.location_type,
+            location_label=sub_label,
+            location_index=sub_index,
+            char_count=len(chunk),
+            section_id=seg.section_id,
+            level=0,  # sub-segments are continuations, not new heading nodes
+        ))
+
+    # Guard: never drop a valid segment entirely
+    return result if result else [seg]
+
+
+def _recursive_split(text: str, max_chars: int, separators: list[str]) -> list[str]:
+    """Split text into chunks of at most max_chars using the coarsest separator first.
+
+    Strategy:
+    1. Try to split on the coarsest separator.
+    2. Greedily merge consecutive pieces back together up to max_chars.
+    3. Pieces that are still too large are recursively split with the next separator.
+    """
+    if len(text) <= max_chars:
+        return [text]
+
+    if not separators:
+        # Hard character slice as last resort
+        return [text[i : i + max_chars] for i in range(0, len(text), max_chars)]
+
+    sep, *remaining = separators
+    raw_parts = text.split(sep)
+
+    if len(raw_parts) == 1:
+        # Separator not present in this text — try the next one
+        return _recursive_split(text, max_chars, remaining)
+
+    # First pass: recursively handle pieces that are individually too large
+    good_parts: list[str] = []
+    for part in raw_parts:
+        part = part.strip()
+        if not part:
+            continue
+        if len(part) <= max_chars:
+            good_parts.append(part)
+        else:
+            good_parts.extend(_recursive_split(part, max_chars, remaining))
+
+    # Second pass: greedy merge — combine consecutive parts up to max_chars
+    chunks: list[str] = []
+    current = ""
+    for part in good_parts:
+        candidate = (current + sep + part).strip() if current else part
+        if len(candidate) <= max_chars:
+            current = candidate
+        else:
+            if current:
+                chunks.append(current)
+            current = part
+    if current:
+        chunks.append(current)
+
+    return chunks
+
+
+# ------------------------------------------------------------------
+# Helpers
+# ------------------------------------------------------------------
+
+def _make_segments(
+    doc: ExtractedDoc,
+    parts: list[str],
+    location_type: str,
+    label_prefix: str,
+) -> list[Segment]:
+    segments: list[Segment] = []
+    for i, part in enumerate(parts):
+        part = part.strip()
+        if len(part) < _MIN_CHARS:
+            continue
+        label = f"{label_prefix} {i + 1}"
+        segments.append(_make_segment(doc, part, location_type, label, i))
+    return segments
+
+
+def _make_segment(
+    doc: ExtractedDoc,
+    content: str,
+    location_type: str,
+    location_label: str,
+    location_index: int,
+) -> Segment:
+    seg_id = _segment_id(doc.path, location_label, location_index)
+    return Segment(
+        id=seg_id,
+        file_path=doc.path,
+        content=content,
+        location_type=location_type,
+        location_label=location_label,
+        location_index=location_index,
+        char_count=len(content),
+    )
+
+
+def _table_to_text(table: object) -> str:
+    """Convert a Kreuzberg ExtractedTable to plain text."""
+    if hasattr(table, "content") and table.content:
+        return str(table.content)
+    if hasattr(table, "rows") and table.rows:
+        return "\n".join("\t".join(str(c) for c in row) for row in table.rows)
+    return str(table)
+
+
+def _segment_id(path: str, label: str, index: int) -> str:
+    raw = f"{path}|{label}|{index}"
+    return hashlib.sha256(raw.encode()).hexdigest()[:32]

doclex_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: doclex-cli
+Version: 0.1.1
+Summary: Local document search — BM25 lexical search over PDFs, DOCX, XLSX, CSV, Markdown and TXT files. No embeddings, no vector DB, no cloud.
+Project-URL: Repository, https://github.com/EnPaiva93/doclex-cli
+Author-email: EnPaiva_93 <enpaiva93@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite
+Requires-Dist: bm25x
+Requires-Dist: kreuzberg==4.8.2
+Requires-Dist: typer
+Requires-Dist: watchdog
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: ranx; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<h1 align="center">Doclex</h1>
+
+<p align="center"><em>English · <a href="README.es.md">Español</a></em></p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT">
+  <img src="https://img.shields.io/badge/python-3.12%2B-blue.svg" alt="Python 3.12+">
+</p>
+
+<p align="center">A CLI that turns a local folder of documents into a searchable, citable corpus. Point it at a folder; extraction, segmentation, indexing, and change tracking happen automatically.</p>
+
+## Features
+
+Doclex is the orchestration layer that ties them together so you never have to think about the pipeline yourself:
+
+- **Plug and play** — point it at a folder. Extraction, structural segmentation, indexing, and change tracking all happen automatically; there's no pipeline to wire up.
+- **SQLite is the source of truth** — every file's hash, mtime, and indexing status live in one place, so Doclex always knows exactly what changed and reprocesses only that.
+- **Local-first** — everything runs on your machine, nothing leaves it. No embeddings, no vector database, no cloud.
+- **Deterministic** — BM25 lexical scoring, no black-box similarity.
+- **Traceable** — every result cites its file, page/sheet/section, and score.
+- **Incremental** — only reprocesses files that actually changed.
+
+## Install
+
+Requires Python ≥3.12 and [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone https://github.com/EnPaiva93/doclex-cli.git
+cd doclex-cli
+uv sync
+```
+
+## Quickstart
+
+```bash
+# register a folder as a project
+uv run doclex add mydocs ./path/to/documents
+
+# build the index
+uv run doclex index --project mydocs
+
+# search it
+uv run doclex search "quarterly budget" --project mydocs
+```
+
+```
+[1] budget_2024.pdf — page 3  (score: 4.812)
+    "...the quarterly budget was approved with a 12% increase in..."
+
+[2] notes.md — Planning  (score: 2.107)
+    "...need to revisit the budget assumptions before..."
+```
+
+## Walkthrough
+
+A typical day-to-day flow, from an empty project to keeping it in sync:
+
+```bash
+# 1. register the folder you want to search
+doclex add contracts ~/Documents/legal/contracts
+
+# 2. build the index — extracts, segments, and indexes every supported file
+doclex index --project contracts
+```
+```
+Processing: 42 new, 0 modified, 0 deleted
+✓ Done.
+```
+```bash
+# 3. search it
+doclex search "termination clause" --project contracts
+```
+```
+[1] MSA_2023_AcmeCorp.pdf — Section 9.2  (score: 6.104)
+    "...either party may terminate this Agreement upon 30 days written notice..."
+
+[2] vendor_agreement_v3.docx — Termination  (score: 5.887)
+    "...termination for convenience requires 60 days advance notice to..."
+```
+```bash
+# 4. check what's indexed
+doclex status --project contracts
+```
+```
+Folder       ~/Documents/legal/contracts
+Indexed      42 files
+Segments     318
+BM25 index   318 docs
+Disk state   up to date
+```
+```bash
+# 5. a new contract shows up on disk — reindexing picks it up automatically
+doclex index --project contracts
+```
+```
+Processing: 1 new, 0 modified, 0 deleted
+✓ Done.
+```
+```bash
+# 6. see every registered project
+doclex list
+```
+```
+Name        Folder
+contracts   /home/you/Documents/legal/contracts
+```
+```bash
+# 7. done with it — deregister and purge its cache/index
+doclex remove contracts
+```
+
+Each project is independent — register as many non-overlapping folders as you need, each with its own cache and index:
+
+```bash
+doclex add hr-policies ~/Documents/hr
+doclex index --project hr-policies
+doclex search "vacation days" --project hr-policies --top 5
+```
+
+## Projects
+
+Every command operates on a **registered project** — a name bound to a folder — instead of a raw `--folder` flag. This keeps folder resolution unambiguous and lets Doclex reject overlapping folders (a subfolder registered as its own project would silently duplicate indexing and caching):
+
+```bash
+doclex add mydocs ./path/to/documents
+doclex add mydocs ./other       # error: name already exists
+doclex add sub ./path/to/documents/subdir   # error: overlaps with 'mydocs'
+doclex remove mydocs            # deregisters and purges its cache/index
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `doclex add <name> <folder>` | Register a folder under a project name |
+| `doclex list` | List registered projects |
+| `doclex remove <name>` | Remove a project and purge its cache/index |
+| `doclex index --project <name>` | Scan and index (incremental by default) |
+| `doclex search <query> --project <name>` | Search and print results with citations |
+| `doclex status --project <name>` | Show corpus/index status |
+
+Run `doclex <command> --help` for all flags and examples.
+
+### Flags in practice
+
+```bash
+# force a full re-extraction
+doclex index --project mydocs --force
+
+# reindex specific files after editing them
+doclex index --project mydocs --file report.pdf --file notes.docx
+
+# more results, full segment text instead of a snippet
+doclex search "risk assessment" --project mydocs --top 20 --full
+
+# list every indexed file and its status
+doclex status --project mydocs --all --filter error
+```
+
+## Architecture
+
+```
+folder → scan/watch → extract (Kreuzberg) → segment → BM25X index
+                                                  ↕
+                                          SQLite (files, segments)
+```
+
+| Layer | Responsibility |
+|---|---|
+| **Ingestion** | Scans a project's folder, hashes files to detect new/modified/deleted ones, skips its own cache directory |
+| **Extraction** | Delegates to [Kreuzberg](https://github.com/Goldziher/kreuzberg) to turn each file into plain text, normalized to an internal format |
+| **Segmentation** | Splits text along the file's natural structure — never blind fixed-size chunking (PDF → page, XLSX → sheet, DOCX → section, TXT/MD → block) |
+| **Index** | Indexes segments (not whole files) with BM25X; supports incremental add/update/delete |
+| **Metadata** | SQLite tracks each file's hash, mtime, size, MIME type, and indexing status, plus which segments belong to it |
+
+A local cache stores extracted text and generated segments per file, so unchanged files are never reprocessed.
+
+## Supported file types
+
+PDF · TXT · Markdown · DOCX · XLSX · CSV
+
+## Design principles
+
+Doclex is built to be local-first, incremental, explainable, deterministic, and cheap to run. It deliberately does **not**:
+
+- use embeddings or a vector database
+- upload files anywhere
+- depend on external services to search
+- run OCR by default
+- generate answers — it retrieves evidence, it doesn't interpret it
+
+## Stack
+
+Python · [Typer](https://typer.tiangolo.com/) · [Kreuzberg](https://github.com/Goldziher/kreuzberg) · BM25X · Watchdog · SQLite
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+```

doclex_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+doclex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/cli.py,sha256=rmbwL4XvGcmzTYlOaxnEqZQ8IOTuekvTeJDITWMfwLg,15989
+doclex/config.py,sha256=ZXgzFt7ONfvPHstdr53dtb4YB_3zEeO-XV3QoOrh_Zw,1338
+doclex/pipeline.py,sha256=fXxVdfY79Wv8Ud5sou4tbGDs_HIJKNl6JW6bXStDI7k,9644
+doclex/registry.py,sha256=G768iMsk4TR7FQQEHWTC7cu4uFQA-eZ4STRQCR8m_gA,3102
+doclex/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/cache/store.py,sha256=g05wNUtxRf_0PsWYhEfoZJwh_jupjd33swSkUpVKz_E,7319
+doclex/extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/extraction/extractor.py,sha256=zOaWODRqr5I8bDnocQCGWu73j6Xcw5Aa2bjnFIzs-Ms,2602
+doclex/index/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/index/bm25_index.py,sha256=11qzuQUu8l_FOc125A7NzOtaMuslUS_R-Y35OubdxhU,4474
+doclex/ingestion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/ingestion/scanner.py,sha256=J2fb5m2ulIS53Jr3aBfnBIGvQvy1md4ckl4h0td7rZ0,2620
+doclex/ingestion/watcher.py,sha256=dsyURJtrp4OfBkUPcrYOIfMMKklMlYFYqdqnytIzMHA,2993
+doclex/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/metadata/db.py,sha256=41871wIiKa1-iLu0GV6omoyW0vRYFOAxv0ms6hiuEuc,8736
+doclex/metadata/models.py,sha256=e2fc6mkhwKxYeLXeys7ZwEhTKJOzewzHPyFxzpjmUnA,1427
+doclex/segmentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doclex/segmentation/segmenter.py,sha256=m0MChmyEGV9HSZLjVHXz7DPOPOi03lxg88Pn4PezgyA,13572
+doclex_cli-0.1.1.dist-info/METADATA,sha256=0Vrfl-T89v3qJaOdbmRB4zzQApnb8wkYUgPeCOKE_0s,7448
+doclex_cli-0.1.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+doclex_cli-0.1.1.dist-info/entry_points.txt,sha256=D2nc0RMXcbn6oElT0xqj-pzpEC2YBQP5aXkK6ydKCKU,42
+doclex_cli-0.1.1.dist-info/licenses/LICENSE,sha256=VtEVThH2Pajb8nQ0ibXjL50aaHdJwwWJPDZBa8Aoxq8,1067
+doclex_cli-0.1.1.dist-info/RECORD,,

doclex_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

doclex_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doclex = doclex.cli:app

doclex_cli-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EnPaiva_93
+
+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.