s3dgraphy 1.6.0.dev4__tar.gz → 1.6.0.dev6__tar.gz

{s3dgraphy-1.6.0.dev4/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev4
+Version: 1.6.0.dev6
 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.dev4 → s3dgraphy-1.6.0.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev4"
+version = "1.6.0.dev6"
 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.dev4 → s3dgraphy-1.6.0.dev6}/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.dev4 → s3dgraphy-1.6.0.dev6}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev4 → s3dgraphy-1.6.0.dev6}/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.dev4 → s3dgraphy-1.6.0.dev6}/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
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -389,8 +424,22 @@ class RDFExporter:
     # ── path/format helpers ─────────────────────────────────────────────────
 
     def _adjust_extension(self, path: str) -> str:
+        """Ensure the file path ends with the format-correct extension.
+
+        Defensive against the leading-dot trap: a basename like ".ttl" is
+        treated by pathlib.Path as a hidden-file name (no suffix), so
+        ``with_suffix(".ttl")`` would produce ".ttl.ttl". We detect that case
+        and leave the path untouched if its name IS already the wanted ext.
+        """
         p = Path(path)
-        if p.suffix.lstrip(".").lower() != self.ext:
+
+        # Leading-dot trap: basename equals "." + wanted ext (e.g. ".ttl")
+        # → treat as already correct, don't double-append.
+        if p.name.startswith('.') and p.name.lower().lstrip('.') == self.ext.lower():
+            return str(p)
+
+        current_ext = p.suffix.lstrip(".").lower()
+        if current_ext != self.ext.lower():
             return str(p.with_suffix("." + self.ext))
         return str(p)
 
@@ -507,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],
@@ -533,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)))
 

{s3dgraphy-1.6.0.dev4 → s3dgraphy-1.6.0.dev6}/src/s3dgraphy/importer/pyarchinit_importer.py

@@ -14,30 +14,100 @@ from ..multigraph.multigraph import multi_graph_manager
 
 # Conservative SQLite identifier whitelist: letters, digits, underscore.
 # Used to guard table names and filter column names interpolated into
-# query strings (values always go through ? parameter binding).
+# query strings (values always go through paramstyle binding).
 _SAFE_IDENT_RE = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$')
 
+# Recognized connection URL prefixes for dialect detection.
+_PG_URL_PREFIXES = ("postgresql://", "postgresql+psycopg2://",
+                    "postgres://")
+_SQLITE_URL_PREFIX = "sqlite:///"
+
+
 class PyArchInitImporter(BaseImporter):
-    def __init__(self, filepath: str, mapping_name: str, overwrite: bool = False,
-                existing_graph=None, filters: Optional[Dict[str, Any]] = None):
+    def __init__(self, filepath: Optional[str] = None,
+                 mapping_name: str = None, overwrite: bool = False,
+                 existing_graph=None,
+                 filters: Optional[Dict[str, Any]] = None,
+                 *,
+                 connection_url: Optional[str] = None):
         """
         Initialize pyArchInit importer with mapping configuration.
 
         Args:
-            filepath: Path to the SQLite database
-            mapping_name: Name of the JSON mapping file to use
-            overwrite: If True, overwrites existing nodes
+            filepath: Path to a SQLite database (legacy / default path).
+                Mutually exclusive with ``connection_url``. When given,
+                it is internally promoted to ``sqlite:///<abspath>`` so
+                downstream code uses a single URL-based representation.
+            mapping_name: Name of the JSON mapping file to use.
+            overwrite: If True, overwrites existing nodes.
             existing_graph: Existing graph instance to use.
-                        If None, creates new unregistered graph with temporary ID.
-                        The caller (EM-tools) is responsible for setting proper graph_id
-                        and registering it in MultiGraphManager.
-            filters: Optional dict of {column_name: value} to restrict the
-                imported rows. Combined with AND. Each column is whitelisted
-                against the mapping's column_mappings, then bound as a
-                parameterized SQL value — safe against injection.
+                If None, creates new unregistered graph with temporary
+                ID. The caller (EM-tools) is responsible for setting
+                proper graph_id and registering it in
+                MultiGraphManager.
+            filters: Optional dict of {column_name: value} to restrict
+                the imported rows. Combined with AND. Each column is
+                whitelisted against the mapping's column_mappings, then
+                bound as a parameterized SQL value — safe against
+                injection. Placeholder syntax adapts to the dialect
+                (``?`` on SQLite, ``%s`` on PostgreSQL).
+            connection_url: SQLAlchemy-style connection URL. Mutually
+                exclusive with ``filepath``. Supported schemes:
+                ``sqlite:///<abspath>``,
+                ``postgresql://user:pass@host:port/dbname`` (or the
+                ``postgres://`` alias / ``postgresql+psycopg2://`` form).
+                For PostgreSQL, ``psycopg2-binary`` must be installed
+                (``pip install s3dgraphy[postgres]``); a friendly
+                ``ImportError`` fires on first connection attempt if
+                it isn't.
+
+        Raises:
+            ValueError: If both ``filepath`` and ``connection_url`` are
+                given, if neither is given, or if ``connection_url``
+                uses an unsupported scheme.
         """
+        # Mutually exclusive + at-least-one validation.
+        if filepath is not None and connection_url is not None:
+            raise ValueError(
+                "Pass either filepath= or connection_url=, not both."
+            )
+        if filepath is None and connection_url is None:
+            raise ValueError(
+                "Either filepath= or connection_url= is required."
+            )
+
+        # Resolve dialect + canonical URL + the path-or-URL string we
+        # hand to BaseImporter as `filepath` (diagnostic-friendly).
+        if filepath is not None:
+            abs_path = os.path.abspath(filepath)
+            self._dialect = "sqlite"
+            self._connection_url = f"{_SQLITE_URL_PREFIX}{abs_path}"
+            _base_filepath = filepath
+        else:
+            if connection_url.startswith(_PG_URL_PREFIXES):
+                self._dialect = "postgres"
+            elif connection_url.startswith(_SQLITE_URL_PREFIX):
+                self._dialect = "sqlite"
+            else:
+                raise ValueError(
+                    "Unsupported connection_url scheme: "
+                    f"{connection_url!r}. "
+                    "Use sqlite:///<path>, postgresql://..., "
+                    "or postgres://..."
+                )
+            self._connection_url = connection_url
+            # BaseImporter uses filepath for diagnostics + abspath
+            # normalization. SQLite URLs reduce to a real path; PG URLs
+            # are passed through verbatim.
+            if self._dialect == "sqlite":
+                _base_filepath = connection_url[
+                    len(_SQLITE_URL_PREFIX):
+                ]
+            else:
+                _base_filepath = connection_url
+
         super().__init__(
-            filepath=filepath,
+            filepath=_base_filepath,
             mapping_name=mapping_name,
             overwrite=overwrite,
             filters=filters,
@@ -65,6 +135,61 @@ class PyArchInitImporter(BaseImporter):
 
         self.validate_mapping()
 
+    # ------------------------------------------------------------------
+    # Backend abstraction (#9 multi-backend)
+    # ------------------------------------------------------------------
+    def _connect(self):
+        """Open a DB-API 2 connection for the active dialect.
+
+        Returns a connection that the caller must close. For SQLite,
+        uses the stdlib ``sqlite3``. For PostgreSQL, uses
+        ``psycopg2`` and raises a friendly ``ImportError`` if the
+        extras are missing.
+        """
+        if self._dialect == "sqlite":
+            return sqlite3.connect(self.filepath)
+        # PostgreSQL path. Probe psycopg2 lazily so SQLite-only
+        # callers never pay the import cost (and don't need the wheel).
+        try:
+            import psycopg2  # noqa: F401
+        except ImportError as e:  # pragma: no cover
+            raise ImportError(
+                "PostgreSQL backend requires psycopg2-binary. "
+                "Install via: pip install s3dgraphy[postgres]"
+            ) from e
+        import psycopg2
+        return psycopg2.connect(self._psycopg2_dsn())
+
+    def _psycopg2_dsn(self) -> str:
+        """Normalize the connection URL for ``psycopg2.connect()``.
+
+        ``psycopg2`` doesn't understand SQLAlchemy-style driver
+        suffixes (e.g. ``postgresql+psycopg2://``): it parses the
+        scheme literally and rejects the ``+psycopg2`` part with
+        "invalid dsn". The write side of the bridge
+        (``s3dgraphy.sync`` via SQLAlchemy) naturally produces those
+        URLs, so a caller wiring the *same* connection string into
+        both the read side (here) and the write side would otherwise
+        hit a silent failure on the read.
+
+        Stripping the ``+<driver>`` token lets one URL flow into both
+        without every caller having to know the dialect-prefix
+        convention. ``postgresql+psycopg2://`` → ``postgresql://`` and
+        ``postgres+psycopg2://`` → ``postgres://`` — both accepted by
+        psycopg2. Plain ``postgresql://`` / ``postgres://`` pass
+        through untouched.
+        """
+        url = self._connection_url
+        scheme, sep, rest = url.partition("://")
+        if sep and "+" in scheme:
+            scheme = scheme.split("+", 1)[0]
+            return f"{scheme}://{rest}"
+        return url
+
+    def _qmark(self) -> str:
+        """Parameter placeholder for the active dialect (``?`` / ``%s``)."""
+        return "?" if self._dialect == "sqlite" else "%s"
+
     def _resolve_node_name(self, row_dict: Dict[str, Any], id_column: str) -> str:
         """Compose the human-readable node name for ``row_dict``.
 
@@ -296,12 +421,13 @@ class PyArchInitImporter(BaseImporter):
 
         where_fragments = []
         params: List[Any] = []
+        qmark = self._qmark()
         for col, value in self.filters.items():
             # Defense in depth: validate against mapping + ident regex.
             self._validate_filter_column(col)
             if not self._is_safe_identifier(col):
                 raise ValueError(f"Unsafe filter column name: {col!r}")
-            where_fragments.append(f"{col} = ?")
+            where_fragments.append(f"{col} = {qmark}")
             params.append(value)
 
         where_clause = " AND ".join(where_fragments)
@@ -325,7 +451,7 @@ class PyArchInitImporter(BaseImporter):
             raise ValueError(f"Unsafe column name: {column!r}")
         table_name = self._get_table_name()
 
-        conn = sqlite3.connect(self.filepath)
+        conn = self._connect()
         try:
             cursor = conn.cursor()
             cursor.execute(
@@ -340,7 +466,7 @@ class PyArchInitImporter(BaseImporter):
         """Parse pyArchInit database using mapping configuration"""
         try:
             # print("\n=== Starting PyArchInit Import ===")
-            conn = sqlite3.connect(self.filepath)
+            conn = self._connect()
             cursor = conn.cursor()
             
             # Debug del mapping