paper-xlsx 0.1.0__tar.gz

paper_xlsx-0.1.0/AUTHORS.rst

@@ -0,0 +1,98 @@
+This project was started by Eric Gazoni. In 2013 Charlie Clark became
+co-maintainer of the project.
+
+It was initially *heavily* inspired by the PHPExcel library:
+http://www.phpexcel.net/
+
+Thanks to all those who participate in the project (in alphabetical order):
+
+* aceMueller
+* Adam Lofts
+* Adam Morris
+* Alessandro Cucci
+* Alex Gronholm
+* Alexander Ley
+* Alexandre Fayolle
+* Amin Mirzaee
+* Anders Chrigstrom
+* Anthony Hayward
+* Bernt R. Brenna
+* Brent Hoover
+* Brice Gelineau
+* ccoacley
+* Chi Ho Kwok
+* Cory Kramer
+* Day Barr
+* Detlef Lannert
+* Dieter Vandenbussche
+* Dmitriy Chernyshov
+* Dominik Geldmacher
+* Don Freeman
+* Eirikur Fannar Torfason
+* Elias Rabel
+* Eric Chlebek
+* Eric Gazoni
+* Eric Hurkman
+* Etienne Desautels
+* Felipe Ochoa
+* Felix Siebeneicker
+* Fumito Hamamura
+* Gabi Nagy
+* Gar Thompson
+* Gerald Van Huffelen
+* Greg Lehmann
+* Heikki Junes
+* Israel Barth Rubio
+* Jacob Middag
+* James Smagala
+* JarekPS
+* Jean Pierre Huart
+* Jeff Holman
+* John Woltman IV
+* Jonathan Peirce
+* Joseph Tate
+* Josh Haywood
+* Jun Omae
+* Kay Webber
+* Khchine Hamza
+* Klaus Bremer
+* Koert van der Veer
+* Laurent Laporte
+* Laurent Vasseur
+* Liam Sanders
+* Maarten De Paepe
+* Magnus Schieder
+* Mark Gemmill
+* Marko Loparic
+* Masato Yoshida
+* Max Bolingbroke
+* Nicholas Laver
+* Nis Martensen
+* Paul Joyce
+* Paul Van Der Linden
+* Philip Roche
+* Primoz Godec
+* ramn_se
+* René Neumann
+* Rick Rankin
+* Samuel Loretan
+* Sergey Pikhovkin
+* Shekhar Gyanwali
+* Shibukawa Yoshiki
+* Stefan Behnel
+* Stephane Bard
+* Stephen Rauch
+* Sven Burk
+* Ted Pollari
+* Thomas Nygards
+* Victor Korobkovsky
+* Waldemar Osuch
+* Wojciech Rola
+* Wolfgane Scherer
+* Yaroslav Halchenko
+* Yash Jhunjhunwala
+* Yingjie Lan
+* Leetao
+
+Project logo designed by Eric Gazoni, font by claudeserieux
+(http://www.dafont.com/profile.php?user=337503)

paper_xlsx-0.1.0/LICENCE.rst

@@ -0,0 +1,24 @@
+This software is under the MIT Licence
+======================================
+
+Copyright (c) 2010 openpyxl
+Portions Copyright (c) 2026 Paper Instruments, Inc.
+
+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.

paper_xlsx-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+prune openpyxl/sample
+prune openpyxl/benchmarks
+prune openpyxl/develop
+prune scratchpad
+prune doc
+
+include *.rst

paper_xlsx-0.1.0/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: paper-xlsx
+Version: 0.1.0
+Summary: A Python library to read/write Excel 2010 xlsx/xlsm files
+Home-page: https://github.com/The-LLM-Data-Company/paper-xlsx
+Author: See AUTHORS; Paper Instruments, Inc.
+Author-email: charlie.clark@clark-consulting.eu
+Maintainer: Paper Instruments, Inc.
+License: MIT
+Project-URL: Documentation, https://openpyxl.readthedocs.io/en/stable/
+Project-URL: Source, https://github.com/The-LLM-Data-Company/paper-xlsx
+Project-URL: Tracker, https://github.com/The-LLM-Data-Company/paper-xlsx/issues
+Project-URL: Upstream, https://foss.heptapod.net/openpyxl/openpyxl
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+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
+Requires-Python: >=3.8
+License-File: LICENCE.rst
+Requires-Dist: et_xmlfile
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+paper-xlsx
+==========
+
+``paper-xlsx`` is an agent-first Python library for safely inspecting and
+editing existing Excel (``.xlsx``) files. It is a strict-superset hard fork of
+``openpyxl`` 3.1.5 and a drop-in replacement. The distribution is renamed; the
+import name stays ``openpyxl``, so existing code keeps working unchanged.
+
+Why it exists
+-------------
+
+openpyxl is excellent at *creating* a workbook from scratch. The harder problem
+is changing a real workbook without dropping charts or leaving formulas pointed
+at the wrong cells. That is **silent corruption**: a file that opens fine and is
+quietly wrong, often with numbers that still look plausible.
+
+An agent cannot eyeball the result. It needs the workbook's structure and every
+edit outcome as typed, machine-readable data, and it needs the library to refuse
+rather than guess.
+
+Safety contract
+---------------
+
+Preserve mode applies the shared rule: every operation either does exactly what
+it claims or refuses atomically. ``load_workbook(path, preserve=True)`` keeps the
+original package bytes as the source of truth. Every session has one of three
+explicit outcomes:
+
+* a **correct save**: your edits are spliced into the original bytes, and
+  everything untouched survives byte-identical;
+* a **typed refusal**: an unsafe edit changes nothing on disk or in memory and
+  the exception names the remedy;
+* a **loud warning**: a stock-mode path reports that an operation may be lossy.
+
+``manifest``, ``model_map``, and ``locate`` expose workbook structure. Six
+pinned JSON schemas make their results available as structured data.
+
+Quick start
+-----------
+
+.. code-block:: python
+
+    from openpyxl import Workbook, load_workbook
+
+    # create a workbook with an input and a formula
+    wb = Workbook()
+    ws = wb.active
+    ws["A1"], ws["B1"] = "Growth rate", 0.05
+    ws["A2"], ws["B2"] = "Revenue", 1000
+    ws["B3"] = "=B2 * (1 + B1)"
+    wb.save("model.xlsx")
+
+    # reopen it in preserve mode: the original bytes are the source of truth
+    wb = load_workbook("model.xlsx", preserve=True)
+
+    wb.manifest().to_dict()             # what's in the file, what survives a save
+    wb.model_map().to_dict()            # inputs / calculations / outputs
+    wb.active.locate("Growth rate")     # find a value cell by its label
+
+    wb.set_input("Growth rate", 0.07)   # set an input; does not overwrite formulas
+    receipt = wb.save("model_v2.xlsx", receipt=True)
+    receipt.to_dict()["cells_changed"]  # {'xl/worksheets/sheet1.xml': {'B1': 'changed'}}
+
+Structural edits follow the same contract. ``ws.insert_rows(5)`` rewrites the
+formulas, defined names, and chart series that point into the shifted range and
+returns an ``AddressRemap``. If it cannot rewrite a reference safely, it refuses
+and lists every reference that would have broken.
+
+Computing values
+----------------
+
+``paper-xlsx`` does not implement formula calculation. When LibreOffice is
+installed, the library delegates calculation to it as the oracle:
+
+.. code-block:: python
+
+    import openpyxl.oracle as oracle
+
+    ev = wb.evaluate(set={"Sheet!B1": 0.10}, read=["Sheet!B3"])
+    ev.outputs                          # {'Sheet!B3': 1100}
+    ev.certification.status             # did LibreOffice reproduce the file's caches?
+    oracle.write_back("model.xlsx")     # write cached values after certification
+
+Six pinned JSON schemas (``workbook_manifest``, ``model_map``, ``evaluation``,
+``oracle_write_back``, ``edit_receipt``, ``workbook_diff``) make every result
+machine-consumable. The **Preserve mode** guide (``doc/paper.rst``) provides the
+complete API overview and refusal taxonomy.
+
+Preserve mode is opt-in today: pass ``preserve=True`` per call, or set
+``PAPER_PRESERVE_DEFAULT=1``. Preserve-by-default for the public/pandas API
+is release-gated.
+
+Drop-in and name map
+--------------------
+
+Only the distribution and repository are renamed. The importable package stays
+``openpyxl``. This is the same distribution/import split as Pillow
+(``pip install pillow``, ``import PIL``), and it preserves existing code,
+snippets, and model priors. Existing code that says ``import openpyxl`` keeps
+working unchanged, and every upstream feature is still available. Preserve mode
+and the new API are purely additive.
+
+* GitHub repository: ``paper-xlsx``
+* PyPI distribution: ``paper-xlsx``
+* Built wheel/sdist names: ``paper_xlsx-*``
+* Python import: ``openpyxl``
+* Fork sentinel: ``openpyxl.__paper_version__ = "0.1.0"``
+* Upstream base: openpyxl **3.1.5** (marker tag ``paper-base``)
+
+Upstream releases are merged (never rebased) on a roughly quarterly cadence, so
+drop-in compatibility with openpyxl holds over time.
+
+Installation
+------------
+
+This repository is private for now and publication to PyPI is gated. Install
+from Git::
+
+    pip install "paper-xlsx @ git+https://github.com/The-LLM-Data-Company/paper-xlsx.git@main"
+
+Verification
+------------
+
+::
+
+    python -c "import openpyxl; print(openpyxl.__paper_version__)"
+
+Expected output::
+
+    0.1.0
+
+How it's tested
+---------------
+
+* Upstream openpyxl's test suite runs on every change to check compatibility
+  with existing behavior.
+* A frozen, hash-pinned fixture corpus under ``tests/paper`` includes real
+  third-party files with provenance labels, rather than only self-generated
+  fixtures.
+* The contract harness saves and reopens before asserting, enforces an exact
+  changed-part budget and refusal atomicity, and runs a headless LibreOffice
+  load smoke.
+
+License
+-------
+
+MIT, inherited from openpyxl. Original work © the openpyxl authors; fork
+additions © Paper Instruments, Inc. The fork preserves the upstream license and
+attribution. See ``LICENCE.rst``.

paper_xlsx-0.1.0/README.rst

@@ -0,0 +1,149 @@
+paper-xlsx
+==========
+
+``paper-xlsx`` is an agent-first Python library for safely inspecting and
+editing existing Excel (``.xlsx``) files. It is a strict-superset hard fork of
+``openpyxl`` 3.1.5 and a drop-in replacement. The distribution is renamed; the
+import name stays ``openpyxl``, so existing code keeps working unchanged.
+
+Why it exists
+-------------
+
+openpyxl is excellent at *creating* a workbook from scratch. The harder problem
+is changing a real workbook without dropping charts or leaving formulas pointed
+at the wrong cells. That is **silent corruption**: a file that opens fine and is
+quietly wrong, often with numbers that still look plausible.
+
+An agent cannot eyeball the result. It needs the workbook's structure and every
+edit outcome as typed, machine-readable data, and it needs the library to refuse
+rather than guess.
+
+Safety contract
+---------------
+
+Preserve mode applies the shared rule: every operation either does exactly what
+it claims or refuses atomically. ``load_workbook(path, preserve=True)`` keeps the
+original package bytes as the source of truth. Every session has one of three
+explicit outcomes:
+
+* a **correct save**: your edits are spliced into the original bytes, and
+  everything untouched survives byte-identical;
+* a **typed refusal**: an unsafe edit changes nothing on disk or in memory and
+  the exception names the remedy;
+* a **loud warning**: a stock-mode path reports that an operation may be lossy.
+
+``manifest``, ``model_map``, and ``locate`` expose workbook structure. Six
+pinned JSON schemas make their results available as structured data.
+
+Quick start
+-----------
+
+.. code-block:: python
+
+    from openpyxl import Workbook, load_workbook
+
+    # create a workbook with an input and a formula
+    wb = Workbook()
+    ws = wb.active
+    ws["A1"], ws["B1"] = "Growth rate", 0.05
+    ws["A2"], ws["B2"] = "Revenue", 1000
+    ws["B3"] = "=B2 * (1 + B1)"
+    wb.save("model.xlsx")
+
+    # reopen it in preserve mode: the original bytes are the source of truth
+    wb = load_workbook("model.xlsx", preserve=True)
+
+    wb.manifest().to_dict()             # what's in the file, what survives a save
+    wb.model_map().to_dict()            # inputs / calculations / outputs
+    wb.active.locate("Growth rate")     # find a value cell by its label
+
+    wb.set_input("Growth rate", 0.07)   # set an input; does not overwrite formulas
+    receipt = wb.save("model_v2.xlsx", receipt=True)
+    receipt.to_dict()["cells_changed"]  # {'xl/worksheets/sheet1.xml': {'B1': 'changed'}}
+
+Structural edits follow the same contract. ``ws.insert_rows(5)`` rewrites the
+formulas, defined names, and chart series that point into the shifted range and
+returns an ``AddressRemap``. If it cannot rewrite a reference safely, it refuses
+and lists every reference that would have broken.
+
+Computing values
+----------------
+
+``paper-xlsx`` does not implement formula calculation. When LibreOffice is
+installed, the library delegates calculation to it as the oracle:
+
+.. code-block:: python
+
+    import openpyxl.oracle as oracle
+
+    ev = wb.evaluate(set={"Sheet!B1": 0.10}, read=["Sheet!B3"])
+    ev.outputs                          # {'Sheet!B3': 1100}
+    ev.certification.status             # did LibreOffice reproduce the file's caches?
+    oracle.write_back("model.xlsx")     # write cached values after certification
+
+Six pinned JSON schemas (``workbook_manifest``, ``model_map``, ``evaluation``,
+``oracle_write_back``, ``edit_receipt``, ``workbook_diff``) make every result
+machine-consumable. The **Preserve mode** guide (``doc/paper.rst``) provides the
+complete API overview and refusal taxonomy.
+
+Preserve mode is opt-in today: pass ``preserve=True`` per call, or set
+``PAPER_PRESERVE_DEFAULT=1``. Preserve-by-default for the public/pandas API
+is release-gated.
+
+Drop-in and name map
+--------------------
+
+Only the distribution and repository are renamed. The importable package stays
+``openpyxl``. This is the same distribution/import split as Pillow
+(``pip install pillow``, ``import PIL``), and it preserves existing code,
+snippets, and model priors. Existing code that says ``import openpyxl`` keeps
+working unchanged, and every upstream feature is still available. Preserve mode
+and the new API are purely additive.
+
+* GitHub repository: ``paper-xlsx``
+* PyPI distribution: ``paper-xlsx``
+* Built wheel/sdist names: ``paper_xlsx-*``
+* Python import: ``openpyxl``
+* Fork sentinel: ``openpyxl.__paper_version__ = "0.1.0"``
+* Upstream base: openpyxl **3.1.5** (marker tag ``paper-base``)
+
+Upstream releases are merged (never rebased) on a roughly quarterly cadence, so
+drop-in compatibility with openpyxl holds over time.
+
+Installation
+------------
+
+This repository is private for now and publication to PyPI is gated. Install
+from Git::
+
+    pip install "paper-xlsx @ git+https://github.com/The-LLM-Data-Company/paper-xlsx.git@main"
+
+Verification
+------------
+
+::
+
+    python -c "import openpyxl; print(openpyxl.__paper_version__)"
+
+Expected output::
+
+    0.1.0
+
+How it's tested
+---------------
+
+* Upstream openpyxl's test suite runs on every change to check compatibility
+  with existing behavior.
+* A frozen, hash-pinned fixture corpus under ``tests/paper`` includes real
+  third-party files with provenance labels, rather than only self-generated
+  fixtures.
+* The contract harness saves and reopens before asserting, enforces an exact
+  changed-part budget and refusal atomicity, and runs a headless LibreOffice
+  load smoke.
+
+License
+-------
+
+MIT, inherited from openpyxl. Original work © the openpyxl authors; fork
+additions © Paper Instruments, Inc. The fork preserves the upstream license and
+attribution. See ``LICENCE.rst``.

paper_xlsx-0.1.0/openpyxl/__init__.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2010-2024 openpyxl
+
+"""paper-xlsx — Paper Instruments' hard fork of openpyxl for LOSSLESS,
+SAFE editing of existing Excel files.
+
+The import name stays ``openpyxl`` so existing code is unchanged. The
+fork adds a **preserve mode**: ``load_workbook(path, preserve=True)``
+keeps the original package bytes as the source of truth, so saving
+splices your edits back in without destroying the charts, pivots, VBA,
+or formatting a normal openpyxl round-trip drops — and any edit it
+cannot make safely refuses loudly (a typed :mod:`openpyxl.errors`
+exception) instead of corrupting the file.
+
+Start here: :attr:`openpyxl.__paper_version__` (fork sentinel), and the
+:mod:`openpyxl.preserve`, :mod:`openpyxl.oracle` and
+:mod:`openpyxl.errors` modules. The project README and ``doc/paper.rst``
+give the full tour.
+"""
+
+DEBUG = False
+
+from openpyxl.compat.numbers import NUMPY
+from openpyxl.xml import DEFUSEDXML, LXML
+from openpyxl.workbook import Workbook
+from openpyxl.reader.excel import load_workbook as open
+from openpyxl.reader.excel import load_workbook
+import openpyxl._constants as constants
+
+# Expose constants especially the version number
+
+__author__ = constants.__author__
+__author_email__ = constants.__author_email__
+__license__ = constants.__license__
+__maintainer_email__ = constants.__maintainer_email__
+__url__ = constants.__url__
+__version__ = constants.__version__
+__paper_version__ = "0.1.0"

paper_xlsx-0.1.0/openpyxl/_constants.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2010-2024 openpyxl
+
+"""
+Package metadata
+"""
+
+__author__ = "See AUTHORS"
+__author_email__ = "charlie.clark@clark-consulting.eu"
+__license__ = "MIT"
+__maintainer_email__ = "openpyxl-users@googlegroups.com"
+__url__ = "https://github.com/The-LLM-Data-Company/paper-xlsx"
+__version__ = "3.1.5"
+__python__ = "3.8"

paper_xlsx-0.1.0/openpyxl/cell/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from .cell import Cell, WriteOnlyCell, MergedCell
+from .read_only import ReadOnlyCell

paper_xlsx-0.1.0/openpyxl/cell/_writer.py

@@ -0,0 +1,136 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.compat import safe_string
+from openpyxl.xml.functions import Element, SubElement, whitespace, XML_NS
+from openpyxl import LXML
+from openpyxl.utils.datetime import to_excel, to_ISO8601
+from datetime import timedelta
+
+from openpyxl.worksheet.formula import DataTableFormula, ArrayFormula
+from openpyxl.cell.rich_text import CellRichText
+
+def _set_attributes(cell, styled=None):
+    """
+    Set coordinate and datatype
+    """
+    coordinate = cell.coordinate
+    attrs = {'r': coordinate}
+    if styled:
+        attrs['s'] = f"{cell.style_id}"
+
+    if cell.data_type == "s":
+        attrs['t'] = "inlineStr"
+    elif cell.data_type != 'f':
+        attrs['t'] = cell.data_type
+
+    value = cell._value
+
+    if cell.data_type == "d":
+        if hasattr(value, "tzinfo") and value.tzinfo is not None:
+            raise TypeError("Excel does not support timezones in datetimes. "
+                    "The tzinfo in the datetime/time object must be set to None.")
+
+        if cell.parent.parent.iso_dates and not isinstance(value, timedelta):
+            value = to_ISO8601(value)
+        else:
+            attrs['t'] = "n"
+            value = to_excel(value, cell.parent.parent.epoch)
+
+    if cell.hyperlink:
+        cell.parent._hyperlinks.append(cell.hyperlink)
+
+    return value, attrs
+
+
+def etree_write_cell(xf, worksheet, cell, styled=None):
+
+    value, attributes = _set_attributes(cell, styled)
+
+    el = Element("c", attributes)
+    if value is None or value == "":
+        xf.write(el)
+        return
+
+    if cell.data_type == 'f':
+        attrib = {}
+
+        if isinstance(value, ArrayFormula):
+            attrib = dict(value)
+            value = value.text
+
+        elif isinstance(value, DataTableFormula):
+            attrib = dict(value)
+            value = None
+
+        formula = SubElement(el, 'f', attrib)
+        if value is not None and not attrib.get('t') == "dataTable":
+            formula.text = value[1:]
+            value = None
+
+    if cell.data_type == 's':
+        if isinstance(value, CellRichText):
+            el.append(value.to_tree())
+        else:
+            inline_string = Element("is")
+            text = Element('t')
+            text.text = value
+            whitespace(text)
+            inline_string.append(text)
+            el.append(inline_string)
+
+    else:
+        cell_content = SubElement(el, 'v')
+        if value is not None:
+            cell_content.text = safe_string(value)
+
+    xf.write(el)
+
+
+def lxml_write_cell(xf, worksheet, cell, styled=False):
+    value, attributes = _set_attributes(cell, styled)
+
+    if value == '' or value is None:
+        with xf.element("c", attributes):
+            return
+
+    with xf.element('c', attributes):
+        if cell.data_type == 'f':
+            attrib = {}
+
+            if isinstance(value, ArrayFormula):
+                attrib = dict(value)
+                value = value.text
+
+            elif isinstance(value, DataTableFormula):
+                attrib = dict(value)
+                value = None
+
+            with xf.element('f', attrib):
+                if value is not None and not attrib.get('t') == "dataTable":
+                    xf.write(value[1:])
+                    value = None
+
+        if cell.data_type == 's':
+            if isinstance(value, CellRichText):
+                el = value.to_tree()
+                xf.write(el)
+            else:
+                with xf.element("is"):
+                    if isinstance(value, str):
+                        attrs = {}
+                        if value != value.strip():
+                            attrs["{%s}space" % XML_NS] = "preserve"
+                        el = Element("t", attrs) # lxml can't handle xml-ns
+                        el.text = value
+                        xf.write(el)
+
+        else:
+            with xf.element("v"):
+                if value is not None:
+                    xf.write(safe_string(value))
+
+
+if LXML:
+    write_cell = lxml_write_cell
+else:
+    write_cell = etree_write_cell