gedcomkit 0.1.4__tar.gz → 0.1.5__tar.gz

gedcomkit-0.1.5/CHANGELOG.md

@@ -0,0 +1,126 @@
+# 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.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.5}/Cargo.lock

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

{gedcomkit-0.1.4 → gedcomkit-0.1.5}/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.5"
 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.5}/PKG-INFO

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

{gedcomkit-0.1.4 → gedcomkit-0.1.5}/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.5}/bindings/gedcomkit-py/Cargo.lock

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

{gedcomkit-0.1.4 → gedcomkit-0.1.5}/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.5"
 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.4 → gedcomkit-0.1.5}/bindings/gedcomkit-py/src/lib.rs

@@ -7,11 +7,13 @@
 //! record and structure path. Everything else stays in Rust.
 
 use gedcomkit::family::FamilyGraph;
+use gedcomkit::gedzip::{self, Archive};
 use gedcomkit::view::{FamilyView, IndividualView, RecordView};
 use gedcomkit::{Document, EncodingReport};
 use pyo3::exceptions::{PyKeyError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyModule};
+use pyo3::wrap_pyfunction;
 use serde::Serialize;
 
 /// A parsed GEDCOM document and the report of how its bytes were read.
@@ -219,6 +221,78 @@ impl Gedcom {
     }
 }
 
+/// Builds a GEDZIP archive one entry at a time. Peak memory per `add` call
+/// is a small multiple of the entry just added, not the archive's total —
+/// roughly 2x for already-compressed media (stored rather than deflated) up
+/// to a little over 3.5x for highly compressible text, plus the growing
+/// central directory; see `gedzip::ArchiveWriter`'s own documentation for
+/// the full accounting. This binding's sink is an in-memory buffer rather
+/// than a real file, though, so `finish` copies that whole buffer again to
+/// hand the bytes to Python — the streaming benefit a real file sink gets
+/// in Rust does not yet extend past this binding's boundary.
+/// `write_archive`-equivalent behavior for a whole list already in memory
+/// is not bound separately — build one of these and call `add` in a loop
+/// instead.
+#[pyclass]
+struct ArchiveWriter {
+    /// `None` once `finish` has been called.
+    inner: Option<gedzip::ArchiveWriter<Vec<u8>>>,
+}
+
+#[pymethods]
+impl ArchiveWriter {
+    /// Starts a new archive under the default bounds
+    /// (`gedcomkit.gedzip.ArchiveLimits` has no Python binding yet; this
+    /// uses the library's defaults).
+    #[staticmethod]
+    fn new() -> Self {
+        Self {
+            inner: Some(gedzip::ArchiveWriter::new(Vec::new())),
+        }
+    }
+
+    /// Adds one entry. Raises `ValueError` for an unsafe or repeated path,
+    /// one that exceeds the writer's per-entry limit, or a call after
+    /// `finish`.
+    fn add(&mut self, name: &str, data: &[u8]) -> PyResult<()> {
+        let writer = self
+            .inner
+            .as_mut()
+            .ok_or_else(|| PyValueError::new_err("finish() was already called"))?;
+        writer
+            .add(name, data)
+            .map_err(|error| PyValueError::new_err(error.to_string()))
+    }
+
+    /// Writes the central directory and returns the finished archive's
+    /// bytes. Valid to call once; raises `ValueError` on a second call.
+    fn finish<'py>(&mut self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
+        let writer = self
+            .inner
+            .take()
+            .ok_or_else(|| PyValueError::new_err("finish() was already called"))?;
+        let bytes = writer
+            .finish()
+            .map_err(|error| PyValueError::new_err(error.to_string()))?;
+        Ok(PyBytes::new(py, &bytes))
+    }
+}
+
+impl Default for ArchiveWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// The sum of a GEDZIP archive's entries' claimed decompressed sizes, read
+/// from its central directory alone — nothing is decompressed to answer
+/// this. Raises `ValueError` for bytes that do not open as an archive.
+#[pyfunction]
+fn archive_total_size(data: &[u8]) -> PyResult<u64> {
+    let archive = Archive::open(data).map_err(|error| PyValueError::new_err(error.to_string()))?;
+    Ok(archive.total_size())
+}
+
 /// An archival-grade GEDCOM library: byte-preserving round-trip, encoding
 /// detection and reporting, GEDCOM 5.5 through 7.x.
 ///
@@ -229,6 +303,8 @@ impl Gedcom {
 #[pyo3(name = "gedcomkit")]
 fn gedcomkit_py(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_class::<Gedcom>()?;
+    module.add_class::<ArchiveWriter>()?;
+    module.add_function(wrap_pyfunction!(archive_total_size, module)?)?;
     module.add("__version__", env!("CARGO_PKG_VERSION"))?;
     Ok(())
 }