gedcomkit 0.1.4__tar.gz → 0.1.6__tar.gz

gedcomkit-0.1.6/CHANGELOG.md

@@ -0,0 +1,175 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. The
+format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
+the project uses semantic versioning within the usual pre-1.0 compatibility
+rules.
+
+## [0.1.6] - 2026-09-25
+
+### Added
+
+- `build`, for a producer writing its own data as GEDCOM rather than
+  reading a file. `build::NodeSpec` describes a structure (tag, optional
+  identifier and payload, substructures) and `NodeSpec::into_node` checks
+  it under `Limits`, refusing with an error what `Node::new` would panic on;
+  with the `serde` feature it deserializes, refusing unknown keys.
+  `Document::append_records` adds records before the trailer, all or none,
+  refusing a repeated identifier or a second header or trailer, and
+  `Document::append_structures` adds substructures to any record or the
+  header (which 5.5.1 wants a `SUBM` pointer in, and `new_v551` cannot
+  supply), leaving every existing line as it was.
+- `Document::wrap_long_lines`, which fits a 5.5.1 document to a line limit
+  by splitting payloads across `CONC` lines — at character boundaries, and
+  not beside a space where the text allows — and names every structure it
+  rewrote. Lines that fit are untouched; a version 7 document is refused.
+- `dates::GedcomDate::to_gedcom_5_5_1`, the reading written in 5.5.1's own
+  date grammar (`about 5 January 1882` → `ABT 5 JAN 1882`), or `None` when
+  that grammar cannot hold it without loss. A dual year it can spell
+  (`1740/41`) is kept; a slashed pair it cannot makes an exact date an `INT`
+  date carrying the original as its phrase.
+- Python and JavaScript/WASM bindings: `Gedcom.new_v551` / `newV551`,
+  `new_v7` / `newV7`, `append_records` / `appendRecords` (records as plain
+  dicts/objects), `append_structures` / `appendStructures`, `wrap_long_lines` / `wrapLongLines`, and
+  `parse_date` / `parseDate`, a date reading with its `display` and
+  `gedcom551` renderings.
+- Python only: `ArchiveFileWriter`, a GEDZIP writer whose sink is a file,
+  with `add_file` streaming an entry from disk without the bytes passing
+  through Python — so a multi-gigabyte archive no longer has to fit in
+  memory twice. And type stubs (`gedcomkit.pyi`), so the package is typed
+  for mypy and pyright.
+
+### Fixed
+
+- The date reader accepts 5.5.1's `B.C.` epoch as well as 7.0's `BCE`.
+- The date reader matched its keywords by ASCII case only, so `après 12
+  juillet 1670` and `før 1679` went unread although both words were in its
+  tables. Keywords now compare case in every script, and may run straight
+  into the date (`abt1810`, `c1700`).
+- `April 9, 1950` read its `9` as September and failed; a month written as a
+  word now decides the order. `10 January 1566/67`, a dual year ending a full
+  date, now reads as 1566 as the bare `1566/67` already did.
+- More spellings: `vers`, `cir`, `c.`, `around`, `probably`, `omtrent`,
+  `cirka` (about); `før` (before); `etter`, `efter` (after); `entre … et …`,
+  `mellom … og …` (between); `du … au …`, `fra … til …` (from … to);
+  and the months `déc`, `févr`, `janv`, `avr`, `juil`, `desember`.
+
+## [0.1.5] - 2026-09-18
+
+### Added
+
+- `gedzip::ArchiveWriter`, a streaming GEDZIP writer: entries are added one
+  at a time and written straight to a sink, so peak memory is a small
+  multiple of the largest single entry plus the growing central directory,
+  never the archive's total. Measured, one `add` runs from roughly 2x the
+  entry (already-compressed media, stored) to a little over 3.5x (highly
+  compressible text, which briefly holds the source, the deflate output and
+  the encoder's state together) — never a function of how many entries came
+  before. A hash set of every lowercased path added so far is resident for
+  the writer's lifetime too, and at the default 100,000-entry limit the
+  central directory is bounded but not small.
+  It produces Zip64 structures once the entry count, an entry's size or the
+  running offset needs them, so it has no archive-size ceiling; the local
+  header's Zip64 extra carries both the original and compressed size
+  together whenever either overflows, as APPNOTE 4.5.3 requires for readers
+  that resolve local headers while streaming. Entry names carry
+  general-purpose bit 11 (UTF-8). A write failure to the sink poisons the
+  writer, so no entry is ever written next to bytes a failed write left
+  truncated, and `finish` flushes the sink before returning it rather than
+  leaving the last bytes to a `Drop` that cannot report failure.
+  `ArchiveWriter` implements `Debug` — entry count, bytes written, the
+  active limits and whether it is poisoned, never the sink or the directory
+  buffer's contents.
+- `gedzip::Archive::total_size`, the sum of an opened archive's entries'
+  claimed decompressed sizes, read from the central directory alone — so a
+  caller can ask what extracting will cost before decompressing anything.
+- Python and JavaScript/WASM bindings for both: `ArchiveWriter` (`new`,
+  `add`, `finish`) and `archive_total_size`. Both bindings write to an
+  in-memory `Vec<u8>` sink and copy it again when `finish` hands the bytes
+  to the host language, so — unlike the Rust API given a real sink such as
+  a file — they do not get the streaming memory benefit yet; their
+  docstrings say so.
+
+### Fixed
+
+Both entries below change `gedzip::write_archive`, which has shipped since
+0.1.0. Everything under **Added** is new in this release and never shipped
+broken; these two are what moves under an existing caller.
+
+- **`write_archive` now sets general-purpose bit 11 (UTF-8 names)**, so a
+  non-ASCII path round-trips as itself instead of being read back as IBM
+  code page 437 mush (confirmed against Python 3.12 `zipfile` and Java 17
+  `ZipFile`; .NET's `ZipArchive` happened to decode the unflagged form
+  correctly, and 7-Zip guesses). Directory entries also now carry the MS-DOS
+  directory external attribute (`0x10`) instead of `0`. **This changes the
+  bytes `write_archive` emits**: on the same five-entry input, exactly
+  eleven bytes differ from 0.1.4 — the flags field on every local and
+  central record, and the external-attribute byte on each directory entry.
+  Versions, timestamps, CRCs, sizes, offsets and names are unchanged. No
+  fixture or test pinned the previous bytes.
+- **`write_archive` now refuses one value earlier**, at the Zip64 sentinel
+  rather than past it. It rejected a count or size only once it *exceeded*
+  what a plain ZIP field holds, so it accepted a count of exactly 65,535
+  entries, or a size, compressed size, directory offset or directory size of
+  exactly 4,294,967,295 — but those values *are* the sentinels a reader
+  takes as "see the Zip64 record", which `write_archive` never writes. It
+  emitted the bare sentinel, and this crate's own `Archive::open` then
+  refused the result ("the archive needs a Zip64 directory and has none")
+  while Python, Java, 7-Zip and `bsdtar` accepted the broken archive.
+  **An input that produced a malformed archive in 0.1.4 is now an error**,
+  so a caller writing exactly 65,535 entries sees a refusal where it
+  previously saw a file. The design is unchanged — `write_archive` still
+  refuses rather than emit Zip64 — only the boundary moved from `>` the
+  sentinel to `>=` it, for the entry count and every 32-bit size and offset
+  field alike. Confirmed at 65,535 (refused), 65,534 and 4,294,967,294
+  (accepted and read back) against this crate's reader, Python 3.12, Java 17
+  `ZipFile` and `ZipInputStream`, 7-Zip 26.02, `bsdtar` and .NET's
+  `ZipArchive`.
+
+## [0.1.4] - 2026-09-16
+
+### Changed
+
+- Migrated Cargo release publishing to crates.io Trusted Publishing through
+  GitLab OIDC, retaining the API token only as a transition fallback.
+
+## [0.1.3] - 2026-09-16
+
+### Changed
+
+- Constrained PyPI Trusted Publishing to the protected `release` environment.
+- Recorded the completed npm OIDC migration and the legacy token removal.
+
+## [0.1.2] - 2026-09-16
+
+### Changed
+
+- Switched npm release publishing to GitLab OIDC Trusted Publishing.
+- Documented the synchronized multi-registry release checklist.
+
+## [0.1.1] - 2026-09-16
+
+### Changed
+
+- Synchronized the Rust core, Python binding, and JavaScript/WASM binding at
+  version 0.1.1 for the next registry release.
+- Added protected-tag publishing for Cargo, PyPI, and npm, with clean
+  registry-install verification documented for all three packages.
+
+## [0.1.0] - 2026-09-08
+
+### Added
+
+- Archival GEDCOM 5.5 through 7.x parsing, decoding, views, validation, and
+  reported version conversion.
+- Bounded GEDZIP reading and writing.
+- Python and JavaScript/WASM bindings over the same Rust core.
+- Byte-exact vendored corpus, conformance, property, interoperability, and
+  adversarial test suites.
+
+### Security
+
+- Refuse traversal, platform-special, duplicate, and central/local-mismatched
+  GEDZIP paths before returning entry bytes.
+- Stage and checksum external fixture downloads before making them visible.
+- Reject line injection through programmatically constructed GEDCOM fields.

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "flate2",
  "serde",

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/Cargo.toml

@@ -3,7 +3,7 @@
 # was checked on crates.io, npm, and PyPI before the initial release.
 [package]
 name = "gedcomkit"
-version = "0.1.4"
+version = "0.1.6"
 description = "A byte-preserving GEDCOM document model: decoding, parsing, readings, version conversion, plausibility checks, and the GEDZIP container, for GEDCOM 5.5 through 7.x."
 edition = "2024"
 # The true minimum, not the workspace's toolchain: a parser library is a leaf

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcomkit
-Version: 0.1.4
+Version: 0.1.6
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/README.md

@@ -203,9 +203,9 @@ than dropped.
 
 ## AI disclosure
 
-This project was created with the help of AI — specifically OpenAI's
-[Codex](https://openai.com/codex/). That includes the library code, bindings,
-tests, CI configuration, and documentation, with design decisions and
+This project was created with the help of AI — specifically Anthropic's
+[Claude](https://claude.com/claude-code). That includes the library code,
+bindings, tests, CI configuration, and documentation, with design decisions and
 validation made by a human. See [`AGENTS.md`](AGENTS.md) for the conventions AI
 contributors are expected to follow.
 

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/bindings/gedcomkit-py/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "flate2",
  "serde",
@@ -43,7 +43,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit-py"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "gedcomkit",
  "pyo3",

{gedcomkit-0.1.4 → gedcomkit-0.1.6}/bindings/gedcomkit-py/Cargo.toml

@@ -2,7 +2,7 @@
 # abi3 keeps it to one wheel per platform across Python versions.
 [package]
 name = "gedcomkit-py"
-version = "0.1.4"
+version = "0.1.6"
 description = "Python bindings for gedcomkit: an archival-grade GEDCOM library — byte-preserving round-trip, encoding detection, GEDCOM 5.5 through 7.x, GEDZIP."
 edition = "2024"
 rust-version = "1.88"

gedcomkit-0.1.6/bindings/gedcomkit-py/gedcomkit.pyi

@@ -0,0 +1,84 @@
+"""Type stubs for gedcomkit, an archival-grade GEDCOM library.
+
+Views, findings and reports are plain dicts built from the core's JSON
+serialization; their keys are camelCase, as the Rust types name them.
+"""
+
+from os import PathLike
+from typing import Any, TypedDict
+
+from typing_extensions import NotRequired
+
+__version__: str
+
+class RecordSpec(TypedDict):
+    """A structure to add: only ``tag`` is required, and any other key is refused."""
+
+    tag: str
+    xref: NotRequired[str | None]
+    value: NotRequired[str | None]
+    children: NotRequired[list[RecordSpec]]
+
+class WrappedLine(TypedDict):
+    record: str
+    path: list[int]
+    tag: str
+
+class Gedcom:
+    @staticmethod
+    def parse(data: bytes) -> Gedcom:
+        """Read a document from a file's bytes; raises ValueError past the bounds."""
+    @staticmethod
+    def new_v551(source_system: str) -> Gedcom:
+        """An empty GEDCOM 5.5.1 document naming its producing system, declaring UTF-8."""
+    @staticmethod
+    def new_v7() -> Gedcom:
+        """An empty GEDCOM 7.0 document."""
+    @property
+    def encoding(self) -> str: ...
+    @property
+    def version(self) -> str | None: ...
+    @property
+    def content_records(self) -> int: ...
+    def records(self) -> list[dict[str, Any]]: ...
+    def record(self, xref: str) -> dict[str, Any]: ...
+    def individuals(self) -> list[dict[str, Any]]: ...
+    def families(self) -> list[dict[str, Any]]: ...
+    def validate(self) -> list[dict[str, Any]]: ...
+    def unresolved_pointers(self) -> list[dict[str, Any]]: ...
+    def parents_of(self, xref: str) -> list[str]: ...
+    def children_of(self, xref: str) -> list[str]: ...
+    def partners_of(self, xref: str) -> list[str]: ...
+    def append_records(self, records: list[RecordSpec]) -> None:
+        """Add records before the trailer, all or none; raises ValueError."""
+    def append_structures(
+        self, record: str, path: list[int], structures: list[RecordSpec]
+    ) -> None:
+        """Add substructures under ``path`` in ``record`` (an xref, or "HEAD")."""
+    def wrap_long_lines(self, max_line_bytes: int = 255) -> list[WrappedLine]:
+        """Split lines over the limit across CONC lines and name each one rewritten."""
+    def set_logical_value(self, xref: str, path: list[int], value: str) -> None: ...
+    def to_text(self) -> str: ...
+    def to_bytes(self) -> bytes: ...
+    def to_version7(self) -> tuple[Gedcom, list[dict[str, Any]]]: ...
+    def to_version551(self) -> tuple[Gedcom, list[dict[str, Any]]]: ...
+    def __len__(self) -> int: ...
+
+class ArchiveWriter:
+    @staticmethod
+    def new() -> ArchiveWriter: ...
+    def add(self, name: str, data: bytes) -> None: ...
+    def finish(self) -> bytes: ...
+
+class ArchiveFileWriter:
+    """A GEDZIP archive written straight to a file, one entry at a time."""
+
+    def __init__(self, path: str | PathLike[str]) -> None: ...
+    def add(self, name: str, data: bytes) -> None: ...
+    def add_file(self, name: str, source: str | PathLike[str]) -> None: ...
+    def finish(self) -> int:
+        """Close the archive and return its size in bytes."""
+
+def archive_total_size(data: bytes) -> int: ...
+def parse_date(text: str) -> dict[str, Any]:
+    """A date reading; its ``gedcom551`` key is the 5.5.1 spelling, or None."""