arango-query-core 0.2.0__tar.gz → 0.2.1__tar.gz

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/CHANGELOG.md

@@ -6,6 +6,27 @@ exact versions (contextual-data-fabric CC-9) and re-run their golden /
 eval suites on every bump — pre-1.0, **minor** bumps may break the API
 and this file must say so explicitly.
 
+## [0.2.1] - 2026-10-16
+
+### Fixed
+
+- **OWL import keeps property names.** `owl_turtle.turtle_to_mapping` cut
+  every datatype-property name at its last underscore — a rule meant for the
+  `:<REL>_<prop>` relationship properties `mapping_to_turtle` writes — so
+  `file_name` imported as `name` and `account_id` as `id`, including on a
+  round trip of this library's own export. Entity properties now keep their
+  full name; relationship properties lose exactly their `<REL>_` prefix.
+- **Shared fields reach every class.** Both importers (`turtle_to_mapping`
+  and the rdflib-based `parse_owl_with_rdflib`) dropped a property whose
+  `rdfs:domain` is an `owl:unionOf` list — arangodb-schema-analyzer
+  0.15.1's form for a field several classes share — and the rdflib one read
+  only the first of several domains. Each member / domain now gets the field,
+  and the anonymous union class is no longer imported as an entity.
+- **Stored field names.** `phys:attributeName` (analyzer 0.15.1) now maps a
+  property to its stored field in the physical mapping
+  (`properties.<name>.field`), so a sanitized or renamed field (`file-name`,
+  `page_count`) resolves to the attribute that holds it.
+
 ## [0.2.0] - 2026-08-23
 
 ### BREAKING

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: arango-query-core
-Version: 0.2.0
+Version: 0.2.1
 Summary: Shared conceptual-model and NL substrate for ArangoDB query transpilers (arango-cypher-py, arango-sparql-py)
 Project-URL: Repository, https://github.com/ArthurKeen/arango-query-core
 Project-URL: Changelog, https://github.com/ArthurKeen/arango-query-core/blob/main/CHANGELOG.md

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/arango_query_core/owl_rdflib.py

@@ -42,23 +42,30 @@ def parse_owl_with_rdflib(turtle_text: str) -> MappingBundle:
     entities: list[dict[str, Any]] = []
     entity_props: dict[str, list[dict[str, str]]] = {}
 
-    for cls in g.subjects(RDF.type, OWL.Class):
+    for cls in _named_classes(g, RDF, OWL):
         name = _local_name(cls)
         entities.append({"name": name, "labels": [name], "properties": []})
         entity_props[name] = []
 
     # ── Extract datatype properties ──────────────────────────────────
+    # A property's domain may be one class, several (each gets the field),
+    # or an owl:unionOf class expression — arangodb-schema-analyzer's form
+    # for a field several classes share. phys:attributeName names the
+    # stored field when it differs from the property name.
+    fields: dict[str, dict[str, str]] = {}
     for prop in g.subjects(RDF.type, OWL.DatatypeProperty):
         prop_name = _local_name(prop)
-        domain = g.value(prop, RDFS.domain)
         range_uri = g.value(prop, RDFS.range)
         prop_entry: dict[str, str] = {"name": prop_name}
         if range_uri:
             prop_entry["type"] = _xsd_to_simple(str(range_uri))
-        if domain:
-            domain_name = _local_name(domain)
-            if domain_name in entity_props:
-                entity_props[domain_name].append(prop_entry)
+        attribute = g.value(prop, PHYS.attributeName)
+        for domain_node in g.objects(prop, RDFS.domain):
+            for domain_name in _domain_names(g, domain_node, OWL):
+                if domain_name in entity_props:
+                    entity_props[domain_name].append(prop_entry)
+                    if attribute:
+                        fields.setdefault(domain_name, {})[prop_name] = str(attribute)
 
     for entity in entities:
         entity["properties"] = entity_props.get(entity["name"], [])
@@ -82,7 +89,7 @@ def parse_owl_with_rdflib(turtle_text: str) -> MappingBundle:
     physical_entities: dict[str, dict[str, Any]] = {}
     physical_rels: dict[str, dict[str, Any]] = {}
 
-    for cls in g.subjects(RDF.type, OWL.Class):
+    for cls in _named_classes(g, RDF, OWL):
         name = _local_name(cls)
         coll = g.value(cls, PHYS.collectionName)
         style = g.value(cls, PHYS.style) or g.value(cls, PHYS.mappingStyle)
@@ -98,6 +105,8 @@ def parse_owl_with_rdflib(turtle_text: str) -> MappingBundle:
                 pm_entry["typeField"] = str(type_field)
             if type_value:
                 pm_entry["typeValue"] = str(type_value)
+            for prop_name, field in fields.get(name, {}).items():
+                pm_entry["properties"][prop_name] = {"field": field}
             physical_entities[name] = pm_entry
 
     for prop in g.subjects(RDF.type, OWL.ObjectProperty):
@@ -127,6 +136,27 @@ def parse_owl_with_rdflib(turtle_text: str) -> MappingBundle:
     )
 
 
+def _named_classes(g: Any, rdf: Any, owl: Any) -> list[Any]:
+    """Every ``owl:Class`` with an IRI. An anonymous class expression (the
+    ``[ a owl:Class ; owl:unionOf ( … ) ]`` of a shared field's domain) is not
+    an entity."""
+    import rdflib
+
+    return [c for c in g.subjects(rdf.type, owl.Class) if isinstance(c, rdflib.URIRef)]
+
+
+def _domain_names(g: Any, domain: Any, owl: Any) -> list[str]:
+    """Class names a ``rdfs:domain`` value covers: the class itself, or every
+    member of an ``owl:unionOf`` list."""
+    import rdflib
+    from rdflib.collection import Collection
+
+    if isinstance(domain, rdflib.BNode):
+        members = g.value(domain, owl.unionOf)
+        return [_local_name(m) for m in Collection(g, members)] if members is not None else []
+    return [_local_name(domain)]
+
+
 def _local_name(uri: Any) -> str:
     """Extract the local (fragment / last-path-segment) name from a URI."""
     s = str(uri)

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/arango_query_core/owl_turtle.py

@@ -111,10 +111,21 @@ def mapping_to_turtle(bundle: MappingBundle) -> str:
 
 
 def turtle_to_mapping(turtle: str) -> MappingBundle:
-    """Parse an OWL/Turtle string into a MappingBundle."""
+    """Parse an OWL/Turtle string into a MappingBundle.
+
+    A line-oriented reader for the layout :func:`mapping_to_turtle` and
+    arangodb-schema-analyzer write (no rdflib needed; see
+    :mod:`.owl_rdflib` for arbitrary Turtle). A datatype property keeps its
+    full local name (``:file_name`` is ``file_name``); only a relationship
+    property written ``:<REL>_<prop>`` with ``rdfs:domain :<REL>`` loses the
+    ``<REL>_`` prefix. Its domain may be one class, several ``rdfs:domain``
+    lines, or an ``owl:unionOf`` list (the analyzer's form for a field
+    several classes share), and ``phys:attributeName`` names the stored
+    field when it differs from the property name.
+    """
     classes: dict[str, dict[str, str]] = {}
     obj_props: dict[str, dict[str, str]] = {}
-    data_props: list[dict[str, str]] = []
+    data_props: list[dict[str, Any]] = []
     annotations: dict[str, dict[str, str]] = {}
 
     current_subject: str | None = None
@@ -143,14 +154,20 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
         if m_dataprop:
             current_subject = m_dataprop.group(1)
             current_kind = "dataprop"
-            data_props.append({"name": current_subject})
+            data_props.append({"name": current_subject, "domains": []})
+            continue
+
+        m_union = re.match(r"rdfs:domain\s+\[.*owl:unionOf\s*\(([^)]*)\)", stripped)
+        if m_union:
+            if current_kind == "dataprop" and data_props:
+                data_props[-1]["domains"].extend(re.findall(r":(\w+)", m_union.group(1)))
             continue
 
         m_domain = re.match(r"rdfs:domain\s+:(\w+)", stripped)
         if m_domain:
             domain = m_domain.group(1)
             if current_kind == "dataprop" and data_props:
-                data_props[-1]["domain"] = domain
+                data_props[-1]["domains"].append(domain)
             elif current_kind == "objprop" and current_subject:
                 obj_props[current_subject]["domain"] = domain
             continue
@@ -164,7 +181,14 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
                 obj_props[current_subject]["range"] = rng.lstrip(":")
             continue
 
-        for annot in ("mappingStyle", "collectionName", "typeField", "typeValue", "edgeCollectionName"):
+        for annot in (
+            "mappingStyle",
+            "collectionName",
+            "typeField",
+            "typeValue",
+            "edgeCollectionName",
+            "attributeName",
+        ):
             m_a = re.match(rf':(\w+)\s+phys:{annot}\s+"([^"]+)"', stripped)
             if m_a:
                 subject = m_a.group(1)
@@ -174,14 +198,8 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
     entities_cs: list[dict[str, Any]] = []
     entities_pm: dict[str, dict[str, Any]] = {}
     for name in classes:
-        props = [
-            {
-                "name": dp["name"].split("_")[-1] if "_" in dp["name"] else dp["name"],
-                "type": _from_xsd_type(dp.get("range", "xsd:string")),
-            }
-            for dp in data_props
-            if dp.get("domain") == name
-        ]
+        own = [dp for dp in data_props if name in dp["domains"]]
+        props = [{"name": dp["name"], "type": _from_xsd_type(dp.get("range", "xsd:string"))} for dp in own]
         entities_cs.append({"name": name, "labels": [name], "properties": props})
         ann = annotations.get(name, {})
         pm_entry: dict[str, Any] = {
@@ -191,6 +209,13 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
         if pm_entry["style"] == "LABEL":
             pm_entry["typeField"] = ann.get("typeField", "type")
             pm_entry["typeValue"] = ann.get("typeValue", name)
+        fields = {
+            dp["name"]: {"field": annotations[dp["name"]]["attributeName"]}
+            for dp in own
+            if annotations.get(dp["name"], {}).get("attributeName")
+        }
+        if fields:
+            pm_entry["properties"] = fields
         entities_pm[name] = pm_entry
 
     rels_cs: list[dict[str, Any]] = []
@@ -201,11 +226,12 @@ def turtle_to_mapping(turtle: str) -> MappingBundle:
         to_e = op.get("range", "Any")
         props = [
             {
-                "name": dp["name"].replace(f"{rtype}_", ""),
+                # Exactly the `<REL>_` prefix mapping_to_turtle adds, not every occurrence.
+                "name": dp["name"].removeprefix(f"{rtype}_"),
                 "type": _from_xsd_type(dp.get("range", "xsd:string")),
             }
             for dp in data_props
-            if dp.get("domain") == rtype
+            if rtype in dp["domains"]
         ]
         rels_cs.append({"type": rtype, "fromEntity": from_e, "toEntity": to_e, "properties": props})
         ann = annotations.get(rtype, {})

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arango-query-core"
-version = "0.2.0"
+version = "0.2.1"
 description = "Shared conceptual-model and NL substrate for ArangoDB query transpilers (arango-cypher-py, arango-sparql-py)"
 readme = "README.md"
 license = { file = "LICENSE" }

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/tests/test_owl_rdflib.py

@@ -189,3 +189,53 @@ class TestImportError:
         with patch("builtins.__import__", side_effect=mock_import):
             with pytest.raises(ImportError, match="rdflib is required"):
                 parse_owl_with_rdflib(MINIMAL_OWL)
+
+
+ANALYZER_OWL = """\
+@prefix : <http://arangodb.com/schema/hybrid#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix phys: <http://arangodb.com/schema/physical#> .
+
+:Chunk a owl:Class ; phys:collectionName "chunks" .
+:Document a owl:Class ; phys:collectionName "documents" .
+:Note a owl:Class ; phys:collectionName "notes" .
+
+:content a owl:DatatypeProperty ;
+  rdfs:domain [ a owl:Class ; owl:unionOf ( :Chunk :Document ) ] .
+:file_name a owl:DatatypeProperty ;
+  rdfs:domain :Document ;
+  phys:attributeName "file-name" .
+:tag a owl:DatatypeProperty ;
+  rdfs:domain :Document , :Note ;
+  rdfs:range xsd:string .
+"""
+
+
+def _names(bundle, entity):
+    return sorted(
+        p["name"]
+        for e in bundle.conceptual_schema["entities"]
+        if e["name"] == entity
+        for p in e["properties"]
+    )
+
+
+def test_a_union_domain_gives_the_field_to_every_member():
+    bundle = parse_owl_with_rdflib(ANALYZER_OWL)
+    # The anonymous union class is not an entity of its own.
+    assert sorted(e["name"] for e in bundle.conceptual_schema["entities"]) == ["Chunk", "Document", "Note"]
+    assert _names(bundle, "Chunk") == ["content"]
+    assert _names(bundle, "Document") == ["content", "file_name", "tag"]
+
+
+def test_several_domains_each_get_the_field():
+    assert _names(parse_owl_with_rdflib(ANALYZER_OWL), "Note") == ["tag"]
+
+
+def test_attribute_name_becomes_the_physical_field():
+    bundle = parse_owl_with_rdflib(ANALYZER_OWL)
+    assert bundle.physical_mapping["entities"]["Document"]["properties"] == {
+        "file_name": {"field": "file-name"}
+    }

{arango_query_core-0.2.0 → arango_query_core-0.2.1}/tests/test_owl_turtle_roundtrip.py

@@ -164,3 +164,91 @@ def test_export_label_style() -> None:
     assert pm_p["style"] == "LABEL"
     assert pm_p["typeField"] == "type"
     assert pm_p["typeValue"] == "Person"
+
+
+# ---------------------------------------------------------------------------
+# Property names, shared fields and stored-field names (import fixes)
+# ---------------------------------------------------------------------------
+
+# The layout arangodb-schema-analyzer >= 0.15.1 writes: a field two classes
+# share has an owl:unionOf domain; a renamed or sanitized field carries its
+# stored name in phys:attributeName.
+ANALYZER_OWL = """\
+@prefix : <http://arangodb.com/schema/hybrid#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix phys: <http://arangodb.com/schema/physical#> .
+
+:Chunk a owl:Class ;
+  rdfs:label "Chunk" .
+:Chunk phys:mappingStyle "COLLECTION" .
+:Chunk phys:collectionName "chunks" .
+
+:Document a owl:Class ;
+  rdfs:label "Document" .
+:Document phys:mappingStyle "COLLECTION" .
+:Document phys:collectionName "documents" .
+
+:content a owl:DatatypeProperty ;
+  rdfs:label "content" ;
+  rdfs:domain [ a owl:Class ; owl:unionOf ( :Chunk :Document ) ] .
+
+:file_name a owl:DatatypeProperty ;
+  rdfs:label "file-name" ;
+  rdfs:domain :Document .
+:file_name phys:attributeName "file-name" .
+
+:page_count a owl:DatatypeProperty ;
+  rdfs:label "page_count" ;
+  rdfs:domain :Document ;
+  rdfs:range xsd:integer .
+"""
+
+
+def _props(bundle: MappingBundle, entity: str) -> list[str]:
+    return [
+        p["name"]
+        for e in bundle.conceptual_schema["entities"]
+        if e["name"] == entity
+        for p in e["properties"]
+    ]
+
+
+def test_snake_case_entity_properties_keep_their_names(simple_bundle: MappingBundle) -> None:
+    """Regression: every name was cut at its last underscore (file_name -> name)."""
+    simple_bundle.conceptual_schema["entities"][0]["properties"].append(
+        {"name": "account_id", "type": "string"}
+    )
+    back = turtle_to_mapping(mapping_to_turtle(simple_bundle))
+    assert _props(back, "Person") == ["name", "age", "account_id"]
+
+
+def test_relationship_properties_lose_only_their_prefix(simple_bundle: MappingBundle) -> None:
+    simple_bundle.conceptual_schema["relationships"][0]["properties"] = [
+        {"name": "role_name", "type": "string"}
+    ]
+    back = turtle_to_mapping(mapping_to_turtle(simple_bundle))
+    (rel,) = back.conceptual_schema["relationships"]
+    assert [p["name"] for p in rel["properties"]] == ["role_name"]
+
+
+def test_a_field_with_a_union_domain_belongs_to_every_member() -> None:
+    bundle = turtle_to_mapping(ANALYZER_OWL)
+    assert _props(bundle, "Chunk") == ["content"]
+    assert _props(bundle, "Document") == ["content", "file_name", "page_count"]
+
+
+def test_attribute_name_maps_the_property_to_its_stored_field() -> None:
+    bundle = turtle_to_mapping(ANALYZER_OWL)
+    assert bundle.physical_mapping["entities"]["Document"]["properties"] == {
+        "file_name": {"field": "file-name"}
+    }
+    assert "properties" not in bundle.physical_mapping["entities"]["Chunk"]
+
+
+def test_a_property_declared_once_per_domain_reaches_each(simple_bundle: MappingBundle) -> None:
+    """mapping_to_turtle writes one block per entity for a shared name."""
+    simple_bundle.conceptual_schema["entities"][1]["properties"].append({"name": "name", "type": "string"})
+    back = turtle_to_mapping(mapping_to_turtle(simple_bundle))
+    assert "name" in _props(back, "Person") and "name" in _props(back, "Movie")

arango_query_core-0.2.0/.claude/settings.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh run *)",
-      "Bash(git worktree *)"
-    ]
-  }
-}