fancy-holy-sheet 0.1.0__tar.gz

fancy_holy_sheet-0.1.0/.gitattributes

@@ -0,0 +1,23 @@
+# Line endings are part of the contract here, so they are pinned rather than
+# left to a clone's `core.autocrlf`.
+#
+# Two reasons, both concrete:
+#
+#  1. The writers are string builders and the OOXML they emit is compared
+#     byte-for-byte against the PHP reference. A source file checked out with
+#     CRLF changes the bytes of any multi-line literal in it.
+#  2. `holy-sheet`'s tool-definition JSON is pinned by a cross-repo SHA-256
+#     that is taken over CRLF-NORMALISED text. A Windows checkout hashes
+#     differently from the same file on Linux, which reads as a drifted schema
+#     when nothing has drifted at all. It has already cost one investigation.
+#
+# The markdown fixtures matter for the same reason: `last-word`'s markdown
+# bridge is asserted byte-exact with LF newlines.
+* text=auto eol=lf
+
+*.docx binary
+*.xlsx binary
+*.pptx binary
+*.png  binary
+*.jpg  binary
+*.jpeg binary

fancy_holy_sheet-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+# Least-privilege: CI only reads the repo.
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      # Third-party dependency allowlist. Cheap, and failing here is cheap --
+      # the same check gates the release, so a PR that adds an unapproved or
+      # abandoned dependency finds out now rather than at tag time.
+      # The allowlist is FETCHED, never vendored: one source, no copies to drift.
+      - name: Fetch the third-party allowlist
+        uses: actions/checkout@v4
+        with:
+          repository: Particle-Academy/.github
+          path: .third-party-allowlist
+          persist-credentials: false
+
+      - name: Third-party dependency allowlist
+        run: |
+          node .third-party-allowlist/third-party/check.mjs --repo .
+          # Delete it. A fetched checkout left lying in the workspace is not
+          # inert: vitest globbed the checker's own tests out of it and failed
+          # a package whose code was fine. Removed with node, not rm -rf,
+          # because some of these matrices run on windows-latest where a
+          # multi-line run: block is PowerShell and rm -rf is not a command.
+          node -e "require('node:fs').rmSync('.third-party-allowlist',{recursive:true,force:true})"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      # PHP is REQUIRED, not optional. tests/test_parity_php.py is the
+      # cross-runtime writer guarantee and it FAILS when php is absent rather
+      # than skipping - a skip here is a green build with zero parity coverage,
+      # which is exactly how two suites in this org reported success over
+      # nothing for months.
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.4"
+          coverage: none
+          extensions: mbstring, zip
+
+      - name: Check out the PHP holy-sheet
+        uses: actions/checkout@v4
+        with:
+          repository: Particle-Academy/holy-sheet
+          path: .php-holy-sheet
+
+      - name: Check out fancy-conformance
+        uses: actions/checkout@v4
+        with:
+          repository: Particle-Academy/fancy-conformance
+          path: .fancy-conformance
+
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Test
+        run: python -m pytest
+        env:
+          HOLY_SHEET_PHP_SRC: ${{ github.workspace }}/.php-holy-sheet/src
+          FANCY_CONFORMANCE_ROOT: ${{ github.workspace }}/.fancy-conformance

fancy_holy_sheet-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,87 @@
+name: Publish
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions: {}
+
+jobs:
+  # Build and publish are separate jobs so `id-token: write` is never held by
+  # the job that executes build code.
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      # The one documentation failure that cannot be repaired later: once the
+      # sdist is on PyPI, whoever upgraded into it has no way to learn what
+      # changed. Checked before anything is built.
+      - name: Require a CHANGELOG entry for this tag
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          grep -q "^## \[${version}\]" CHANGELOG.md || {
+            echo "No CHANGELOG.md entry for ${version}."
+            exit 1
+          }
+
+      # Release gate: third-party dependencies must be approved and still
+      # maintained BEFORE the tarball reaches the registry. Once it is
+      # published, an unapproved or abandoned dependency has already shipped
+      # to everyone who upgrades -- the same reason the changelog gate sits
+      # here. The allowlist is FETCHED, never vendored: one source of truth,
+      # so there is no per-repo copy that can drift out of agreement with it.
+      - name: Fetch the third-party allowlist
+        uses: actions/checkout@v4
+        with:
+          repository: Particle-Academy/.github
+          path: .third-party-allowlist
+          persist-credentials: false
+
+      - name: Third-party dependency allowlist
+        run: |
+          node .third-party-allowlist/third-party/check.mjs --repo .
+          # Delete it. A fetched checkout left lying in the workspace is not
+          # inert: vitest globbed the checker's own tests out of it and failed
+          # a package whose code was fine. Removed with node, not rm -rf,
+          # because some of these matrices run on windows-latest where a
+          # multi-line run: block is PowerShell and rm -rf is not a command.
+          node -e "require('node:fs').rmSync('.third-party-allowlist',{recursive:true,force:true})"
+
+      - name: Require the version to match the tag
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          grep -q "^version = \"${version}\"$" pyproject.toml || {
+            echo "pyproject.toml version does not match tag ${GITHUB_REF_NAME}."
+            exit 1
+          }
+
+      - run: python -m pip install --upgrade build && python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dists
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/fancy-flow
+    permissions:
+      id-token: write        # mandatory for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dists
+          path: dist/
+      # Pinned by SHA, not by tag: a mutable reference in exactly this position
+      # is what the April 2026 supply-chain compromises exploited.
+      # v1.14.2 -- no `password:` (that is the point) and attestations default
+      # to true.
+      - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33

fancy_holy_sheet-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+build/
+dist/
+*.egg-info/
+.venv/
+venv/
+.coverage
+htmlcov/
+.DS_Store

fancy_holy_sheet-0.1.0/AGENTS.md

@@ -0,0 +1,239 @@
+# AGENTS.md — holy-sheet (Python)
+
+This file describes **this repo's code**: its API, its invariants, and the traps
+that will cost you a day. Process rules — publishing, versioning, backports,
+support lifecycle — live in the envelope's `AGENTS.md` and are deliberately not
+repeated here.
+
+## What this is
+
+A zero-dependency `.xlsx` writer, reader and formula linter. The **third**
+implementation of one contract:
+
+| | |
+|---|---|
+| `particle-academy/holy-sheet` (PHP) | the reference — shipped first, most complete |
+| `@particle-academy/holy-sheet` (Node) | the container/API model — bytes-in/bytes-out, no host |
+| `holy-sheet` (this) | Python |
+
+**PHP is normative for SEMANTICS. Node is normative for STRUCTURE.** That split
+is why the module layout mirrors the Node port's directories while every
+behavioural decision follows PHP's.
+
+### Python never casts a deciding vote
+
+Where PHP and Node already disagree, **this port follows PHP**. Not because PHP
+is better, but because the disagreements are documented in
+`.ai/plans/polyglot/parity/documents.md` with a ruling attached, and a third
+engine picking its own answer turns a two-way drift into a permanent three-way
+split. Following PHP keeps the tally 2–1 in the direction already decided.
+
+Where PHP has a feature Node lacks, this implements PHP's. Two of those:
+
+- **`=`-promotion** — a bare string cell beginning with `=` is a formula.
+- **Bare scalar `cells` entries** — `{"A1": 42}` as well as `{"A1": {"value": 42}}`.
+
+Node is a minor behind on both.
+
+## The API shape
+
+Module-level snake_case functions, mirroring PHP's static `Agent` and TS's
+`Agent` object: `validate`, `validate_and_repair`, `to_bytes`, `write`, `read`,
+`describe`, `lint`, `from_array`, `from_csv`, `tool_definition`, `version`.
+Lower-level classes keep their peer names (`Validator`, `Normalizer`,
+`XlsxWriter`, `XlsxReader`, `CellAddress`, …) so a reader moving between the
+three repos recognises them.
+
+**The input schema is a plain `dict` and must stay one.** The declarative
+one-shot schema is the product: an agent emits the whole workbook in a single
+JSON object, and the *Validator* is the gate. A dataclass would move the gate
+into a constructor and reject exactly the loose input `validate_and_repair`
+exists to fix. `schema/types.py` holds `TypedDict`s (`total=False`) for editor
+support only — never construct from them.
+
+The internal `Workbook` / `Sheet` / `Cell` / `CellFormat` objects the Normalizer
+produces ARE real classes. They are internal, like their peers.
+
+Three shape differences from a peer, each deliberate and each pinned by a test:
+
+- `write()` is **synchronous** (PHP's is; Node's is async only for browsers).
+- `from_csv()` accepts a **path or content** (PHP's superset; Node takes content).
+- `read()` takes **bytes**, `describe()` takes a **path** (Node's split).
+
+## Byte parity with PHP is the definition of done
+
+`tests/test_parity_php.py` runs the PHP writer as a subprocess and asserts this
+port emits **byte-identical OOXML parts** for every fixture. `KNOWN_DIVERGENT_PARTS`
+is empty and the ledger ratchets both ways — a new divergence fails, and a stale
+entry fails too.
+
+**Never byte-compare the container.** PHP writes through `ZipArchive` (DEFLATE,
+real mtimes); this writes a fixed 1980-01-01 DOS date. Those files can never
+match, and a reader sees parts, never the compression.
+
+### Therefore: the XML is a string builder, and must stay one
+
+Attribute order (`<c r="A1" s="3" t="inlineStr">`, in that order), self-closing
+style (`<c r="A1"/>` for a null cell, but `<xf …></xf>` always as a pair), the
+absence of inter-element whitespace, and `&apos;` rather than `&#39;` are all
+part of the contract. A DOM serialiser owns every one of those decisions and
+would fail the first fixture.
+
+`xml.etree` is used for **reading** and never for writing. That is the correct
+division: nothing is serialised on the read side.
+
+`helpers/xml.py` has two escapers and the difference is intentional:
+`xml_escape` strips XML-illegal control characters first; `xml_escape_raw` does
+not. The reference engine's `StylesRegistry` calls bare `htmlspecialchars` where
+its writer calls its own `escape()`, so number-format codes and font names skip
+the strip. Mirrored, not tidied — tidying it would change bytes both shipped
+engines currently agree on.
+
+## Numbers: the section to read before touching the writer
+
+This is where every cross-runtime bug in this family has lived. Five real
+PHP↔JS divergences shipped in the Node port, all of them here.
+
+Everything numeric goes through `helpers/php.py`. **Do not reach for a builtin.**
+
+### `bool` is a subclass of `int`
+
+`isinstance(True, int)` is `True` and `True == 1`. Any branch that tests `int`
+before `bool` writes a boolean into a numeric cell — `<v>1</v>` with no `t="b"`,
+a sheet showing 1 where the author wrote TRUE, and no error anywhere. **Check
+`bool` first, every time you branch on type.** The places that matter:
+`Cell.excel_type`, `XlsxWriter.cell_xml`, `php.type_of`, `php.php_to_string`,
+`Inference._all_numeric`, `Inference._all_integer`, the linter's coercions.
+
+### `round()` is banker's rounding
+
+`round(0.5) == 0` and `round(2.5) == 2`. PHP's is half away from zero. Use
+`php_round`; the builtin is never called anywhere in this package. It matters in
+the reader's column-width inverse and in the linter's `ROUND()`.
+
+At a non-zero precision `php_round` quantises the **shortest repr**, so
+`php_round(1.2345, 3)` is 1.235 — PHP's answer, and the one a caller writing
+"1.2345" means. (The exact double is 1.23449999999999993.)
+
+### `f"{v:.14f}"` rounds half to EVEN
+
+That is the `<v>` serialisation of every float cell. PHP's `number_format` rounds
+half **away from zero**, and the two disagree on any double whose decimal
+expansion terminates in a 5 at the 15th place — `j / 2**15` with odd `j`. Use
+`php_number_format`. Two such values live in the `numericHazards` parity fixture
+so a half-even formatter fails the build rather than shipping.
+
+**Known, deliberate deviation:** PHP reaches its answer through a floating-point
+*pre-rounding* step whose result changed between PHP 8.3 and 8.4 (8.4 dropped the
+`>= 1e15` bail-out, so `number_format(32.666666666666664, 14)` now disagrees with
+`sprintf('%.14F', …)` of the same double). Reproducing that would make this
+package's output a function of whichever PHP the maintainer built against, which
+is parity with nothing. `php_number_format` implements the **rule** — round the
+exact binary expansion, half away from zero, suppress the sign on a zero result
+— and the two agree everywhere except the 15th significant digit of values below
+10. The oracle proves it part-for-part on every fixture. If you change this,
+re-run the parity suite; it is the only thing that can tell you.
+
+### Only ever trim a fraction, never an exponent
+
+`format_float` = `number_format(v, 14)` then strip trailing zeros then a trailing
+dot. The Node port trimmed unconditionally, and because `toFixed` goes
+exponential at 1e21 the strip chewed the **exponent**: 1e300 was written to the
+sheet as `1e3`. Python's `format` never goes exponential for `f`, so the hazard
+is absent — the rule is written down because the next port will be offered a
+formatter that does.
+
+### Numeric-string coercion is PHP's, not Python's
+
+`float()` accepts `"inf"`, `"nan"`, `"1_000"` and `"0x1A"`-adjacent forms that
+PHP's `is_numeric` rejects. Always guard with `is_numeric_string` before
+`numeric_string_to_number`. And the coercion returns `int` for an
+integer-shaped string inside zend_long's range and `float` otherwise — it does
+**not** clamp, which is what `(int)` did and how `"1e21"` became
+9223372036854775807.
+
+### Python ints are unbounded; PHP's are 64-bit
+
+An `int` outside `[-2**63, 2**63)` is written through the float formatter,
+because that is what PHP's `json_decode` would have produced for the same
+literal. Losing the extra precision is the point: it is what makes the document
+the same on both backends.
+
+### Non-finite values
+
+NaN and ±Infinity have no `<v>` representation — "NaN" in a cell is a corrupt
+sheet, not a big number. Both engines write `0`.
+
+## Other invariants
+
+**Cells within a row are ordered LEXICOGRAPHICALLY on the column letter**, so a
+sheet wider than 26 columns emits `A, AA, AB, AC, AD, B, C, …`. That matches
+neither Excel's canonical order nor intuition, and **both shipped engines do it**
+(`ksort` on a string key in PHP, `[...keys].sort()` in Node). It is replicated on
+purpose and pinned by the `wide` fixture. Fixing it changes the bytes of every
+wide sheet in every engine simultaneously, so it belongs in a coordinated release
+train — not in a port. Do not "fix" it here.
+
+**`cells` is document-ordered.** Python dicts are insertion-ordered, so the
+contract the Node port needed a deliberate structure for is free here — but it is
+still a contract. `Sheet.comments()` and the comment/VML part numbering read it.
+
+**The zip is deterministic.** Fixed part order, fixed `date_time=(1980, 1, 1, 0,
+0, 0)`. Without it the container is a clock, the same input produces different
+bytes every run, and a golden fixture is impossible.
+
+**Sheet XML is rendered before `styles.xml` is serialised.** Every format has to
+register first. Swapping those two lines in `XlsxWriter.to_bytes` produces a
+styles part missing every style the sheets reference.
+
+**Reading rejects a DOCTYPE before parsing.** An xlsx never legitimately carries
+one, and an internal DTD subset is the entry point for entity expansion on
+untrusted input. Refusing the construct is cheaper than depending on what a
+parser does with it today. See `reader/xml.py`.
+
+**Dates parse in UTC, from an explicit grammar.** Not `datetime.fromisoformat`,
+whose accepted set changed in Python 3.11 — that would make a cell's serial
+depend on the interpreter. Not PHP's `DateTimeImmutable` grammar either, which
+accepts `"next monday"` and is unportable. Unparseable input yields serial 0.0,
+matching the reference's failure path. The epoch anchor is 1899-12-30, which
+cancels Excel's 1900-leap-year bug for every date from 1900-03-01.
+
+**`tool_definition()` raises when the schema file is missing.** PHP returns an
+empty array; that is the worse failure, because an empty tool definition produces
+no error anywhere — just a model told nothing about the tool it is holding. The
+file is byte-identical across all three repos and each pins its SHA-256 over
+CRLF-normalised content (`tests/test_schema_sync.py`). Edit one copy, edit all
+three, update all three constants.
+
+**Linter hint strings are byte-compared against PHP.** They contain em dashes
+(`Division by zero — the divisor evaluated to 0.`). A hyphen there is a parity
+failure.
+
+## Deliberately out of scope
+
+Three things the PHP package has that neither port implements, and that a
+contributor will otherwise assume were forgotten:
+
+- `Laravel/` — the service provider, facade, artisan command and query adapter.
+- `Toolkit/` — the prompt/tool/schema-store layer.
+- `Schema/Dumper` + `DumpOptions` — `dumpJson()`, the cell-level content dump.
+
+The Node port omits all three too. `Dumper` is the one with a real case for
+being ported; it is the read-tool counterpart to `describe()` and it is what
+lets an agent make targeted cell edits.
+
+## Testing
+
+`python -m pytest`. **Write the test first**; a bug fix lands with a test that
+fails against the old code, and you verify that it does.
+
+The parity oracle needs `php` on `PATH` (or `PHP_BIN` pointing at a real
+interpreter — on Windows `php` is usually a `.bat` shim, which a bare `exec`
+cannot spawn) and the PHP sources beside this checkout (or `HOLY_SHEET_PHP_SRC`).
+Locally a missing toolchain skips those tests and says so; **under `CI` it
+raises**, because a suite that quietly stops comparing anything reads exactly
+like one that compares everything.
+
+Do not weaken `tests/_oracle.py`, `tests/test_parity_php.py` or
+`tests/test_determinism.py`. They are the reason this is a port rather than a
+rewrite.

fancy_holy_sheet-0.1.0/CHANGELOG.md

@@ -0,0 +1,86 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+**Pre-1.0: breaking changes land in MINOR releases.** Until `1.0.0`, a bump from
+`0.1.x` to `0.2.0` may change or remove API. Pin accordingly, and read the entry
+before upgrading — every breaking change here says what you have to DO, not just
+what moved.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-08-18
+
+First release. The Python mirror of PHP `particle-academy/holy-sheet` 1.3.0 and
+Node `@particle-academy/holy-sheet`.
+
+### Added
+
+- **The Agent surface**, as module-level snake_case functions: `validate`,
+  `validate_and_repair`, `to_bytes`, `write`, `read`, `describe`,
+  `tool_definition`, `from_array`, `from_csv`, `lint`, `version`. No class to
+  instantiate and no DI container — `import holy_sheet` is the whole setup.
+- **The declarative workbook schema**, taken as a plain `dict`. Row-oriented
+  (`columns` + `rows`) and sparse (`cells`) sheets, four themes, symbolic totals,
+  merged regions, column widths, frozen panes, comments, formulas with cached
+  values, and per-cell or per-column formatting.
+- **`XlsxWriter`** — a complete OOXML package with deduplicated
+  fonts/fills/borders/numFmts. Output is deterministic: fixed part order, fixed
+  1980-01-01 zip timestamps, the same bytes for the same input every time.
+- **`XlsxReader`** — `read(bytes)` and `describe(path)` round-trip an xlsx back
+  to a schema that can be written again unchanged. Handles shared strings, which
+  this writer never emits but Excel always does.
+- **`FormulaLinter`** — evaluates every formula and reports `#VALUE!`, `#REF!`,
+  `#NAME?`, `#DIV/0!` and `#CIRC!` with an actionable hint, including the
+  header-row off-by-one ("Did you mean B2? (it holds 12000)").
+- **`Validator` + `Repairer`** — structured errors, and conservative repairs for
+  the unambiguous mistakes agents make (`sheet` for `sheets`, `row` for `rows`,
+  integer-keyed rows objects, stringified numerics, unknown themes, whitespace in
+  A1 addresses, and an omitted date column type).
+- **`from_array` / `from_csv`** with header-plus-sample type inference.
+  `from_csv` accepts a path as well as content, following PHP.
+- **`tool_definition()`**, returning the JSON Schema that is byte-identical
+  across all three engines. It **raises** when the file is missing rather than
+  returning an empty dict — an empty tool definition hands a model no hints and
+  produces no error anywhere.
+- **Cross-runtime parity as a test result.** `tests/test_parity_php.py` drives
+  the PHP writer as a subprocess and asserts byte-identical OOXML parts for every
+  fixture; `tests/test_reader_parity_php.py` asserts a PHP-written file describes
+  identically to a Python-written one. Both FAIL under `CI` when PHP is absent
+  rather than skipping.
+- **`helpers/php.py`** — PHP's numeric and string semantics written down once:
+  `is_numeric_string`, `numeric_string_to_number`, `php_round`,
+  `php_number_format`, `format_float`, `php_to_string`, `type_of`. Every
+  numeric decision in the package routes through it, and the Python builtins it
+  replaces (`round`, `float`, `f"{v:.14f}"`, `str`) are never called on a value
+  that reaches a cell.
+
+### Notes for anyone porting or reviewing this
+
+- **`bool` is a subclass of `int` in Python**, so every type branch checks `bool`
+  first. A branch that does not writes `<v>1</v>` with no `t="b"` — a sheet
+  showing 1 where the author wrote TRUE, with no error anywhere.
+- **`round()` is banker's rounding and `f"{v:.14f}"` rounds half to even.** PHP
+  does both half away from zero. The `numericHazards` fixture carries two exact
+  ties at the 14th decimal so a half-even formatter fails the build.
+- **Cells within a row are ordered lexicographically on the column letter**, so a
+  sheet wider than 26 columns emits `A, AA, AB, …, B, C`. This is a shared wart
+  that both existing engines have; it is replicated on purpose and pinned by the
+  `wide` fixture, because changing it changes the bytes of every wide sheet in
+  every engine at once.
+- **The XML is built by string concatenation, and must stay that way.** Attribute
+  order, self-closing style and `&apos;`-vs-`&#39;` are the cross-runtime
+  contract. `xml.etree` reads; it never writes.
+- **`number_format` implements the rule, not PHP's floating-point artefact.** PHP
+  reaches its answer via a pre-rounding step whose result changed between 8.3 and
+  8.4; reproducing it would tie this package's output to the maintainer's PHP
+  build. The two agree everywhere except the 15th significant digit of values
+  below 10, and the parity oracle proves it part-for-part.
+- **Not ported, deliberately** (the Node port omits them too): PHP's `Laravel/`
+  bridge, `Toolkit/`, and `Schema/Dumper` + `DumpOptions` (`dumpJson`).
+
+[Unreleased]: https://github.com/Particle-Academy/holy-sheet-py/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/Particle-Academy/holy-sheet-py/releases/tag/v0.1.0

fancy_holy_sheet-0.1.0/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

fancy_holy_sheet-0.1.0/LICENSE

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