s3dgraphy 1.6.0.dev103__tar.gz → 1.6.0.dev104__tar.gz

{s3dgraphy-1.6.0.dev103/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev103
+Version: 1.6.0.dev104
 Summary: 3D Stratigraphic Graph Management Library for archaeological and heritage applications
 Author-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>
 Maintainer-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>

{s3dgraphy-1.6.0.dev103 → s3dgraphy-1.6.0.dev104}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev103"
+version = "1.6.0.dev104"
 description = "3D Stratigraphic Graph Management Library for archaeological and heritage applications"
 readme = "README.md"
 requires-python = ">=3.9"

{s3dgraphy-1.6.0.dev103 → s3dgraphy-1.6.0.dev104}/src/s3dgraphy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.6.0.dev103"
+__version__ = "1.6.0.dev104"
 __datamodel_version__ = "1.5.5"  # s3Dgraphy connections datamodel version
 
 # s3Dgraphy/__init__.py

{s3dgraphy-1.6.0.dev103 → s3dgraphy-1.6.0.dev104}/src/s3dgraphy/importer/pyarchinit_importer.py

@@ -156,6 +156,12 @@ class PyArchInitImporter(BaseImporter):
         self._footprints = footprints
         self._layer_url = layer_url
         self.footprint_report: Optional[Dict[str, Any]] = None
+        # 15 Nov 2026 · every row CLASSIFIED (unit_numbers): a unit, not a
+        # unit (with the class its code names), or ambiguous — counted here
+        # and said in the warnings. Nothing is written on the node: the
+        # unit's number is read from its NAME (E.D., 12 Nov 2026).
+        from .unit_numbers import new_report
+        self.numbering_report: Dict[str, Any] = new_report()
 
         self.validate_mapping()
 
@@ -303,6 +309,7 @@ class PyArchInitImporter(BaseImporter):
                 self._process_pyarchinit_properties(row_dict, existing_node)
                 self._process_memberships(row_dict, existing_node)
                 self._index_unit(row_dict, existing_node)
+                self._number_unit(row_dict, existing_node)
                 return existing_node
                 
             elif is_enriching_existing:
@@ -381,6 +388,7 @@ class PyArchInitImporter(BaseImporter):
                 self._process_pyarchinit_properties(row_dict, new_node)
                 self._process_memberships(row_dict, new_node)
                 self._index_unit(row_dict, new_node)
+                self._number_unit(row_dict, new_node)
                 return new_node
 
         except KeyError as e:
@@ -390,6 +398,30 @@ class PyArchInitImporter(BaseImporter):
     #: the unita_tipo that make their own class (the two voids, POL6)
     _VOID_TYPES = ("USN", "USNt")
 
+    def _number_unit(self, row_dict: Dict[str, Any], node: Node) -> None:
+        """The row CLASSIFIED (15 Nov 2026, unit_numbers): ``unita_tipo`` and
+        ``us`` say whether it is a unit (the mapping's node_type when the row
+        has no code), not a unit, or cannot be told. Nothing is written on the
+        node — the number is in the NAME the template made (``1.US2``), the
+        identifier (E.D., 12 Nov 2026: no ``data.us``). What is not a unit, or
+        ambiguous, is said in ``numbering_report`` and in the warnings."""
+        from .unit_numbers import number_of, record
+        id_column = self._get_id_column()
+        code = (str(row_dict.get('unita_tipo') or '').strip()
+                or self.mapping['column_mappings'][id_column].get('node_type', 'US'))
+        verdict = number_of(code, row_dict.get(id_column))
+        label = str(getattr(node, "name", "") or "")
+        record(self.numbering_report, label, verdict)
+        if verdict["status"] == "numbered":
+            return
+        if verdict["status"] == "not_unit":
+            self.warnings.append(
+                f"'{label}': unita_tipo '{verdict['code']}' names "
+                f"{verdict['class']} (not a unit): no unit number "
+                f"(the node is still a {type(node).__name__})")
+        else:
+            self.warnings.append(f"'{label}': no unit number, {verdict['reason']}")
+
     def _index_unit(self, row_dict: Dict[str, Any], node: Node) -> None:
         key = tuple(str(row_dict.get(c) if row_dict.get(c) is not None else "").strip()
                     for c in ("sito", "area", "us"))
@@ -1068,6 +1100,11 @@ class PyArchInitImporter(BaseImporter):
                 self.warnings.append(f"Skipped rows (not in graph): {skipped_rows}")
             if error_rows > 0:
                 self.warnings.append(f"Errors: {error_rows}")
+            nr = self.numbering_report
+            self.warnings.append(
+                f"Unit numbers: {nr['numbered']} numbered, "
+                f"{len(nr['not_unit'])} rows that are not units, "
+                f"{len(nr['ambiguous'])} ambiguous")
 
             self._read_footprints(conn)
             self._finish_relative_chronology("imported")

s3dgraphy-1.6.0.dev104/src/s3dgraphy/importer/unit_numbers.py

@@ -0,0 +1,144 @@
+"""THE NUMBER OF A UNIT is read from its NAME (15 Nov 2026; E.D., 12 Nov 2026).
+
+In EM the identifier of a unit is its ``name`` (``P1_is_identified_by``). The
+number is NOT copied into another key: no ``data.us``, in the data or in the
+datamodel. The name the pyArchInit importer builds from its
+``node_name_template`` (``{area}.{settore}.{unita_tipo}{us}`` → ``1.1.US1``,
+``1.US2``, ``1.USM12``, ``1.SF300``) already holds code and number, and the
+area in front makes it unique (in pyArchInit the key is site + area + number).
+No room is migrated: order and the «no number» sign are display only.
+
+ONE RULE, used by the importer to CLASSIFY a row (from its columns: the number
+is ``us``, the code ``unita_tipo``) and by any reader that has only the name
+(:func:`number_of_name`, a pure reader):
+
+* the code names a stratigraphic unit of the datamodel (its subtypes, the voids,
+  and the genre codes USM/USR/USS and their localised forms) and the number is
+  a unit number → ``numbered``;
+* the code names something that is not a unit (pyArchInit's paradata codes:
+  DOC, Combinar, Extractor, property; CON for continuity) → ``not_unit``, with
+  the class it names: the unit is not invented;
+* anything else (an unknown code, no code, a number that is not one) →
+  ``ambiguous``, with the reason. Not guessed: said.
+
+The importer writes nothing on the node from this: it counts the verdicts in
+its ``numbering_report`` and says the non-units and the ambiguous rows in its
+warnings.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+#: pyArchInit's codes for what is NOT a unit: the paradata rows of us_table
+#: (the same table as sync/yed_import_pipeline._CLASSIFIED_KIND_TO_UNITA_TIPO:
+#: DOC, Combinar, Extractor, property) and CON, the continuity row of the demo
+#: database. Code → the class it names.
+NOT_UNIT_CODES: Dict[str, str] = {
+    "DOC": "DocumentNode",
+    "Combinar": "CombinerNode",
+    "Extractor": "ExtractorNode",
+    "property": "PropertyNode",
+    "CON": "ContinuityNode",
+}
+
+#: What a unit number is (the rule StratiField's tools.unit_number applies):
+#: it begins with a digit, no spaces — «3018», «12a», «1001.2», «3014-bis».
+UNIT_NUMBER = re.compile(r"\d+(?:[./-]?[0-9A-Za-z]+)*")
+
+#: A name's LAST dot-separated component as code + number: ``US1``, ``USM-12``,
+#: ``SF 300``, ``USVs102``. What stands before it (``1.``, ``1.1.``) is the
+#: location the template put in front (area, settore).
+_CODE_NUMBER = re.compile(r"^(?P<code>[^\W\d_]+)[\s_-]*(?P<number>\d[0-9A-Za-z]*)$",
+                          re.UNICODE)
+
+
+def _datamodel_path() -> Path:
+    return (Path(__file__).resolve().parent.parent / "JSON_config"
+            / "s3Dgraphy_node_datamodel.json")
+
+
+@lru_cache(maxsize=1)
+def unit_codes() -> Dict[str, str]:
+    """Code → class, for every code that names a stratigraphic UNIT: the
+    concrete subtypes of StratigraphicNode in the datamodel (not ContinuityNode
+    nor StratigraphicEventNode, which are not units), and the genre codes
+    (USM, USR, USS, WSU…), which are a US with a kind."""
+    from ..nodes.stratigraphic_node import KIND_OF_CODE
+
+    data = json.loads(_datamodel_path().read_text(encoding="utf-8"))
+    strat = (((data.get("stratigraphic_nodes") or {}).get("StratigraphicNode")
+              or {}).get("subtypes") or {})
+    out = {key: str(v.get("class") or "") for key, v in strat.items()
+           if isinstance(v, dict) and v.get("class")
+           and not str(v["class"]).endswith("Node")}
+    for code in KIND_OF_CODE:
+        out.setdefault(code, "StratigraphicUnit")
+    return out
+
+
+def _known(code: str, table: Dict[str, str]) -> Optional[str]:
+    """The code as the table spells it: exact, else the ONE that differs only
+    by case (``usm`` → ``USM``); None when none or more than one."""
+    if code in table:
+        return code
+    low = [k for k in table if k.lower() == code.lower()]
+    return low[0] if len(low) == 1 else None
+
+
+def number_of(code: Any, number: Any) -> Dict[str, Any]:
+    """The verdict for a code and a number (a pyArchInit row's ``unita_tipo``
+    and ``us``): ``{"status": "numbered", "number", "code"}``,
+    ``{"status": "not_unit", "code", "class"}`` or
+    ``{"status": "ambiguous", "reason"}``."""
+    code = str(code if code is not None else "").strip()
+    number = str(number if number is not None else "").strip()
+    if not code:
+        return {"status": "ambiguous", "reason": "no unit code"}
+    other = _known(code, NOT_UNIT_CODES)
+    if other is not None:
+        return {"status": "not_unit", "code": other,
+                "class": NOT_UNIT_CODES[other]}
+    unit = _known(code, unit_codes())
+    if unit is None:
+        return {"status": "ambiguous",
+                "reason": f"'{code}' is not a code of the datamodel"}
+    if not UNIT_NUMBER.fullmatch(number):
+        return {"status": "ambiguous",
+                "reason": f"'{number}' is not a unit number"}
+    return {"status": "numbered", "number": number, "code": unit}
+
+
+def number_of_name(name: Any) -> Dict[str, Any]:
+    """The verdict for a NAME alone (``1.1.US1``, ``1.USM12``, ``1.SF300``):
+    the last dot-separated component read as code + number, the components
+    before it left as the location they are. Same answers as :func:`number_of`,
+    with ``"ambiguous"`` for a name that does not end in a code and a number."""
+    text = str(name if name is not None else "").strip()
+    last = text.rsplit(".", 1)[-1].strip()
+    m = _CODE_NUMBER.match(last)
+    if not m:
+        return {"status": "ambiguous",
+                "reason": f"'{text}' does not end in a code and a number"}
+    return number_of(m.group("code"), m.group("number"))
+
+
+def new_report() -> Dict[str, Any]:
+    """The numbering part of an import report."""
+    return {"numbered": 0, "not_unit": [], "ambiguous": []}
+
+
+def record(report: Dict[str, Any], label: str, verdict: Dict[str, Any]) -> None:
+    status = verdict.get("status")
+    if status == "numbered":
+        report["numbered"] += 1
+    elif status == "not_unit":
+        report["not_unit"].append({"name": label, "code": verdict["code"],
+                                   "class": verdict["class"]})
+    else:
+        report["ambiguous"].append({"name": label,
+                                    "reason": verdict.get("reason", "")})

{s3dgraphy-1.6.0.dev103 → s3dgraphy-1.6.0.dev104/src/s3dgraphy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev103
+Version: 1.6.0.dev104
 Summary: 3D Stratigraphic Graph Management Library for archaeological and heritage applications
 Author-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>
 Maintainer-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>

{s3dgraphy-1.6.0.dev103 → s3dgraphy-1.6.0.dev104}/src/s3dgraphy.egg-info/SOURCES.txt

@@ -283,6 +283,7 @@ src/s3dgraphy/importer/rdf_importer.py
 src/s3dgraphy/importer/sheet_header.py
 src/s3dgraphy/importer/source_text.py
 src/s3dgraphy/importer/unified_xlsx_importer.py
+src/s3dgraphy/importer/unit_numbers.py
 src/s3dgraphy/importer/xlsx_importer.py
 src/s3dgraphy/importer/xml_importer.py
 src/s3dgraphy/mappings/__init__.py
@@ -640,6 +641,7 @@ tests/test_timbra_master.py
 tests/test_transform_form.py
 tests/test_ttl_roundtrip.py
 tests/test_unit_definition.py
+tests/test_unit_numbers.py
 tests/test_use_profiles.py
 tests/test_valore_proprieta_doppio.py
 tests/test_verifica_provenance.py

s3dgraphy-1.6.0.dev104/tests/test_unit_numbers.py

@@ -0,0 +1,139 @@
+"""The number of a unit is read from its name (MICRO-NUMERI-UNITA, then
+MICRO-NUMERO-DAL-NOME, 15 Nov 2026: E.D. 12 Nov — no data.us, nothing migrated).
+
+The cases are the StratiField test room's, measured: the pyArchInit demo
+database (`Scavo archeologico`) imported with the 1.6 name template gave
+`1.1.US1`, `1.US2`, `1.USM12`, `1.SF300`, `1.USVs102`, `1.Combinar900`…
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import sys
+from pathlib import Path
+
+import pytest
+
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(_REPO_ROOT / "src"))
+
+from s3dgraphy.importer.unit_numbers import (  # noqa: E402
+    number_of, number_of_name)
+import s3dgraphy.importer.unit_numbers as unit_numbers  # noqa: E402
+
+
+@pytest.mark.parametrize("name,number,code", [
+    ("1.1.US1", "1", "US"),          # area 1, settore 1
+    ("1.US2", "2", "US"),
+    ("1.US10", "10", "US"),
+    ("1.USM12", "12", "USM"),        # its genre stays in the code
+    ("1.USN7", "7", "USN"),
+    ("1.SF300", "300", "SF"),        # a special find
+    ("1.USVs102", "102", "USVs"),
+    ("1.USVn104", "104", "USVn"),
+    ("US2", "2", "US"),              # a yEd label, no location
+    ("A.USM-10", "10", "USM"),
+])
+def test_a_name_that_says_its_number_gives_it(name, number, code):
+    v = number_of_name(name)
+    assert v == {"status": "numbered", "number": number, "code": code}
+
+
+@pytest.mark.parametrize("name,klass", [
+    ("1.Combinar900", "CombinerNode"),
+    ("1.DOC4001", "DocumentNode"),
+    ("1.Extractor400", "ExtractorNode"),
+    ("1.property800", "PropertyNode"),
+    ("1.CON500", "ContinuityNode"),
+])
+def test_what_is_not_a_unit_gets_no_number(name, klass):
+    v = number_of_name(name)
+    assert v["status"] == "not_unit" and v["class"] == klass
+    assert "number" not in v
+
+
+@pytest.mark.parametrize("name", ["1.Pippo12", "D.01.03", "Strato di crollo", "", "1."])
+def test_an_ambiguous_name_is_said_not_guessed(name):
+    v = number_of_name(name)
+    assert v["status"] == "ambiguous" and v["reason"]
+
+
+def test_the_row_columns_decide_not_the_name():
+    assert number_of("USM", "12") == {"status": "numbered", "number": "12", "code": "USM"}
+    assert number_of("usm", 12)["code"] == "USM"
+    assert number_of("US", "3014-bis")["number"] == "3014-bis"
+    assert number_of("US", "")["status"] == "ambiguous"
+    assert number_of("", "3")["status"] == "ambiguous"
+
+
+def _fixture(tmp_path):
+    db = tmp_path / "pyarchinit.sqlite"
+    conn = sqlite3.connect(str(db))
+    conn.execute("CREATE TABLE us_table (id_us INTEGER PRIMARY KEY, us TEXT, "
+                 "sito TEXT, area TEXT, settore TEXT, unita_tipo TEXT, "
+                 "d_stratigrafica TEXT)")
+    rows = [("1", "1", "1", "US", "Strato di macerie"),
+            ("2", "1", "", "US", "Strato di terra"),
+            ("12", "1", "", "USM", "Struttura in muratura"),
+            ("7", "1", "", "USN", "Taglio"),
+            ("300", "1", "", "SF", ""),
+            ("102", "1", "", "USVs", ""),
+            ("900", "1", "", "Combinar", ""),
+            ("4001", "1", "", "DOC", "Documento"),
+            ("55", "1", "", "Pippo", "")]
+    conn.executemany("INSERT INTO us_table (us, sito, area, settore, unita_tipo, "
+                     "d_stratigrafica) VALUES (?, 'Scavo', ?, ?, ?, ?)", rows)
+    conn.commit()
+    conn.close()
+    mapping = {
+        "table_settings": {"table_name": "us_table", "format_type": "sqlite",
+                           "node_name_template": "{area}.{settore}.{unita_tipo}{us}"},
+        "column_mappings": {
+            "us": {"node_type": "US", "is_id": True},
+            "sito": {"is_filter": True},
+            "unita_tipo": {"is_filter": True},
+            "d_stratigrafica": {"is_description": True},
+        },
+    }
+    mdir = tmp_path / "mappings"
+    mdir.mkdir()
+    (mdir / "numeri_test.json").write_text(json.dumps(mapping), encoding="utf-8")
+    from s3dgraphy.mappings.registry import mapping_registry
+    mapping_registry.add_mapping_directory("pyarchinit", str(mdir), priority="high")
+    return str(db), str(mdir)
+
+
+def test_the_pyarchinit_importer_classifies_and_writes_no_number(tmp_path):
+    from s3dgraphy.importer.pyarchinit_importer import PyArchInitImporter
+    from s3dgraphy.mappings.registry import mapping_registry
+    db, mdir = _fixture(tmp_path)
+    try:
+        imp = PyArchInitImporter(db, mapping_name="numeri_test",
+                                 filters={"sito": "Scavo"}, footprints=False)
+        graph = imp.parse()
+    finally:
+        mapping_registry._mapping_directories.get("pyarchinit", []).remove(mdir)
+    by_name = {n.name: n for n in graph.nodes if hasattr(n, "attributes")}
+    expect = {"1.1.US1": ("1", "US"), "1.US2": ("2", "US"),
+              "1.USM12": ("12", "USM"), "1.USN7": ("7", "USN"),
+              "1.SF300": ("300", "SF"), "1.USVs102": ("102", "USVs")}
+    for name, (number, code) in expect.items():
+        node = by_name[name]                       # the name as it came
+        assert "us" not in node.attributes         # E.D. 12 Nov: no data.us
+        assert "unita_tipo" not in node.attributes
+        v = number_of_name(node.name)              # the number IS the name's
+        assert (v["number"], v["code"]) == (number, code)
+    for name in ("1.Combinar900", "1.DOC4001", "1.Pippo55"):
+        assert "us" not in by_name[name].attributes
+    rep = imp.numbering_report
+    assert rep["numbered"] == 6
+    assert [x["name"] for x in rep["not_unit"]] == ["1.Combinar900", "1.DOC4001"]
+    assert [x["name"] for x in rep["ambiguous"]] == ["1.Pippo55"]
+    assert any(w.startswith("Unit numbers: 6 numbered") for w in imp.warnings)
+    assert any("'1.Combinar900'" in w and "CombinerNode" in w for w in imp.warnings)
+
+
+def test_no_writer_and_no_migration():
+    """The number is not copied into another key, and no room is migrated."""
+    for gone in ("write_number", "plan_for_document", "NUMBER_KEY", "CODE_KEY"):
+        assert not hasattr(unit_numbers, gone)