xml2table 0.1.0__py3-none-any.whl

xml2table/pdf_xml_writer.py

@@ -0,0 +1,71 @@
+"""Render an extracted PDF :class:`~xml2table.pdf_extract.Document` as XML."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Union
+from xml.dom import minidom
+from xml.etree import ElementTree as ET
+
+from .pdf_extract import Document, Page, Paragraph, Table
+from .pdf_options import PDFOptions
+
+
+def _format_bbox(bbox) -> str:
+    return ",".join(f"{v:.2f}" for v in bbox)
+
+
+def _add_paragraph(page_el: ET.Element, paragraph: Paragraph) -> None:
+    el = ET.SubElement(page_el, "paragraph", bbox=_format_bbox(paragraph.bbox))
+    el.text = paragraph.text
+
+
+def _add_table(page_el: ET.Element, table: Table, options: PDFOptions) -> None:
+    table_el = ET.SubElement(
+        page_el,
+        "table",
+        bbox=_format_bbox(table.bbox),
+        rows=str(table.n_rows),
+        cols=str(table.n_cols),
+    )
+    for row in table.rows:
+        row_el = ET.SubElement(table_el, "row")
+        for cell in row:
+            cell_el = ET.SubElement(row_el, "cell")
+            cell_el.text = cell if cell not in (None, "") else options.cell_na
+
+
+def _add_page(document_el: ET.Element, page: Page, options: PDFOptions) -> None:
+    page_el = ET.SubElement(
+        document_el,
+        "page",
+        number=str(page.number),
+        width=f"{page.width:.2f}",
+        height=f"{page.height:.2f}",
+    )
+    for block in page.blocks:
+        if isinstance(block, Paragraph):
+            _add_paragraph(page_el, block)
+        else:
+            _add_table(page_el, block, options)
+
+
+def document_to_element(document: Document, options: PDFOptions) -> ET.Element:
+    root = ET.Element("document", source=Path(document.source).name, pages=str(len(document.pages)))
+    for page in document.pages:
+        _add_page(root, page, options)
+    return root
+
+
+def document_to_xml(document: Document, options: PDFOptions) -> str:
+    """Serialize a :class:`Document` to a pretty-printed XML string."""
+    root = document_to_element(document, options)
+    rough = ET.tostring(root, encoding="unicode")
+    return minidom.parseString(rough).toprettyxml(indent="  ")
+
+
+def write_document_xml(document: Document, destination: Union[str, Path], options: PDFOptions) -> Path:
+    destination = Path(destination)
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(document_to_xml(document, options), encoding="utf-8")
+    return destination

xml2table/writers/__init__.py

@@ -0,0 +1,4 @@
+from .csv_writer import write_csv
+from .excel_writer import write_excel, write_workbook
+
+__all__ = ["write_csv", "write_excel", "write_workbook"]

xml2table/writers/csv_writer.py

@@ -0,0 +1,50 @@
+"""CSV output for flattened XML rows."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from ..parser import union_columns
+
+
+def write_csv(
+    rows: List[Dict[str, Any]],
+    destination: Union[str, Path],
+    *,
+    columns: Optional[List[str]] = None,
+    delimiter: str = ",",
+    encoding: str = "utf-8",
+    na_rep: str = "",
+) -> Path:
+    """Write flattened rows to a CSV file.
+
+    Args:
+        rows: Flat row dicts, as produced by :func:`xml2table.parser.parse_to_records`.
+        destination: Output file path.
+        columns: Explicit column order. Defaults to the union of all keys in
+            ``rows``, in first-seen order.
+        delimiter: Field delimiter.
+        encoding: Output file encoding.
+        na_rep: String used for missing values.
+
+    Returns:
+        The output path, as a :class:`~pathlib.Path`.
+    """
+    destination = Path(destination)
+    columns = columns if columns is not None else union_columns(rows)
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with destination.open("w", newline="", encoding=encoding) as fh:
+        writer = csv.DictWriter(
+            fh,
+            fieldnames=columns,
+            delimiter=delimiter,
+            restval=na_rep,
+            extrasaction="ignore",
+        )
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({k: (na_rep if v is None else v) for k, v in row.items()})
+    return destination

xml2table/writers/excel_writer.py

@@ -0,0 +1,114 @@
+"""Excel (.xlsx) output for flattened XML rows."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Optional, Union
+
+from openpyxl import Workbook
+from openpyxl.styles import Alignment, Font, PatternFill
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.worksheet import Worksheet
+
+from ..parser import union_columns
+
+_HEADER_FONT = Font(bold=True, color="FFFFFF")
+_HEADER_FILL = PatternFill(start_color="FF2F5496", end_color="FF2F5496", fill_type="solid")
+_MAX_COLUMN_WIDTH = 60
+_MIN_COLUMN_WIDTH = 8
+
+
+def _write_sheet(
+    ws: Worksheet,
+    rows: List[Dict[str, Any]],
+    columns: List[str],
+    *,
+    freeze_header: bool,
+    autofit: bool,
+    na_rep: Any,
+) -> None:
+    ws.append(columns)
+    for cell in ws[1]:
+        cell.font = _HEADER_FONT
+        cell.fill = _HEADER_FILL
+        cell.alignment = Alignment(vertical="center")
+
+    for row in rows:
+        ws.append([row.get(col, na_rep) for col in columns])
+
+    if freeze_header:
+        ws.freeze_panes = "A2"
+
+    if columns:
+        ws.auto_filter.ref = ws.dimensions
+
+    if autofit:
+        for idx, col in enumerate(columns, start=1):
+            longest = len(str(col))
+            for row in rows:
+                value = row.get(col, "")
+                if value is not None:
+                    longest = max(longest, len(str(value)))
+            width = min(max(longest + 2, _MIN_COLUMN_WIDTH), _MAX_COLUMN_WIDTH)
+            ws.column_dimensions[get_column_letter(idx)].width = width
+
+
+def write_workbook(
+    sheets: Mapping[str, List[Dict[str, Any]]],
+    destination: Union[str, Path],
+    *,
+    columns: Optional[Mapping[str, List[str]]] = None,
+    freeze_header: bool = True,
+    autofit: bool = True,
+    na_rep: Any = "",
+) -> Path:
+    """Write one or more named row-sets to a single ``.xlsx`` workbook.
+
+    Args:
+        sheets: Mapping of sheet name -> rows for that sheet.
+        destination: Output file path.
+        columns: Optional per-sheet explicit column order, keyed by sheet name.
+        freeze_header: Whether to freeze the header row.
+        autofit: Whether to approximate column widths from content.
+        na_rep: Value written for missing cells.
+
+    Returns:
+        The output path, as a :class:`~pathlib.Path`.
+    """
+    if not sheets:
+        raise ValueError("sheets must contain at least one entry")
+
+    destination = Path(destination)
+    columns = columns or {}
+
+    wb = Workbook()
+    wb.remove(wb.active)
+    for name, rows in sheets.items():
+        sheet_columns = columns.get(name) if columns.get(name) is not None else union_columns(rows)
+        ws = wb.create_sheet(title=name[:31] or "Sheet1")
+        _write_sheet(ws, rows, sheet_columns, freeze_header=freeze_header, autofit=autofit, na_rep=na_rep)
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    wb.save(str(destination))
+    return destination
+
+
+def write_excel(
+    rows: List[Dict[str, Any]],
+    destination: Union[str, Path],
+    *,
+    sheet_name: str = "Sheet1",
+    columns: Optional[List[str]] = None,
+    freeze_header: bool = True,
+    autofit: bool = True,
+    na_rep: Any = "",
+) -> Path:
+    """Write flattened rows to a single-sheet ``.xlsx`` workbook."""
+    return write_workbook(
+        {sheet_name: rows},
+        destination,
+        columns={sheet_name: columns} if columns is not None else None,
+        freeze_header=freeze_header,
+        autofit=autofit,
+        na_rep=na_rep,
+    )

xml2table-0.1.0.dist-info/METADATA

@@ -0,0 +1,353 @@
+Metadata-Version: 2.4
+Name: xml2table
+Version: 0.1.0
+Summary: Convert XML and PDF documents to CSV, Excel, XML, and text with a small, predictable SDK.
+Author-email: Meet2147 <meetjethwa3@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Meet2147/pythonLibraries/tree/main/xml2table
+Project-URL: Repository, https://github.com/Meet2147/pythonLibraries
+Project-URL: Issues, https://github.com/Meet2147/pythonLibraries/issues
+Keywords: xml,pdf,csv,excel,xlsx,convert,flatten,etl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Markup :: XML
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3; extra == "pandas"
+Provides-Extra: lxml
+Requires-Dist: lxml>=4.9; extra == "lxml"
+Provides-Extra: pdf-text
+Requires-Dist: pypdf>=4.0; extra == "pdf-text"
+Provides-Extra: pdf
+Requires-Dist: pdfplumber>=0.10; extra == "pdf"
+Requires-Dist: pypdf>=4.0; extra == "pdf"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pandas>=1.3; extra == "dev"
+Requires-Dist: pdfplumber>=0.10; extra == "dev"
+Requires-Dist: pypdf>=4.0; extra == "dev"
+Requires-Dist: fpdf2>=2.7; extra == "dev"
+Dynamic: license-file
+
+# xml2table
+
+A small, predictable Python SDK for converting XML and PDF documents to
+CSV, Excel, XML, and plain text.
+
+- **XML → CSV / Excel.** One core recursive flattening function turns
+  nested XML into flat rows; CSV and Excel are thin writers on top of it.
+  No data loss by default: repeated elements can be joined into one cell,
+  exploded into extra rows, or spread across indexed columns — you choose.
+- **PDF → XML.** A structure-preserving extractor ([`pdfplumber`](https://github.com/jsvine/pdfplumber)-backed)
+  groups a PDF's words into paragraphs and detects tables, keeping both in
+  their original top-to-bottom reading order — no data lost, no tables
+  flattened into loose words.
+- **PDF → text.** A fast, lightweight raw-text extractor
+  ([`pypdf`](https://github.com/py-pdf/pypdf)-backed) that doesn't need
+  table detection at all — just the PDF's text, in reading order, with its
+  visual whitespace layout preserved by default.
+- **Small dependency footprint.** Only [`openpyxl`](https://openpyxl.readthedocs.io/)
+  is required for the XML-to-table side. `pandas` (DataFrames), `pypdf`
+  (PDF text), and `pdfplumber` (PDF XML/tables) are all optional extras —
+  importing `xml2table` never requires any of them.
+- **Three ways in, for each conversion:** one-line functions, a reusable
+  converter object, or the `xml2table` CLI.
+
+## Install
+
+```bash
+pip install -e .             # from a checkout: XML -> CSV/Excel only
+pip install -e ".[pandas]"   # + optional DataFrame support
+pip install -e ".[pdf-text]" # + PDF -> text (pypdf only, lightweight)
+pip install -e ".[pdf]"      # + PDF -> XML and text (pdfplumber + pypdf)
+```
+
+## Quick start
+
+```python
+from xml2table import xml_to_csv, xml_to_excel
+
+xml_to_csv("orders.xml", "orders.csv")
+xml_to_excel("orders.xml", "orders.xlsx")
+```
+
+Given:
+
+```xml
+<orders>
+  <order id="1">
+    <customer><name>Jane Doe</name></customer>
+    <total>99.99</total>
+  </order>
+</orders>
+```
+
+you get one row per `<order>`:
+
+| @id | customer.name | total |
+|-----|----------------|-------|
+| 1   | Jane Doe       | 99.99 |
+
+Nested elements are flattened with `.`-separated keys, attributes get an
+`@` prefix, and the record element (`order` here) is auto-detected as "the
+repeated child of the root". When detection is ambiguous, pass
+`record_path` explicitly.
+
+## Reusable converter
+
+Parse once, write many times:
+
+```python
+from xml2table import XMLConverter, FlattenOptions
+
+converter = XMLConverter("orders.xml", options=FlattenOptions(record_path="Order"))
+converter.to_csv("orders.csv")
+converter.to_excel("orders.xlsx", sheet_name="Orders")
+rows = converter.to_records()      # list[dict]
+df = converter.to_dataframe()      # requires pandas
+```
+
+## Handling repeated elements (`array_mode`)
+
+Given an order with two line items, `FlattenOptions.array_mode` controls the
+shape of the output:
+
+| mode | Result | Use when |
+|------|--------|----------|
+| `"join"` (default) | One row per order; items collapsed into one joined cell | You just want a quick, human-readable table |
+| `"explode"` | One row per item (order fields repeat) | You want a normalized, analysis-ready table, like a SQL join |
+| `"index"` | One row per order; items spread into `items.item.0.*`, `items.item.1.*`, ... | You need every field as its own column with no row duplication |
+
+```python
+from xml2table import FlattenOptions, xml_to_records
+
+xml_to_records("orders.xml", options=FlattenOptions(array_mode="explode"))
+```
+
+## Multi-sheet Excel from one document
+
+Turn different parts of the same XML document into separate, related sheets
+(e.g. an "orders" table and an "items" table):
+
+```python
+from xml2table import xml_to_excel
+
+xml_to_excel(
+    "orders.xml", "orders.xlsx",
+    sheets={"orders": "Order", "items": ".//Order/Items/Item"},
+)
+```
+
+## Record paths
+
+`record_path` uses the same syntax as
+[`Element.findall`](https://docs.python.org/3/library/xml.etree.elementtree.html#xml.etree.ElementTree.Element.findall)
+(a subset of XPath): `"Order"`, `"Orders/Order"`, `".//Item"`,
+`"Order[@status='shipped']"`, etc.
+
+## CLI (XML)
+
+```bash
+xml2table csv orders.xml orders.csv --record-path Order --array-mode explode
+xml2table excel orders.xml orders.xlsx --sheet-name Orders
+xml2table excel orders.xml orders.xlsx --sheet orders=Order --sheet items=".//Item"
+```
+
+Run `xml2table csv --help` or `xml2table excel --help` for all flags
+(`--separator`, `--attribute-prefix`, `--no-attributes`, `--keep-namespaces`,
+`--delimiter`, `--encoding`, ...).
+
+## PDF → XML / text
+
+`pdf_to_xml` and `pdf_to_text` are two independent, purpose-built backends
+behind one options object and one CLI command:
+
+- **`pdf_to_xml`** (pdfplumber) groups the PDF's words into paragraphs (by
+  line, then by vertical gap) and detects tables separately via ruling
+  lines or text alignment, then places both back in the order they appear
+  on the page. Nothing is dropped, and table text never bleeds into
+  surrounding paragraphs.
+- **`pdf_to_text`** (pypdf) is a much lighter path: it just extracts each
+  page's text in reading order, preserving the PDF's visual whitespace
+  layout by default (so simple tables and columns still read naturally)
+  without doing any table detection.
+
+```python
+from xml2table import pdf_to_xml, pdf_to_text
+
+pdf_to_xml("invoice.pdf", "invoice.xml")    # paragraphs + tables (needs xml2table[pdf])
+pdf_to_text("invoice.pdf", "invoice.txt")   # fast raw text (needs xml2table[pdf-text])
+```
+
+`invoice.xml` looks like:
+
+```xml
+<document source="invoice.pdf" pages="1">
+  <page number="1" width="595.28" height="841.89">
+    <paragraph bbox="42.83,43.13,159.90,61.13">Invoice #1024</paragraph>
+    <table bbox="40.00,220.00,540.00,316.00" rows="4" cols="3">
+      <row><cell>Item</cell><cell>Qty</cell><cell>Price</cell></row>
+      <row><cell>Widget</cell><cell>2</cell><cell>$10.00</cell></row>
+      ...
+    </table>
+  </page>
+</document>
+```
+
+`invoice.txt` is pypdf's layout-preserving text, e.g.:
+
+```
+Invoice #1024
+
+Bill To: Jane Doe
+123 Example Street
+Springfield, USA
+
+Thank you for your business. Payment is due within thirty days...
+
+Item                                                          Qty        Price
+Widget                                                        2          $10.00
+...
+```
+
+Reuse one `PDFConverter` for both (it lazily parses with pdfplumber only if
+you call `to_xml()`/`pages`, and always uses pypdf for `to_text()`):
+
+```python
+from xml2table import PDFConverter
+
+converter = PDFConverter("invoice.pdf")
+converter.to_xml("invoice.xml")
+converter.to_text("invoice.txt")
+for page in converter.pages:
+    print(page.number, len(page.paragraphs), len(page.tables))
+```
+
+### `PDFOptions` reference
+
+| Option | Default | Used by | Description |
+|--------|---------|---------|--------------|
+| `line_tolerance` | `3.0` | XML | Max vertical gap (points) for words to count as the same line |
+| `paragraph_gap` | `6.0` | XML | Min vertical gap (points) between lines that starts a new paragraph |
+| `table_settings` | `None` | XML | Passed through to pdfplumber's `find_tables()` for unusual tables (e.g. borderless). **Caution:** this applies to the whole page, not just the table — see [Validation](#validation-tested-on-1200-financial-report-pdfs) below before using it on documents with narrative text. |
+| `cell_na` | `""` | XML | String used for empty/missing table cells |
+| `page_separator` | `"\n----- Page {page} -----\n"` | text | Inserted between pages |
+| `keep_layout` | `True` | text | Preserve the PDF's whitespace layout (pypdf `"layout"` mode) vs. plain, whitespace-normalized text |
+
+### CLI (PDF)
+
+```bash
+xml2table pdf invoice.pdf invoice.xml --to xml
+xml2table pdf invoice.pdf invoice.txt --to text
+```
+
+Run `xml2table pdf --help` for all flags (`--line-tolerance`,
+`--paragraph-gap`, `--cell-na`, `--page-separator`, `--no-layout`).
+
+## Validation: tested on 1,200 financial-report PDFs
+
+`pdf_to_xml` and `pdf_to_text` were benchmarked against 1,200 generated
+financial-report PDFs (balance sheets, income statements, cash-flow
+statements, MD&A-style narrative text, footnotes — real financial
+formatting: `$1,234,567`, `(123,456)` negatives, `N/A` blanks, multi-page,
+ruled and borderless tables) with **exact ground truth** for every paragraph
+and table cell, so the numbers below are measured, not estimated. Full
+methodology, the generator, and raw per-document results are in
+[`benchmarks/RESULTS.md`](benchmarks/RESULTS.md).
+
+| Metric | Result |
+|---|---|
+| Documents converted without error | **1,200 / 1,200 (100%)** |
+| Paragraph text fidelity (XML) | **100.000%** |
+| Ruled-table shape + cell fidelity | **100.000%** |
+| Borderless-table shape detection | 0.000% (documented limitation — see below) |
+| Raw-text content recall (`pdf_to_text`) | **100.000%**, including for borderless tables |
+| Throughput | 20.4 PDFs/sec (`pdf_to_xml`), 184.6 PDFs/sec (`pdf_to_text`) |
+
+**The one real limitation, quantified:** pdfplumber's default table finder
+needs ruling lines, so it doesn't detect borderless (text-only-aligned)
+tables — but nothing is lost when it doesn't: the un-detected table's text
+still comes through as ordinary paragraph text (`pdf_to_text` recall stays
+at 100%). We also tested the obvious "fix" — pdfplumber's `table_settings`
+override for borderless tables — across all 1,200 documents, and it made
+things *worse*: because the override applies to the whole page, it started
+misreading ordinary paragraph sentences as table cells, corrupting
+paragraph output in **97.9% of documents** (paragraph fidelity dropped from
+100% to 13.9%). We did not ship that as a recommended workaround; see
+`PDFOptions.table_settings`'s docstring and `benchmarks/RESULTS.md` for the
+full numbers and why.
+
+We could not download real financial filings for this test — this sandboxed
+session's network policy blocks direct access to sites like sec.gov — so
+the corpus is synthetic but built to real financial-statement conventions
+specifically so every value has a known-correct answer to grade against.
+`benchmarks/RESULTS.md` explains this in more detail and gives the exact
+commands to reproduce or extend the benchmark (e.g. against real filings, on
+a machine with broader network access).
+
+## `FlattenOptions` reference
+
+| Option | Default | Description |
+|--------|---------|--------------|
+| `record_path` | `None` (auto-detect) | Path to the repeated record element |
+| `attribute_prefix` | `"@"` | Prefix for attribute-derived columns |
+| `text_key` | `"#text"` | Key for an element's own text when it also has attributes/children |
+| `separator` | `"."` | Separator for nested key paths |
+| `array_mode` | `"join"` | `"join"`, `"explode"`, or `"index"` |
+| `join_separator` | `"; "` | Separator used by `"join"` mode |
+| `include_attributes` | `True` | Include XML attributes as columns |
+| `strip_namespaces` | `True` | Strip `{namespace}` from tag/attribute names |
+| `encoding` | `"utf-8"` | Text encoding for reads/writes |
+
+## Errors
+
+All exceptions inherit from `xml2table.XMLConversionError`:
+
+- `XMLParseError` — malformed XML input
+- `RecordPathNotFoundError` — `record_path` matched nothing, or automatic
+  record detection was ambiguous (the error message tells you what to pass)
+- `PDFExtractionError` — a PDF file could not be opened or parsed
+- `MissingOptionalDependencyError` — e.g. calling `to_dataframe()` without
+  `pandas`, `pdf_to_xml()` without `pdfplumber`, or `pdf_to_text()` without
+  `pypdf`, installed
+
+## Development
+
+```bash
+pip install -e ".[dev]"   # includes pandas, pdfplumber, pypdf, and fpdf2 (for regenerating PDF fixtures)
+pytest
+python examples/quickstart.py
+```
+
+Project layout:
+
+```
+src/xml2table/
+  parser.py          # XML -> list[dict] flattening engine
+  options.py         # FlattenOptions
+  converter.py       # XMLConverter + module-level convenience functions
+  writers/           # CSV and Excel output
+  pdf_extract.py     # pdfplumber: PDF -> Document(pages of Paragraph/Table), in reading order
+  pdf_xml_writer.py  # Document -> XML
+  pdf_text_extract.py # pypdf: PDF -> plain text, independent of pdf_extract.py
+  pdf_options.py     # PDFOptions
+  pdf_converter.py   # PDFConverter + pdf_to_xml/pdf_to_text
+  cli.py             # `xml2table` command-line tool
+tests/
+  fixtures/          # sample XML documents and PDF fixtures (fixtures/pdf/)
+  test_*.py
+examples/
+  quickstart.py
+```

xml2table-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+xml2table/__init__.py,sha256=dZrUzgk1ttBRyEWwBBBzxE5Q_xausg4mWUHveBf70eg,1851
+xml2table/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+xml2table/cli.py,sha256=01xRgPkDe7LYkd9xBRxjcvdTQZVgX3POUOK7wuV-HGc,6976
+xml2table/converter.py,sha256=iQulK_48d2hO7pfCgjAPiMW9QHKgXYQZXsu-xdEOHRE,6295
+xml2table/exceptions.py,sha256=lDpNFHiPffL-shIAhbtN6M9_MZAoNgg3N_oByO4aFl4,836
+xml2table/options.py,sha256=EVhZcdnT6ewJlV0uC3c76jthgdkcO2ZplxQKmu9nWoU,2927
+xml2table/parser.py,sha256=6ZwIkLKXtVqAUxQNO2PdPvepoq4Jtgp01DFmEVNorQw,8204
+xml2table/pdf_converter.py,sha256=s9Zvr1-dNrZst1lqJHFNxoJKk1srZvDaga_9NGThX4g,3727
+xml2table/pdf_extract.py,sha256=cEB5fKP3Bm4jGHNPqIIgU6Uu03_Q7xXag4hRBJeco00,6640
+xml2table/pdf_options.py,sha256=7Vk-vLiP7YOtztOuWwYEHs-Z7hkOYoVTlirI_mtTakY,2598
+xml2table/pdf_text_extract.py,sha256=sM3a-75JXGWFkDM30sO7UFtM4mLHaptAXwED5LuV0KY,2637
+xml2table/pdf_xml_writer.py,sha256=OqudAAV4sz0NLJ6QcQ8ewZF_pH7HuJW0gai4Ny_WeKU,2392
+xml2table/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xml2table/writers/__init__.py,sha256=klJp665bhn_dCWu0cboGdtDkOA1n4sG8-k6k-YYZp9c,146
+xml2table/writers/csv_writer.py,sha256=D2UPyGNlgEKR7TkfSoEPvEDjKuvBDHJC_yzL0ltW2VA,1508
+xml2table/writers/excel_writer.py,sha256=hLg2A-YOSgJ9kwCmeAOC10tsa6X9WJuVb3R2uUoAtys,3490
+xml2table-0.1.0.dist-info/licenses/LICENSE,sha256=8dM3jbNCeKKzPTUb21RxFuyBzR3kqatmEDdVcuVMXDE,1065
+xml2table-0.1.0.dist-info/METADATA,sha256=aLJjBiSUayxqBQTt5s2DWJVsFHW-AEQiVcI7LSvWA9E,14185
+xml2table-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+xml2table-0.1.0.dist-info/entry_points.txt,sha256=QhlYFHOR3s6RsgaMVcI_Q330Mglo97iqfnqeo02NKKI,49
+xml2table-0.1.0.dist-info/top_level.txt,sha256=NfAgcf027U09Ay1urgtatTVIXbDu9mmR156TQyNWb3k,10
+xml2table-0.1.0.dist-info/RECORD,,

xml2table-0.1.0.dist-info/WHEEL

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

xml2table-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xml2table = xml2table.cli:main

xml2table-0.1.0.dist-info/licenses/LICENSE

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

xml2table-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xml2table