gedcomkit 0.1.17__tar.gz → 0.1.18__tar.gz

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/CHANGELOG.md

@@ -5,6 +5,132 @@ 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.
 
+## [Unreleased]
+
+## [0.1.18] - 2026-10-16
+
+### Added
+
+- `validate::inspect` runs nine more checks. Each has a stable name, and
+  the module documentation now lists every check with its severity:
+  - `married-after-died` (contradiction): a family's first `MARR` wholly
+    after a partner's death, or, failing a dated death, their burial. A
+    burial before the wedding beside a death after it is no finding here:
+    the death says when the life ended, and the burial is
+    `buried-before-died`'s.
+  - `child-born-long-after-father-died`: a child born more than 300 days
+    after the death of the family's `HUSB`. A contradiction when both dates
+    name a day; a question otherwise, since a bare year is often a guess.
+  - `christened-before-born` (contradiction): a `CHR`, `CHRA` or `BAPM`
+    wholly before the birth.
+  - `event-before-birth`: the mirror of `event-after-death`, for any other
+    event or attribute wholly before the birth year. A burial or cremation
+    is left to `died-before-born` and `buried-before-died` when the person
+    has a dated death.
+  - `buried-long-after-died` (question): a burial more than 365 days after
+    the death, counted from the latest day the death allows to the earliest
+    the burial does.
+  - `children-too-close`: two children of one mother born 2 to 270 days
+    apart. A contradiction when both dates name a day and are under 150
+    days apart; a question otherwise, since a very early birth makes the
+    longer gaps possible. A mother's children are taken from every family
+    she is the `WIFE` in; a family with no `WIFE` is compared alone.
+  - `possible-duplicate-child` (question): two children of one mother with
+    one given name (one name may be the start of the other: `Mira` and
+    `Mira Elowen`, but not `Mira Elowen` and `Mira Rose`), born on one
+    date, or on one day and month of different years.
+  - `conflicting-vitals` (question): two `BIRT`, or two `DEAT`, events of
+    one person that cannot both be true, even with an approximate date
+    allowed a year either way (`BIRT 1851` and `BIRT ABT 1850` are not in
+    conflict). GEDCOM lets a file record alternatives with the preferred
+    first, which is the one the other checks read, so this asks rather
+    than accuses.
+  - `own-ancestor` (contradiction): a loop in the parent links, read from
+    both directions of the family link as `FamilyGraph` reads them. One
+    finding per loop, on the person in it the file lists first, naming the
+    shortest way round: in full up to six steps, and past that its first
+    five and how many more, so a loop through 20,000 people is one short
+    message.
+
+  The three checks that compare pairs are bounded, so a hostile file cannot
+  make the report as large as the square of its people. `children-too-close`
+  and `possible-duplicate-child` report at most ten pairs for one mother,
+  and `conflicting-vitals` ten for one person's births and ten for their
+  deaths, the first in the order the file lists them; one more finding under
+  the same check, as serious as the most serious pair it stands for, then
+  says how many more pairs there are and how many in all (`4059990 more
+  pairs of children born 2 to 270 days apart, 4060000 in all`). The work is
+  bounded too: births and deaths are counted by sorting rather than compared
+  pair by pair; children who share a span of birth days, or a given name,
+  are compared as one group; and one mother's children are compared at most
+  100,000 times for each check, past which the summary gives its counts as
+  lower bounds. A family of 3,000 children of one name born in one month,
+  which made 4.5 million sibling findings, makes 22; a person with 5,000
+  births, which made 12.5 million `conflicting-vitals` findings, makes 11.
+
+### Changed
+
+- PyPI gets one wheel, Linux x86_64, beside the source distribution. The
+  macOS and Windows wheels are no longer cross-built; on those platforms pip
+  builds from the sdist, which needs a Rust toolchain.
+- `died-before-born`, `buried-before-died`, `christened-before-born`,
+  `married-after-died` and `conflicting-vitals` compare as finely as both
+  dates allow: a burial on 12 September before a death on 14 September of
+  one year is now found. Julian and Gregorian dates are put on one count of days first.
+  An approximate date (`ABT`, `CAL`, `EST`) still vouches for its year and
+  nothing finer, and a bound (`BEF`, `AFT`, `BET`) admits its own day. A
+  finding the years alone decide keeps its wording (`born 1900 and died
+  1880`); one only a finer comparison finds names the dates in full
+  (`died 14 September 1862 and buried 12 September 1862`).
+- An approximate date (`ABT`, `CAL`, `EST`) may be a year out. A finding
+  that two events are out of order is a question, not a contradiction, when
+  moving each approximate date a year either way could put them in order:
+  `BIRT ABT 1850` with `CHR 1849` or `CENS 1849`, or `DEAT ABT 1850` with a
+  burial in 1849. Two years out it is still a contradiction. This holds for
+  `died-before-born`, `buried-before-died`, `event-after-death`,
+  `married-before-born` and `child-born-after-mother-died`, and for the new
+  `christened-before-born`, `event-before-birth` and `married-after-died`;
+  the checks about an age or an interval take an approximate year as
+  written. Their messages say an approximate date is one: `born about 1850,
+  and Christening is dated 1849`.
+- `event-after-death` is a question, not a contradiction, for an `EVEN` or
+  `FACT`. Such an event is whatever its free-text `TYPE` says — a land
+  entry completed, a patent issued, an estate settled — and many of those
+  are done in a dead person's name. The other events keep their severity.
+- `by` is read as a `BEF` qualifier: `by 5 October 1752` is
+  `BEF 5 OCT 1752`, where it was read as 5 May 1752. The qualifiers the
+  reader already knew (`abt`, `about`, `c.`, `ca.`, `bef`, `before`, `aft`,
+  `after`, and the others) are unchanged.
+
+### Fixed
+
+- The date reader no longer shifts the pieces of a four-word date around a
+  word it does not know. `chr 10 Nov 1788` read as 10 October 1788,
+  `b 9 Jun 1750` as 9 September, `bapt. 3 May 1801` as 3 March: the leading
+  word was tried as a month, failed, and the day number was taken as the
+  month instead. Four pieces are now read only as a day, its ordinal ending
+  and a month written as a word, in either order (`Feb 11 th 1809`,
+  `11 th Feb 1809`, `1er janvier 1800`, `5te Januar 1800`); anything else is
+  `DateKind::Unparsed`, keeps its text as the phrase, and still offers its
+  year to sort by, so `to_gedcom_5_5_1` and `to_gedcom_7` return `None` and
+  the caller writes it as a date phrase. A month given only as a number never
+  decides the order of four pieces.
+- A dual year (`10 JAN 1731/32`) admits both its years in every check, not
+  only where days are compared. The checks that compare years read it as
+  its first year alone, so `BIRT 1732` with `DEAT 10 JAN 1731/32` was
+  `died-before-born` ("born 1732 and died 1731"); it is now no finding, and
+  a death past both years says `died between 1731 and 1732`. Where the days
+  of two dates are compared, they alone decide the order, so a burial in the
+  Julian year 1700, which runs eleven days into the Gregorian 1701, is no
+  longer wholly before a death in the Gregorian 1701.
+- `child-listed-twice` keeps the children it has seen in a set rather than
+  a list, so a family listing tens of thousands of children is checked in
+  time proportional to their number, not its square.
+- The checks on an individual's own record read that record's dates when it
+  has no identifier, or shares one with another record. Before, such a
+  record was checked against no dates, or against those of the last record
+  with its identifier.
+
 ## [0.1.17] - 2026-10-16
 
 ### Changed

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/Cargo.lock

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

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/Cargo.toml

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

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

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/README.md

@@ -23,6 +23,9 @@ Python:
 python -m pip install gedcomkit
 ```
 
+Wheels are published for Linux x86_64 only. Elsewhere pip builds the package from
+source, which needs a Rust toolchain ([rustup](https://rustup.rs)).
+
 Node.js / WASM:
 
 ```bash

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/bindings/gedcomkit-py/Cargo.lock

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

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/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.17"
+version = "0.1.18"
 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.17 → gedcomkit-0.1.18}/bindings/gedcomkit-py/gedcomkit.pyi

@@ -44,7 +44,11 @@ class Gedcom:
     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 validate(self) -> list[dict[str, Any]]:
+        """Plausibility findings, each with ``record``, ``check``, ``severity``
+        and ``message``. ``check`` is the core's stable rule name, such as
+        ``died-before-born`` or ``own-ancestor``; the core's ``validate``
+        module documentation lists every one with its severity."""
     def unresolved_pointers(self) -> list[dict[str, Any]]: ...
     def parents_of(self, xref: str) -> list[str]: ...
     def children_of(self, xref: str) -> list[str]: ...

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/bindings/gedcomkit-py/src/lib.rs

@@ -240,7 +240,10 @@ impl Gedcom {
     }
 
     /// Plausibility findings: contradictions, questions, and what cites
-    /// nothing — reported with the numbers they were drawn from.
+    /// nothing — reported with the numbers they were drawn from. Each has
+    /// `record`, `check`, `severity` and `message`; `check` is the core's
+    /// stable rule name (`died-before-born`, `own-ancestor`, …), listed with
+    /// its severity in the core's `validate` module documentation.
     fn validate(&self, py: Python<'_>) -> PyResult<Vec<Py<PyAny>>> {
         gedcomkit::validate::inspect(&self.document)
             .iter()

{gedcomkit-0.1.17 → gedcomkit-0.1.18}/src/dates.rs

@@ -571,7 +571,7 @@ fn point_5_5_1(point: DatePoint) -> String {
 /// The first slashed year pair in a payload — `1740/41`, `1679/1683` — as
 /// two full years. `8/2/1664` is a numeric date, not a pair, and is skipped
 /// because a pair's first half has three or four digits.
-fn dual_year(text: &str) -> Option<(i32, i32)> {
+pub(crate) fn dual_year(text: &str) -> Option<(i32, i32)> {
     let bytes = text.as_bytes();
     let mut index = 0;
     while index < bytes.len() {
@@ -721,9 +721,14 @@ const PREFIXES: &[(DateKind, &[&str])] = &[
     ),
     (DateKind::Calculated, &["CAL", "CALCULATED"]),
     (DateKind::Estimated, &["EST", "ESTIMATED"]),
+    // `by 5 October 1752` says the event had happened by that day. GEDCOM
+    // has no "on or before", and `BEF` is the nearest claim; `validate`
+    // compares a bound as admitting the bound itself, so nothing is lost.
     (
         DateKind::Before,
-        &["BEF", "BEFORE", "AVANT", "VOR", "PRIMA", "ANTES", "FØR"],
+        &[
+            "BEF", "BEFORE", "BY", "AVANT", "VOR", "PRIMA", "ANTES", "FØR",
+        ],
     ),
     (
         DateKind::After,
@@ -930,20 +935,48 @@ fn parse_point(input: &str) -> Option<DatePoint> {
             })
         }
         [first, second, third, fourth] => {
-            // `Feb 11 th 1809`, and `April 15 , 1873` once punctuation splits.
+            // Four pieces are a day with its ordinal ending beside a month
+            // written as a word: `Feb 11 th 1809` and `April 15th, 1873`
+            // month-first, `11 th Feb 1809` and `1er janvier 1800` day-first.
+            // Nothing else is read. A word the reader does not know in front
+            // of a date — `chr 10 Nov 1788`, `b 9 Jun 1750`, `bapt. 3 May
+            // 1801` — leaves the payload unparsed rather than shifting the
+            // pieces around it: guessing past such a word once took the day
+            // for the month and read `10 OCT 1788`.
             let year = parse_year(fourth)?;
-            let month = month_number(first).or_else(|| month_number(second))?;
-            let day = parse_day(second).or_else(|| parse_day(third))?;
+            let (month, day) = if is_month_name(first) && is_ordinal_ending(third) {
+                (first, second)
+            } else if is_month_name(third) && is_ordinal_ending(second) {
+                (third, first)
+            } else {
+                return None;
+            };
             Some(DatePoint {
                 year,
-                month: Some(month),
-                day: Some(day),
+                month: Some(month_number(month)?),
+                day: Some(parse_day(day)?),
             })
         }
         _ => None,
     }
 }
 
+/// Whether a token is a month written as a word, never as a number.
+fn is_month_name(token: &str) -> bool {
+    !token.bytes().all(|byte| byte.is_ascii_digit()) && month_number(token).is_some()
+}
+
+/// Whether a token is the ending of an ordinal day once the digits have been
+/// split from it: English `11th` and `2nd`, French `1er`, Danish and
+/// Norwegian `1ste` and `5te`. (`22de` needs no entry: `de` is dropped as a
+/// filler word before the pieces are counted.)
+fn is_ordinal_ending(token: &str) -> bool {
+    matches!(
+        token.to_lowercase().as_str(),
+        "st" | "nd" | "rd" | "th" | "er" | "ste" | "te"
+    )
+}
+
 fn parse_numeric(input: &str) -> Option<DatePoint> {
     for (separator, month_first) in [('.', false), ('/', true), ('-', false)] {
         let parts: Vec<&str> = input.split(separator).collect();
@@ -1538,6 +1571,100 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_word_in_front_of_a_date_never_turns_the_day_into_the_month() {
+        // Each of these was once read with its day number as the month:
+        // `chr 10 Nov 1788` as 10 October. A word the reader does not know
+        // leaves the whole payload unparsed, so a writer keeps it as a phrase.
+        for payload in [
+            "chr 10 Nov 1788",
+            "b 9 Jun 1750",
+            "bapt. 3 May 1801",
+            // Lower-case and full month names, and two-digit days.
+            "chr 10 nov 1788",
+            "chr 10 November 1788",
+            "b 19 Jun 1750",
+            "b. 19 june 1750",
+            "bapt 3 MAY 1801",
+            "Sunday 5 Jan 1882",
+            // No month written as a word: nothing to anchor the order.
+            "chr 10 11 1788",
+            "chr Nov 1788",
+            "b 1750",
+        ] {
+            let date = parsed(payload);
+            assert_eq!(date.kind, DateKind::Unparsed, "{payload:?}");
+            assert_eq!(date.earliest, None, "{payload:?}");
+            assert_eq!(date.phrase.as_deref(), Some(payload), "{payload:?}");
+            assert_eq!(date.to_gedcom_5_5_1(), None, "{payload:?}");
+            assert_eq!(date.to_gedcom_7(), None, "{payload:?}");
+        }
+        // The year is still there to sort by.
+        assert_eq!(parsed("chr 10 Nov 1788").year_hint(), Some(1788));
+    }
+
+    #[test]
+    fn a_known_qualifier_in_front_of_a_date_is_read_as_one() {
+        let written = |text: &str| parsed(text).to_gedcom_5_5_1();
+        let cases: &[(&str, &str)] = &[
+            ("by 5 October 1752", "BEF 5 OCT 1752"),
+            ("By 5 Oct 1752", "BEF 5 OCT 1752"),
+            ("by 1752", "BEF 1752"),
+            ("abt 10 Nov 1788", "ABT 10 NOV 1788"),
+            ("abt. 10 nov 1788", "ABT 10 NOV 1788"),
+            ("about 10 November 1788", "ABT 10 NOV 1788"),
+            ("c. 3 May 1801", "ABT 3 MAY 1801"),
+            ("ca. 3 May 1801", "ABT 3 MAY 1801"),
+            ("ca 3 may 1801", "ABT 3 MAY 1801"),
+            ("bef 19 Jun 1750", "BEF 19 JUN 1750"),
+            ("bef. 19 Jun 1750", "BEF 19 JUN 1750"),
+            ("before 19 June 1750", "BEF 19 JUN 1750"),
+            ("aft 9 Jun 1750", "AFT 9 JUN 1750"),
+            ("aft. 9 Jun 1750", "AFT 9 JUN 1750"),
+            ("after 9 June 1750", "AFT 9 JUN 1750"),
+        ];
+        for (text, expected) in cases {
+            assert_eq!(written(text).as_deref(), Some(*expected), "{text:?}");
+        }
+        // A word that merely begins like a qualifier is not one.
+        assert_eq!(parsed("byre 5 Oct 1752").kind, DateKind::Unparsed);
+    }
+
+    #[test]
+    fn a_day_with_its_ordinal_ending_is_read_either_side_of_the_month() {
+        type Case = (&'static str, i32, u8, u8);
+        let cases: &[Case] = &[
+            ("Feb 11 th 1809", 1809, 2, 11),
+            ("Feb 11th 1809", 1809, 2, 11),
+            ("April 15th, 1873", 1873, 4, 15),
+            ("January 1st 1800", 1800, 1, 1),
+            ("11 th Feb 1809", 1809, 2, 11),
+            ("1st January 1800", 1800, 1, 1),
+            ("23rd nov 1788", 1788, 11, 23),
+            ("1er janvier 1800", 1800, 1, 1),
+            ("5te Januar 1800", 1800, 1, 5),
+            ("22de Juni 1848", 1848, 6, 22),
+        ];
+        for (payload, year, month, day) in cases {
+            let date = parsed(payload);
+            assert_eq!(date.kind, DateKind::Exact, "{payload:?}");
+            assert_eq!(
+                date.earliest,
+                Some(DatePoint {
+                    year: *year,
+                    month: Some(*month),
+                    day: Some(*day)
+                }),
+                "{payload:?}"
+            );
+        }
+        // A number where the month should be, or a word where the ending
+        // should be, is not guessed around.
+        for payload in ["11 15 th 1873", "Feb 11 foo 1809", "11 foo Feb 1809"] {
+            assert_eq!(parsed(payload).kind, DateKind::Unparsed, "{payload:?}");
+        }
+    }
+
     #[test]
     fn what_cannot_be_read_keeps_its_text_and_says_so() {
         for payload in ["Infant", "DEAD", "Unknown", "1799 or 12 April 1811"] {