s3dgraphy 1.6.0.dev5__tar.gz → 1.6.0.dev7__tar.gz

{s3dgraphy-1.6.0.dev5/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev5
+Version: 1.6.0.dev7
 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>
@@ -43,6 +43,10 @@ Requires-Dist: pyoxigraph>=0.4; extra == "rdf-embedded"
 Provides-Extra: visualization
 Requires-Dist: matplotlib>=3.0; extra == "visualization"
 Requires-Dist: plotly>=5.0; extra == "visualization"
+Provides-Extra: sync
+Requires-Dist: sqlalchemy>=2.0; extra == "sync"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9; extra == "postgres"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -57,9 +61,9 @@ Requires-Dist: sphinx>=5.0; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: myst-parser; extra == "docs"
 Provides-Extra: full
-Requires-Dist: s3dgraphy[rdf-embedded,visualization]; extra == "full"
+Requires-Dist: s3dgraphy[rdf-embedded,sync,visualization]; extra == "full"
 Provides-Extra: all
-Requires-Dist: s3dgraphy[dev,docs,full]; extra == "all"
+Requires-Dist: s3dgraphy[dev,docs,full,postgres]; extra == "all"
 Dynamic: license-file
 
 # s3dgraphy

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev5"
+version = "1.6.0.dev7"
 description = "3D Stratigraphic Graph Management Library for archaeological and heritage applications"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -92,6 +92,20 @@ visualization = [
     "matplotlib>=3.0",
     "plotly>=5.0",
 ]
+sync = [
+    # Backend-agnostic SQL bridge (s3dgraphy.sync) — bidirectional
+    # ingestion + projection between a Graph and the host application's
+    # SQL tables. SQLite works out of the box; add the [postgres] extra
+    # for the PostgreSQL backend. Moved from pyArchInit in 1.6.0
+    # (zalmoxes-laran/s3Dgraphy#10).
+    "sqlalchemy>=2.0",
+]
+postgres = [
+    # PostgreSQL backend driver. Combine with [sync] for the SQL bridge
+    # (zalmoxes-laran/s3Dgraphy#9 + #10). Standalone, it also enables
+    # the PG path of PyArchInitImporter when that lands.
+    "psycopg2-binary>=2.9",
+]
 dev = [
     "pytest>=7.0",
     "pytest-cov",
@@ -111,10 +125,10 @@ docs = [
 # without the dev/docs tooling. The dev/docs/test stacks stay separate
 # so CI-style installs don't pull editor/QA deps.
 full = [
-    "s3dgraphy[rdf-embedded,visualization]",
+    "s3dgraphy[rdf-embedded,visualization,sync]",
 ]
 all = [
-    "s3dgraphy[full,dev,docs]",
+    "s3dgraphy[full,dev,docs,postgres]",
 ]
 
 [tool.setuptools.packages.find]

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/JSON_config/em_visual_rules.json

@@ -1,7 +1,8 @@
 {
   "formal_language": "EM",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "_changelog": {
+    "1.5.3": "Fix USD / serUSD material colour: RGB was (0.549, 0.103, 0.0) = #8C1A00 (red), should be #D86400 (orange) to match the canonical USD documentary colour used in the GraphML palette template, node_registry defaults and document_variant_styles.observable. USD border_color also corrected from #8C1A00 to #D86400 (serUSD border was already correct).",
     "1.5.2": "Added RSF (Reused Special Find / spolia) node style — octagon, red border (#9B3333), white fill. Sibling of SF/VSF, distinguished by border colour. Originating DP: DP-26.",
     "1.5.1": "Added LocationNodeGroup node style (dashed roundrectangle, kind-based border colour) and is_in_location edge style with primary_modifier override.",
     "1.5.0": "Initial EM 1.5 visual rules."
@@ -133,13 +134,13 @@
       "style": {
         "material": {
           "color": {
-            "r": 0.549,
-            "g": 0.103,
+            "r": 0.847,
+            "g": 0.392,
             "b": 0.0,
             "a": 1.0
           }
         },
-        "border_color": "#8C1A00",
+        "border_color": "#D86400",
         "fill_color": "#F5F5F5",
         "border_style": "solid",
         "shape": "rounded_rectangle"
@@ -173,8 +174,8 @@
       "style": {
         "material": {
           "color": {
-            "r": 0.549,
-            "g": 0.103,
+            "r": 0.847,
+            "g": 0.392,
             "b": 0.0,
             "a": 1.0
           }

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/canvas_generator.py

@@ -68,7 +68,7 @@ class CanvasGenerator:
         return root
 
     def _add_node_keys(self, root: ET.Element):
-        """Add key definitions for nodes (d4-d8)."""
+        """Add key definitions for nodes (d4-d8, d13)."""
         # d4: url
         key = ET.SubElement(root, '{http://graphml.graphdrawing.org/xmlns}key')
         key.set('attr.name', 'url')
@@ -104,6 +104,27 @@ class CanvasGenerator:
         key.set('for', 'node')
         key.set('id', 'd8')
 
+        # d13: physical_relationships (EM 1.6 per-node packed string)
+        #
+        # Per-node serialisation of the canonical physical stratigraphic
+        # edges, in the same list-of-lists Python-literal format used by
+        # the pyArchInit ``us_table.rapporti`` column. yEd reserves edges
+        # for the temporal Matrix layer, so the EM 1.6 palette surfaces
+        # these relationships as a per-node attribute instead — visible
+        # to humans editing the file in yEd, and byte-identical with the
+        # pyArchInit column when the graph between them is unmutated.
+        #
+        # The exporter writes this attribute on every stratigraphic node
+        # whose canonical edges include physical-stratigraphic types;
+        # the importer reads it only when the richer graph-level JSON
+        # side channel (``_s3d_physical_relations``) is absent. See
+        # ``s3dgraphy.sync.rapporti`` for the canonical vocabulary.
+        key = ET.SubElement(root, '{http://graphml.graphdrawing.org/xmlns}key')
+        key.set('attr.name', 'physical_relationships')
+        key.set('attr.type', 'string')
+        key.set('for', 'node')
+        key.set('id', 'd13')
+
     def _add_edge_keys(self, root: ET.Element):
         """Add key definitions for edges (d10-d12)."""
         # d10: edgegraphics (yfiles)

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/graphml_exporter.py

@@ -142,6 +142,40 @@ class GraphMLExporter:
         # side channel restores all three on import.
         self._write_property_metadata_data(graph_elem, canvas)
 
+        # 1d. Snapshot per-US-node physical_relationships (the EM 1.6
+        # palette per-node packed string format, byte-identical with the
+        # pyArchInit ``us_table.rapporti`` column). Computed BEFORE the
+        # transitive reduction below so the canonical edges are still
+        # present; stashed for NodeGenerator to attach as ``<data
+        # key="d13">`` on each stratigraphic node. See
+        # ``s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`` for
+        # the format and ``canvas_generator._add_node_keys`` (d13) for
+        # the key declaration.
+        try:
+            from ...sync.rapporti import serialize_rapporti_from_edges
+            # Pick the site name to stamp into the 4th column of each
+            # rapporto entry. Graph.__init__ stores the caller-supplied
+            # identifier on ``graph_id`` and leaves ``name`` empty by
+            # default, so ``graph_id`` is the most reliable signal in
+            # practice — but we still consult ``name`` / ``sito`` for
+            # consumers that populate them explicitly.
+            default_sito = (
+                getattr(self.graph, "graph_id", None)
+                or getattr(self.graph, "name", None)
+                or getattr(self.graph, "sito", None)
+                or ""
+            )
+            # ``name`` may be a dict in the s3dgraphy Graph schema; only
+            # str values are valid for the pyArchInit column.
+            if not isinstance(default_sito, str):
+                default_sito = ""
+            self._physical_relationships_by_node: Dict[str, list] = (
+                serialize_rapporti_from_edges(self.graph, default_sito))
+        except Exception as exc:  # pragma: no cover - defensive
+            print(f"  [physical_relationships] skipped serialization: "
+                  f"{exc}")
+            self._physical_relationships_by_node = {}
+
         # Allocate palette refids starting from 4 (1-3 are reserved for
         # SVG extractor/combiner/continuity emitted by CanvasGenerator).
         # Populated as AuthorNode / LicenseNode / EmbargoNode instances
@@ -150,7 +184,10 @@ class GraphMLExporter:
         self._next_palette_refid: int = 4
 
         # 2. Initialize generators
-        node_gen = NodeGenerator(self.node_registry, self.id_manager)
+        node_gen = NodeGenerator(
+            self.node_registry, self.id_manager,
+            physical_relationships_by_node=self._physical_relationships_by_node,
+        )
         group_gen = GroupNodeGenerator(self.node_registry, self.id_manager)
         edge_gen = EdgeGenerator(self.id_manager)
 

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/node_generator.py

@@ -15,17 +15,30 @@ from .utils import IDManager, calculate_node_width, generate_uuid
 class NodeGenerator:
     """Generates GraphML XML for various node types."""
 
-    def __init__(self, registry: NodeRegistry, id_manager: IDManager):
+    def __init__(self, registry: NodeRegistry, id_manager: IDManager,
+                 physical_relationships_by_node: Optional[dict] = None):
         """
         Initialize node generator.
-        
+
         Args:
             registry: Node registry with visual properties
             id_manager: ID manager for nested IDs
+            physical_relationships_by_node: Optional pre-computed dict
+                mapping ``node_id`` → list of
+                ``[label, target_us, area, sito]`` entries (the
+                pyArchInit list-of-lists serialisation produced by
+                :func:`s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`).
+                When provided, ``generate_stratigraphic_node`` emits a
+                ``<data key="d13">`` element with the Python-literal
+                ``repr`` of the entry list — the EM 1.6 palette format
+                for per-node physical relationships. Unknown / missing
+                node ids are silently ignored.
         """
         self.registry = registry
         self.id_manager = id_manager
         self.ns_y = 'http://www.yworks.com/xml/graphml'
+        self._physical_relationships_by_node = (
+            physical_relationships_by_node or {})
 
     def generate_stratigraphic_node(self, node, x: float = 100.0, y: float = 100.0,
                                     parent_id: Optional[str] = None) -> ET.Element:
@@ -72,7 +85,24 @@ class NodeGenerator:
         data_d7 = ET.SubElement(node_elem, '{http://graphml.graphdrawing.org/xmlns}data')
         data_d7.set('key', 'd7')
         data_d7.text = node_uuid
-        
+
+        # Add physical_relationships (d13) — EM 1.6 per-node packed
+        # string. The exporter pre-computes a dict ``node_id → list``
+        # using :func:`s3dgraphy.sync.rapporti.serialize_rapporti_from_edges`
+        # before the transitive reduction collapses canonical edges, and
+        # passes it in via ``__init__``. The on-disk format is the
+        # Python literal ``repr`` of the list-of-lists, byte-identical
+        # with the pyArchInit ``us_table.rapporti`` column when the
+        # graph between them is unmutated.
+        rapporti_entries = self._physical_relationships_by_node.get(
+            node_uuid)
+        if rapporti_entries:
+            data_d13 = ET.SubElement(
+                node_elem,
+                '{http://graphml.graphdrawing.org/xmlns}data')
+            data_d13.set('key', 'd13')
+            data_d13.text = repr(rapporti_entries)
+
         # Add nodegraphics (d6) - ShapeNode
         data_d6 = ET.SubElement(node_elem, '{http://graphml.graphdrawing.org/xmlns}data')
         data_d6.set('key', 'd6')

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/graphml/node_registry.py

@@ -236,33 +236,42 @@ class NodeRegistry:
                 )
 
             # Sanity-check the canonical stratigraphic types are all present.
+            # Caller paths (NodeGenerator, GraphmlPatcher) already fall back to
+            # the 'US' stencil — or to inline defaults — when a single type is
+            # missing, so we only emit a diagnostic here.
             missing = sorted(_REQUIRED_PALETTE_TYPES - set(self.visual_properties))
             for em_type in missing:
                 warnings.warn(
                     f"s3dgraphy: palette template did not yield a stencil "
-                    f"for stratigraphic type {em_type!r}. Falling back to "
-                    "the hardcoded default visual properties. Verify that "
-                    "the palette template still contains the expected "
-                    "NodeLabel (USM01, USM02, USD10, USDxx ellipse for "
-                    "serUSD, USV100, USV102, USV106, SF01, VSF01, RSF01, "
-                    "TSU) or extend node_registry._PALETTE_DISPATCH_RULES.",
+                    f"for stratigraphic type {em_type!r}. Callers will fall "
+                    "back to the 'US' stencil. Verify that the palette "
+                    "template still contains the expected NodeLabel (USM01, "
+                    "USM02, USD10, USDxx ellipse for serUSD, USV100, USV102, "
+                    "USV106, SF01, VSF01, RSF01, TSU) or extend "
+                    "node_registry._PALETTE_DISPATCH_RULES.",
                     S3DgraphyPaletteWarning,
                     stacklevel=2,
                 )
-            if missing:
-                # Backfill the missing ones from the hardcoded defaults so
-                # callers never get None for a known stratigraphic type.
-                defaults = self._default_visual_properties_dict()
-                for em_type in missing:
-                    if em_type in defaults:
-                        self.visual_properties[em_type] = defaults[em_type]
 
         except (FileNotFoundError, ModuleNotFoundError) as e:
-            print(f"[s3dgraphy] Warning: Palette template not found: {type(e).__name__}: {e}")
-            self._load_default_visual_properties()
+            # The palette template is bundled with the package — its absence
+            # is a packaging/install bug, not a runtime condition we should
+            # paper over with hardcoded constants that can silently drift
+            # from the canonical palette. Fail loud.
+            raise RuntimeError(
+                "s3dgraphy: palette template "
+                "'templates/em_palette_template.graphml' is missing from "
+                f"the installed package ({type(e).__name__}: {e}). "
+                "GraphML export cannot proceed without it — reinstall "
+                "s3dgraphy or check the package data."
+            ) from e
         except Exception as e:
-            print(f"[s3dgraphy] Warning: Error loading palette template: {e}")
-            self._load_default_visual_properties()
+            # Same rationale: a corrupt template is a packaging issue, not
+            # something to silently swallow.
+            raise RuntimeError(
+                "s3dgraphy: failed to parse palette template "
+                f"'templates/em_palette_template.graphml': {e}"
+            ) from e
 
     def _extract_visual_properties(self, node_elem: ET.Element, ns: Dict) -> Optional[NodeVisualProperties]:
         """Extract visual properties from a palette node element."""
@@ -308,28 +317,6 @@ class NodeRegistry:
             print(f"Warning: Error extracting visual properties: {e}")
             return None
 
-    @staticmethod
-    def _default_visual_properties_dict() -> Dict[str, NodeVisualProperties]:
-        """Hardcoded default visual properties (used as fallback)."""
-        return {
-            'US': NodeVisualProperties('rectangle', '#FFFFFF', '#9B3333', 'line', 4.0, '#000000'),
-            'USVs': NodeVisualProperties('parallelogram', '#000000', '#248FE7', 'line', 4.0, '#FFFFFF'),
-            'USVn': NodeVisualProperties('hexagon', '#000000', '#31792D', 'line', 4.0, '#FFFFFF'),
-            'SF': NodeVisualProperties('octagon', '#FFFFFF', '#D8BD30', 'line', 4.0, '#000000'),
-            'VSF': NodeVisualProperties('octagon', '#000000', '#B19F61', 'line', 4.0, '#FFFFFF'),
-            'RSF': NodeVisualProperties('octagon', '#FFFFFF', '#9B3333', 'line', 4.0, '#000000'),
-            'USD': NodeVisualProperties('roundrectangle', '#FFFFFF', '#D86400', 'line', 4.0, '#000000'),
-            'serSU': NodeVisualProperties('ellipse', '#FFFFFF', '#9B3333', 'line', 4.0, '#000000'),
-            'serUSD': NodeVisualProperties('ellipse', '#FFFFFF', '#D86400', 'line', 4.0, '#000000'),
-            'serUSVn': NodeVisualProperties('ellipse', '#000000', '#31792D', 'line', 4.0, '#FFFFFF'),
-            'serUSVs': NodeVisualProperties('ellipse', '#000000', '#248FE7', 'line', 4.0, '#FFFFFF'),
-            'TSU': NodeVisualProperties('roundrectangle', '#FFFFFF', '#9B3333', 'dashed', 4.0, '#000000'),
-        }
-
-    def _load_default_visual_properties(self):
-        """Load hardcoded default visual properties as fallback."""
-        self.visual_properties = self._default_visual_properties_dict()
-
     def get_visual_properties(self, node_type: str) -> Optional[NodeVisualProperties]:
         """
         Get visual properties for a node type.

{s3dgraphy-1.6.0.dev5 → s3dgraphy-1.6.0.dev7}/src/s3dgraphy/exporter/rdf_exporter.py

@@ -259,10 +259,45 @@ class _Datamodel:
         return _resolve_prefixed(cidoc), None, deprecated
 
     def get_qualia_crm_iri(self, property_type: Optional[str]) -> Optional[URIRef]:
+        """Resolve a property_type string to its CIDOC class IRI.
+
+        Lookup strategy (graceful, three steps):
+          1. Exact match against em_qualia_types.json `id` (e.g.
+             "absolute_time_start", "height", "color").
+          2. Last segment after dot — handles EM yEd convention where
+             properties are labelled with a category prefix
+             (e.g. "Dimension.height" → "height", "Spatial.elevation" →
+             "elevation").
+          3. Lowercase match — handles minor case mismatches between
+             graphml labels and qualia ids (e.g. "Height" → "height").
+
+        Returns None if no strategy matches; the caller (typically
+        ``_compute_primary_iri``) falls back to the generic PropertyNode
+        default mapping.
+        """
         if not property_type:
             return None
+        # 1) Exact match
         crm = self._qualia_class_index.get(property_type)
-        return _resolve_prefixed(crm)
+        if crm:
+            return _resolve_prefixed(crm)
+        # 2) Last segment after dot (yEd category prefix convention)
+        if "." in property_type:
+            tail = property_type.rsplit(".", 1)[-1]
+            crm = self._qualia_class_index.get(tail)
+            if crm:
+                return _resolve_prefixed(crm)
+        # 3) Lowercase fallback
+        crm = self._qualia_class_index.get(property_type.lower())
+        if crm:
+            return _resolve_prefixed(crm)
+        # 4) Combined: lowercase last segment
+        if "." in property_type:
+            tail_lower = property_type.rsplit(".", 1)[-1].lower()
+            crm = self._qualia_class_index.get(tail_lower)
+            if crm:
+                return _resolve_prefixed(crm)
+        return None
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -521,23 +556,44 @@ class RDFExporter:
         Resolve the rdf:type primary IRI for a node, applying conditional rules.
 
         Conditional rule for PropertyNode:
-            The qualia-type-specific class (looked up in em_qualia_types.json
-            by `node.property_type`) takes precedence over the generic
-            PropertyNode default class (typically crm:E54_Dimension).
-            Without this, an aesthetic_value property would be typed as BOTH
-            crm:E54_Dimension (PropertyNode default) and crminf:I4_Proposition_Set
-            (qualia-specific), which is semantically misleading: aesthetic
-            value is NOT a dimension.
-
-        Fallback for all other node types and for PropertyNode with unknown
-        property_type: the em_extension.uri or mapping.cidoc declared in the
-        node datamodel.
+            The qualia-type-specific class (looked up in em_qualia_types.json)
+            takes precedence over the generic PropertyNode default class
+            (typically crm:E54_Dimension). Without this, an aesthetic_value
+            property would be typed as BOTH crm:E54_Dimension (PropertyNode
+            default) and crminf:I4_Proposition_Set (qualia-specific), which is
+            semantically misleading: aesthetic value is NOT a dimension.
+
+        Lookup key resolution (PropertyNode):
+            The s3dgraphy graphml importer preserves raw graphml data
+            (``node.name`` carries the NodeLabel, ``node.property_type`` is
+            the default "string" unless populated by the
+            ``_s3d_property_metadata`` side channel). To enrich at export
+            time without burdening the importer with vocabulary knowledge,
+            we try the lookup key in this order:
+              1. ``node.property_type`` if explicitly set (not "string")
+              2. ``node.name`` if available (the yEd NodeLabel — qualia
+                 identifier in EM convention)
+            Either string is resolved through the multi-step graceful
+            matcher in ``_Datamodel.get_qualia_crm_iri`` (exact / dot-split
+            / lowercase). Falls back to the generic node datamodel mapping
+            when no qualia term matches (e.g. custom labels like
+            "lenght_pipe" stay as em:Qualia + crm:E1_CRM_Entity).
         """
         if node_type == "property":
             ptype = getattr(node, "property_type", None)
-            qualia_iri = self.datamodel.get_qualia_crm_iri(ptype)
-            if qualia_iri is not None:
-                return qualia_iri
+            # Treat the default "string" sentinel as "unset" — the importer
+            # leaves it on the PropertyNode constructor default when no
+            # side-channel metadata is present.
+            if ptype and ptype.lower() != "string":
+                qualia_iri = self.datamodel.get_qualia_crm_iri(ptype)
+                if qualia_iri is not None:
+                    return qualia_iri
+            # Fall back to NodeLabel (em yEd convention: label IS the qualia id)
+            name = getattr(node, "name", None)
+            if name:
+                qualia_iri = self.datamodel.get_qualia_crm_iri(name)
+                if qualia_iri is not None:
+                    return qualia_iri
         return self.datamodel.get_node_primary_iri(cls_name)
 
     def _serialize_type_specific(self, node: Any, node_type: Optional[str],
@@ -547,10 +603,22 @@ class RDFExporter:
         if node_type == "property":
             # rdf:type already emitted by _compute_primary_iri (qualia-specific
             # class takes precedence over PropertyNode default).
+            #
+            # Value resolution: prefer node.value when set & non-empty;
+            # fall back to node.description for legacy graphml where the
+            # description data field encodes the value (yEd has no separate
+            # "value" socket on annotation-style PropertyNodes).
+            raw_value = getattr(node, "value", None)
+            if raw_value is None or (isinstance(raw_value, str) and not raw_value.strip()):
+                raw_value = getattr(node, "description", None)
+            if raw_value is not None and (not isinstance(raw_value, str) or raw_value.strip()):
+                ctx.add((node_iri, CRM.P90_has_value, Literal(raw_value)))
+
+            # Qualia type identifier — same key resolution as _compute_primary_iri:
+            # property_type if non-default, otherwise the NodeLabel (name).
             ptype = getattr(node, "property_type", None)
-            value = getattr(node, "value", None)
-            if value is not None:
-                ctx.add((node_iri, CRM.P90_has_value, Literal(value)))
+            if not ptype or ptype.lower() == "string":
+                ptype = getattr(node, "name", None)
             if ptype:
                 ctx.add((node_iri, EM.hasQualiaType, Literal(ptype)))