gedcomkit 0.1.14__tar.gz → 0.1.16__tar.gz

{gedcomkit-0.1.14 → gedcomkit-0.1.16}/CHANGELOG.md

@@ -5,6 +5,72 @@ 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.16] - 2026-10-14
+
+### Added
+
+- `Document::record_index` builds a `RecordIndex` that answers
+  `get(xref)`, `position(xref)`, and `contains(xref)` in constant time,
+  exactly as `Document::record` does: ASCII case folded, other characters
+  compared as themselves, the first of two records with one identifier
+  winning. It borrows the document, so the compiler refuses any edit to
+  `records` while it is alive and no answer can be stale; build one per
+  batch of lookups (a page of rows, a chart) instead of calling `record`
+  per item, which scans. No identifier is copied to build it.
+- `gedzip::ArchiveWriter::add_streamed(name, source, size)`, for a sink that
+  is also `Seek`, writes an entry from any `Read` in 64 KiB chunks, so an
+  entry costs one buffer rather than about twice its size. Its size is
+  bounded by `ArchiveLimits::entry_bytes` alone (1 GiB by default); a writer
+  made with `new_with` and a higher figure takes entries past 4 GiB, through
+  Zip64. The local header is written first, with a Zip64 extra when the
+  entry needs one; the CRC-32 is computed as the bytes pass, and the writer
+  seeks back to fill it in and the compressed size, so the header is as
+  complete as `add`'s (no data descriptor). A stored entry is byte-for-byte
+  what `add` writes. `size` is checked against `entry_bytes` before anything
+  is written; a source that yields more or fewer bytes than `size`, a failing
+  source, a failed seek, or a sink that does not overwrite in place after a
+  seek (a file opened for appending) poisons the writer, since the sink then
+  holds a partial entry. A name `add` would deflate is deflated here too, but
+  kept deflated even when that did not make it smaller; and since its Zip64
+  need is settled against a bound before the compressed size is known, a
+  deflated entry within about an eighth of 4 GiB may carry a Zip64 extra in
+  its local header while its directory record is plain, which the format
+  allows.
+
+### Changed
+
+- The Python binding's `ArchiveFileWriter.add_file` now streams the file
+  through `add_streamed` instead of reading it into memory, so adding a file
+  costs one buffer; the per-entry limit stays the default 1 GiB. It refuses
+  anything but a regular file before writing. The binding surfaces are
+  unchanged.
+- `Document::xref_index` documents that its owned map can go stale after an
+  edit, and points to `record_index`.
+
+## [0.1.15] - 2026-10-11
+
+### Added
+
+- `gedzip::Archive::copy_entry` decompresses one entry into any
+  `std::io::Write` in 64 KiB chunks and returns the byte count, so an entry
+  of any size can be extracted without holding it in memory. It enforces the
+  same rules as `read_entry`: the local header must agree with the directory,
+  the entry may not outgrow its declared size, the per-file and ratio limits
+  are checked against the bytes as they accumulate, and the CRC-32 is
+  verified at the end. The sink may already have received bytes when an error
+  is returned, so write to a temporary file and move it into place on success.
+
+### Changed
+
+- `Archive::read_entry` is now `copy_entry` into a `Vec`, so the two share one
+  validation path and cannot disagree. Results and error messages are
+  unchanged.
+- The per-file and compression-ratio checks at open and at extraction are one
+  function, and `copy_entry` re-applies them to the entry it is handed.
+- `Archive::open_with` follows the Zip64 directory when the end record's
+  directory size is the `0xFFFF_FFFF` marker, as the writer promotes on it.
+  Before, only the entry count and offset were consulted.
+
 ## [0.1.14] - 2026-10-10
 
 ### Fixed

{gedcomkit-0.1.14 → gedcomkit-0.1.16}/Cargo.lock

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

{gedcomkit-0.1.14 → gedcomkit-0.1.16}/Cargo.toml

@@ -3,7 +3,7 @@
 # was checked on crates.io, npm, and PyPI before the initial release.
 [package]
 name = "gedcomkit"
-version = "0.1.14"
+version = "0.1.16"
 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.14 → gedcomkit-0.1.16}/PKG-INFO

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

{gedcomkit-0.1.14 → gedcomkit-0.1.16}/bindings/gedcomkit-py/Cargo.lock

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

{gedcomkit-0.1.14 → gedcomkit-0.1.16}/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.14"
+version = "0.1.16"
 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.14 → gedcomkit-0.1.16}/bindings/gedcomkit-py/src/lib.rs

@@ -20,7 +20,7 @@ use pyo3::types::{PyBytes, PyModule};
 use pyo3::wrap_pyfunction;
 use serde::Serialize;
 use std::fs::File;
-use std::io::{BufWriter, Write as _};
+use std::io::{BufReader, BufWriter, Write as _};
 use std::path::PathBuf;
 
 /// A parsed GEDCOM document and the report of how its bytes were read.
@@ -432,8 +432,11 @@ impl Default for ArchiveWriter {
 }
 
 /// Writes a GEDZIP archive straight to a file, one entry at a time, so
-/// memory stays a small multiple of the largest single entry however large
-/// the archive grows. Python only: the WASM binding has no filesystem.
+/// memory stays a small multiple of the largest entry passed as bytes to
+/// `add` — and one 64 KiB buffer for an entry streamed with `add_file` —
+/// however large the archive grows. Each entry may be at most the library's
+/// default per-entry limit, 1 GiB (`ArchiveLimits` has no Python binding
+/// yet). Python only: the WASM binding has no filesystem.
 ///
 /// The file is created at once and is complete only after `finish`; an
 /// archive abandoned part-way (an error, or no `finish`) leaves a partial
@@ -466,12 +469,32 @@ impl ArchiveFileWriter {
         self.writer()?.add(name, data).map_err(value_error)
     }
 
-    /// Adds one entry read from the file at `source`, without the bytes ever
-    /// passing through Python. Raises `OSError` when it cannot be opened and
-    /// `ValueError` as `add` does.
+    /// Adds one entry read from the regular file at `source`, without the
+    /// bytes ever passing through Python, and without holding the file in
+    /// memory: it streams in 64 KiB chunks, so it costs one buffer. The file
+    /// may be at most the writer's per-entry limit, the library's default of
+    /// 1 GiB. Raises `OSError` when it cannot be opened, `ValueError` when it
+    /// is not a regular file or as `add` does, and `ValueError` when the
+    /// file changes size while it is read — after which the archive cannot
+    /// be finished.
     fn add_file(&mut self, name: &str, source: PathBuf) -> PyResult<()> {
         let file = File::open(&source).map_err(|error| os_error(&source, &error))?;
-        self.writer()?.add(name, file).map_err(value_error)
+        let metadata = file
+            .metadata()
+            .map_err(|error| os_error(&source, &error))?;
+        // A directory, pipe, or device reports no usable length, and would
+        // fail part-way through the entry; refuse it before anything is
+        // written, which leaves the archive usable.
+        if !metadata.is_file() {
+            return Err(PyValueError::new_err(format!(
+                "{} is not a regular file",
+                source.display()
+            )));
+        }
+        let size = metadata.len();
+        self.writer()?
+            .add_streamed(name, BufReader::new(file), size)
+            .map_err(value_error)
     }
 
     /// Writes the central directory, flushes, and closes the file, returning