s3dgraphy 1.6.0.dev15__tar.gz → 1.6.0.dev16__tar.gz

{s3dgraphy-1.6.0.dev15/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev16}/PKG-INFO

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

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

s3dgraphy-1.6.0.dev16/src/s3dgraphy/JSON_config/acquisition_mappings/uri.json

@@ -0,0 +1,22 @@
+{
+  "mapping_version": "0",
+  "source": "uri",
+  "tier": 0,
+  "_comment": "Per-source acquisition mapping for a BARE URI — the asset nobody downloads. Somebody pastes a link (a IIIF manifest, a Zenodo record, a Sketchfab model, a colleague's WebDAV folder) and what enters the shelf is the URI plus the protocol you reach it through: asset.access = {mode: subscribe|open, endpoint?}. NO BYTES ARE COPIED and no object store is touched — that is the whole point of this mapping, and the difference from fs.json, which acquires a local file. Build the raw record with s3dgraphy.acquisition.uri_record(uri, protocol=..., access=...), then apply_mapping('uri', record). The acquisition method is uri_reference: the URI is what was acquired, not the object, and calling it 'download' would record a retrieval that never happened.",
+  "descriptor_defaults": {
+    "schema_version": "0",
+    "source": {"repo_id": "uri", "capabilities": []},
+    "acquisition": {"agent": "emtools-shelf@0", "method": "uri_reference"},
+    "rights": {"license": "unknown"}
+  },
+  "field_map": {
+    "asset.ref": "uri",
+    "asset.name": "name",
+    "asset.media_type": "media_type",
+    "asset.access": "access",
+    "asset.protocol": "protocol",
+    "source.repo_id": "repo_id",
+    "source.record_id": "record_id",
+    "source.record_url": "record_url"
+  }
+}

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/JSON_config/em_visual_rules.json

@@ -840,7 +840,8 @@
     "acquisition": {
       "download": { "label": "Download", "glyph": null, "description": "Retrieval of a digital object from a remote (opaque, Tier-0) repository." },
       "ingest": { "label": "Ingest", "glyph": null, "description": "Generic ingestion of a digital object into the study." },
-      "local_import": { "label": "Local import", "glyph": null, "description": "Acquisition from the local file system (project-folder search) — the local analog of remote acquisition." }
+      "local_import": { "label": "Local import", "glyph": null, "description": "Acquisition from the local file system (project-folder search) — the local analog of remote acquisition." },
+      "uri_reference": { "label": "URI reference", "glyph": null, "description": "The URI was acquired, not the object: the resource stays where it is and is reached through its own access protocol (an open link, or one you subscribe to). No bytes were copied — calling this a download would record a retrieval that never happened." }
     },
     "output": {
       "pointcloud": { "label": "Point cloud", "glyph": "02_pointcloud", "description": "Produced point cloud." },

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/acquisition/__init__.py

@@ -16,7 +16,8 @@ from .descriptor import (
     AcquisitionError,
     schema,
 )
-from .mapping import apply_mapping, available_mappings, fs_record, load_mapping
+from .mapping import (ACCESS_MODES, apply_mapping, available_mappings,
+                      fs_record, load_mapping, uri_record)
 from .acquire import acquire_from_descriptor
 
 __all__ = [
@@ -28,5 +29,8 @@ __all__ = [
     "apply_mapping",
     "available_mappings",
     "fs_record",
+    # the asset nobody downloads: a URI plus how you reach it
+    "uri_record",
+    "ACCESS_MODES",
     "acquire_from_descriptor",
 ]

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/acquisition/acquire.py

@@ -92,9 +92,19 @@ def acquire_from_descriptor(descriptor: Any, shelf: Any = None
     name = desc.asset.get("name") or (ref.rstrip("/").rsplit("/", 1)[-1] if ref else rid[:8])
     origin = desc.origin()
 
-    # 1) Resource on the shelf (reuse-not-duplicate; origin preserved)
+    # 1) Resource on the shelf (reuse-not-duplicate; origin preserved).
+    #
+    # `media_type` / `size` / `access` are written only when the descriptor
+    # carried them — the fs mapping knows a file's size, a bare URI does not, and
+    # a resource that never said its size must not start claiming zero. They are
+    # here because they are what the shelf TABLE shows: without them the column
+    # would be empty for every entry and a reader would think the shelf lost it.
     entry = add_to_shelf(shelf, ref, resource_id=rid, name=name,
-                         resource_type=_resource_type(desc), origin=origin)
+                         resource_type=_resource_type(desc), origin=origin,
+                         media_type=desc.asset.get("media_type") or None,
+                         size=desc.asset.get("size") or None,
+                         access=origin.get("access"),
+                         role=desc.asset.get("role") or None)
 
     # 2) acquisition event — a distinct DTC event type (crmdig:D12), literals for
     #    the opaque upstream source (Tier 0: no genesis sub-graph)

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/acquisition/descriptor.py

@@ -97,9 +97,27 @@ class AcquisitionDescriptor:
 
     def origin(self) -> Dict[str, Any]:
         """The capability/origin envelope carried onto the shelf entry (for
-        downstream tier badges): repo + capabilities + scope."""
-        return {
+        downstream tier badges): repo + capabilities + scope, and — when the
+        asset says so — how it is REACHED.
+
+        ``access`` rides in the origin rather than in a channel of its own
+        because that is exactly what it is: a fact about where this resource came
+        from and how to get back to it. A URI-only entry has no bytes here, so
+        its origin is the only place that can answer "and how do I open it?".
+        """
+        out: Dict[str, Any] = {
             "repo": self.source.get("repo_id"),
             "capabilities": self.capabilities(),
             "scope": (self.payload_graph or {}).get("scope"),  # None in Tier 0
         }
+        access = self.asset.get("access")
+        if access:
+            out["access"] = (dict(access) if isinstance(access, dict)
+                             else {"mode": str(access)})
+        if self.asset.get("protocol"):
+            out["protocol"] = self.asset.get("protocol")
+        return out
+
+    def access(self) -> Optional[Dict[str, Any]]:
+        """``{mode, endpoint?}`` when the asset declared how it is reached."""
+        return self.origin().get("access")

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/acquisition/mapping.py

@@ -25,7 +25,7 @@ from __future__ import annotations
 import copy
 import json
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 _MAPPINGS_DIR = (Path(__file__).resolve().parent.parent
                  / "JSON_config" / "acquisition_mappings")
@@ -83,6 +83,77 @@ _FS_MEDIA_TYPES = {
 }
 
 
+#: How you get to a resource you did not copy. TWO modes, because the practical
+#: question a colleague asks is binary: can I click this, or do I have to ask
+#: for access?
+#:
+#: * ``open`` — the link is freely reachable;
+#: * ``subscribe`` — you subscribe/register/are granted access first (an
+#:   institutional repository, a shared drive, a IIIF endpoint behind a login).
+#:
+#: This is deliberately NOT a rights statement: `rights.license` says what you
+#: may do with the object, `access.mode` says whether you can reach it at all.
+#: A CC-BY image behind a login is both, and conflating them would make one of
+#: the two unaskable.
+ACCESS_MODES = ("open", "subscribe")
+
+
+def uri_record(uri: str, *, protocol: Optional[str] = None,
+               access: Optional[Any] = None, name: Optional[str] = None,
+               media_type: Optional[str] = None,
+               repo_id: Optional[str] = None) -> Dict[str, Any]:
+    """Build a raw record for the ``uri`` mapping from a bare **URI**.
+
+    The asset nobody downloads: somebody pastes a link and what enters the shelf
+    is the URI plus the protocol it is reached through. **No bytes are copied**
+    and no object store is touched — that is the point, and the difference from
+    :func:`fs_record`.
+
+    ``access`` is ``{"mode": "open"|"subscribe", "endpoint": …}``, or just the
+    mode as a string (the common case). ``record_id`` is the URI itself, so
+    re-acquiring the same link lands on the same stable Resource id and the shelf
+    does not grow a second entry — the idempotence the fs record gets from the
+    absolute path.
+
+    Returns ``{uri, name, protocol, media_type, access, repo_id, record_id,
+    record_url}``.
+    """
+    import mimetypes
+    from urllib.parse import urlsplit
+
+    text = (uri or "").strip()
+    if not text:
+        raise ValueError("a URI-only entry needs a URI")
+    parts = urlsplit(text)
+    scheme = (protocol or parts.scheme or "").lower() or "http"
+    if isinstance(access, str):
+        access = {"mode": access}
+    access = dict(access or {})
+    mode = str(access.get("mode") or "open").lower()
+    if mode not in ACCESS_MODES:
+        raise ValueError(f"access.mode must be one of {list(ACCESS_MODES)}, "
+                         f"got {access.get('mode')!r}")
+    access["mode"] = mode
+    tail = parts.path.rstrip("/").rsplit("/", 1)[-1]
+    guessed = media_type or (_FS_MEDIA_TYPES.get(tail.rsplit(".", 1)[-1].lower())
+                             if "." in tail else None) \
+        or (mimetypes.guess_type(tail)[0] if "." in tail else None) or ""
+    return {
+        "uri": text,
+        # The host is the honest name when the tail is not a filename: a record
+        # page ends in an id, and "12345" is not what anybody is looking for.
+        "name": name or (tail if "." in tail else (parts.netloc or text)),
+        "protocol": scheme,
+        "media_type": guessed,
+        "access": access,
+        # …and the repo is the HOST unless told otherwise, so two links from the
+        # same institution group together without anybody configuring a repo.
+        "repo_id": repo_id or (parts.netloc or "uri"),
+        "record_id": text,
+        "record_url": text,
+    }
+
+
 def fs_record(path: str) -> Dict[str, Any]:
     """Build a raw FILE-SYSTEM record for the ``fs`` mapping from a local ``path``:
     ``{filename, path, record_id, record_url, size, ext, media_type}``. The local

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/api.py

@@ -2060,13 +2060,80 @@ def add_to_shelf(shelf: Graph, locator: str, *, resource_id: Optional[str] = Non
                  name: Optional[str] = None, url_type: Optional[str] = None,
                  description: Optional[str] = None,
                  resource_type: Optional[str] = None,
-                 origin: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """Add a resource to the shelf (reuse-not-duplicate by ``resource_id``);
-    ``origin`` = the capability/origin envelope, preserved. Returns the entry."""
+                 origin: Optional[Dict[str, Any]] = None,
+                 checksum: Optional[str] = None,
+                 scope: Optional[str] = None,
+                 residency: Optional[str] = None,
+                 role: Optional[str] = None,
+                 media_type: Optional[str] = None,
+                 size: Optional[int] = None,
+                 access: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """Add a resource to the shelf (reuse-not-duplicate by ``resource_id`` **or**
+    by ``checksum`` — the same bytes are the same resource); ``origin`` = the
+    capability/origin envelope, preserved. Returns the entry.
+
+    The shelf's own axes are optional and written ONLY when given, because absent
+    means unstated:
+
+    * ``scope`` — the three fences (``own-study`` / ``own-HDT`` / ``other-HDT``);
+    * ``residency`` — ``reference`` (it stays at home) / ``resident`` (I copied it);
+    * ``role`` — what it is FOR: ``comparandum`` / ``internal_source``.
+      **Orthogonal to the other two**: an own-study asset can be a comparandum
+      and an external URI can be a source inside this study's argument, so this
+      is stated and never derived from the fence.
+
+    (These four were already the core's; the api simply did not pass them on, so
+    a caller on this surface could not state a fence at all.)"""
     from .shelf import add_to_shelf as _a
     return _a(shelf, locator, resource_id=resource_id, name=name,
               url_type=url_type, description=description,
-              resource_type=resource_type, origin=origin)
+              resource_type=resource_type, origin=origin, checksum=checksum,
+              scope=scope, residency=residency, role=role,
+              media_type=media_type, size=size, access=access)
+
+
+def resource_roles() -> Tuple[str, ...]:
+    """The two roles a shelf entry may declare, from the class that validates
+    them — so a UI enumerates instead of hardcoding: ``("comparandum",
+    "internal_source")``. Deliberately two; a third case gets declared."""
+    from .nodes.resource_node import ResourceNode
+    return tuple(ResourceNode.ROLES)
+
+
+def shelf_entry_status(subject: Any, resource_id: str) -> Dict[str, Any]:
+    """``{resource_id, in_use, role, mode, used_by}`` for one shelf entry.
+
+    ``subject`` is a Container (the honest unit — a resource is hatted into a
+    STUDY graph while it sits on the SHELF), a Graph, or a list of them.
+
+    DERIVED, not stored: ``in_use`` is the hatting reference-check (the same one
+    the remove-cleanup trusts), and ``mode`` is that fact spelled for a badge
+    (``used_in_graph`` / ``only_shelf``). A stored flag would be wrong the first
+    time somebody deleted the RM that used a photograph."""
+    from .shelf import shelf_entry_status as _s
+    return _s(subject, resource_id)
+
+
+def shelf_table(subject: Any, shelf: Optional[Graph] = None
+                ) -> List[Dict[str, Any]]:
+    """The shelf as **EM Data rows** — one dict per entry, keyed by
+    :func:`shelf_table_columns`.
+
+    A read-model in the em_data formalism (typed columns, like the Units/Epochs/
+    Documents sheets), derived from the ShelfGraph on every call: change the
+    shelf and the table changes. It is NOT a sheet of ``em_data.xlsx`` — that
+    importer fails fast on a missing sheet, so adding one would invalidate every
+    workbook that exists; the shelf's round-trip is the em.json, which already
+    carries it."""
+    from .shelf import shelf_table as _t
+    return _t(subject, shelf)
+
+
+def shelf_table_columns() -> Tuple[str, ...]:
+    """The Shelf sheet's columns, in reading order (what it is → what it is for →
+    where it lives). Same role as :func:`em_data_columns` for the other sheets."""
+    from .shelf import SHELF_COLUMNS
+    return tuple(SHELF_COLUMNS)
 
 
 def list_shelf(shelf: Graph) -> List[Dict[str, Any]]:
@@ -2240,12 +2307,144 @@ def fs_acquisition_record(path: str) -> Dict[str, Any]:
     return fs_record(path)
 
 
+def uri_acquisition_record(uri: str, *, protocol: Optional[str] = None,
+                           access: Any = None, name: Optional[str] = None,
+                           media_type: Optional[str] = None,
+                           repo_id: Optional[str] = None) -> Dict[str, Any]:
+    """Build a raw record for the ``uri`` mapping from a **bare URI** — the asset
+    nobody downloads.
+
+    Somebody pastes a link and what enters the shelf is the URI plus the protocol
+    it is reached through: ``access = {"mode": "open"|"subscribe", "endpoint"?}``
+    (or just the mode as a string). **No bytes are copied and no object store is
+    touched** — that is the point, and the difference from
+    :func:`fs_acquisition_record`.
+
+    Feed it to :func:`apply_acquisition_mapping` with ``"uri"`` and then to
+    :func:`acquire_from_descriptor`: the resource id is derived from the URI, so
+    pasting the same link twice does not grow a second entry."""
+    from .acquisition import uri_record
+    return uri_record(uri, protocol=protocol, access=access, name=name,
+                      media_type=media_type, repo_id=repo_id)
+
+
+def access_modes() -> Tuple[str, ...]:
+    """How a URI-only resource is reached: ``("open", "subscribe")``. Not a
+    rights statement — ``rights.license`` says what you may DO with the object,
+    this says whether you can reach it at all."""
+    from .acquisition import ACCESS_MODES
+    return tuple(ACCESS_MODES)
+
+
 def acquisition_schema() -> Dict[str, Any]:
     """The canonical AcquisitionDescriptor JSON Schema (versioned)."""
     from .acquisition import schema
     return schema()
 
 
+# ── MAPPING AUTHORING: the surface a mapping EDITOR is built on ──────────────
+#
+# The RICH mapping layer, not the acquisition one (`apply_acquisition_mapping`
+# above is the other thing, and the two must not be confused — see
+# `mappings/authoring.py`'s docstring). These five functions are what EMStudio's
+# mapping editor calls over the bridge, and what a chatbot or a script calls
+# directly: one surface, three consumers, no second implementation of "what may
+# this field become".
+
+def mapping_source_fields(path: str, *, format_type: Optional[str] = None,
+                          table: Optional[str] = None,
+                          record_path: Optional[str] = None,
+                          samples: int = 3) -> Dict[str, Any]:
+    """What is in a source, with EXAMPLE VALUES — the list an editor draws.
+
+    A table gives columns; an XML gives paths (`@id`, `rapporti/copre`) plus the
+    repeated elements that are candidates for one RECORD. Samples are the point:
+    half the columns in an archaeological table are called `d_interpretativa`,
+    and the only way to know what one holds is to look at three of its values."""
+    from .mappings.authoring import source_fields
+    return source_fields(path, format_type=format_type, table=table,
+                         record_path=record_path, samples=samples)
+
+
+def mapping_target_catalog(*, include_direct: bool = True) -> List[Dict[str, Any]]:
+    """The CIDOC classes a field may be mapped to, each already resolved to the
+    EM node type that implements it — or marked `cidoc_direct` when none does.
+
+    CIDOC-first with the retro-map (E.D. 2026-08-24): the bridge between the two
+    vocabularies is not a new table, it is the `mapping.cidoc` field the
+    datamodels already declare for every type, read backwards."""
+    from .mappings.authoring import target_catalog
+    return target_catalog(include_direct=include_direct)
+
+
+def mapping_cidoc_index() -> Dict[str, Any]:
+    """The raw inverse index: `{cidoc_class → [candidates]}` and
+    `{cidoc_property → [edges]}`, plus the edges mapped only through an
+    extension property. Many-to-one on purpose — one CIDOC class can be the
+    reading of several EM types."""
+    from .mappings.authoring import cidoc_index
+    return cidoc_index()
+
+
+def mapping_allowed_edges(source_type: Optional[str] = None,
+                          target_type: Optional[str] = None
+                          ) -> List[Dict[str, Any]]:
+    """The edges the datamodel allows between two node types, with their CIDOC
+    property. THE SAME `allowed_connections` the canvas's edge picker reads, so a
+    relation authored in a mapping cannot be one the graph would refuse."""
+    from .mappings.authoring import allowed_edges
+    return allowed_edges(source_type, target_type)
+
+
+def mapping_validate(mapping: Dict[str, Any]) -> Dict[str, Any]:
+    """`{ok, errors, warnings}` for a mapping — structural AND datamodel-checked:
+    a relation whose edge is not allowed between the two resolved types is an
+    ERROR here rather than a failure at import time, long after the person who
+    authored it left the screen."""
+    from .mappings.authoring import validate_mapping
+    return validate_mapping(mapping)
+
+
+def mapping_normalize(mapping: Dict[str, Any]) -> Dict[str, Any]:
+    """A copy of the mapping with its CIDOC choices resolved to EM node types
+    (and the ones nothing implements marked `cidoc_direct`)."""
+    from .mappings.authoring import normalize_mapping
+    return normalize_mapping(mapping)
+
+
+def mapping_apply(mapping: Dict[str, Any], source: str, *, graph: Any = None,
+                  mode: str = "volatile", mapping_name: Optional[str] = None
+                  ) -> Dict[str, Any]:
+    """Run a mapping over a source: `mode="volatile"` (an auxiliary in the graph,
+    out of the saved document until a bake) or `mode="bake"` (written in).
+
+    Named `mapping_apply` and not `apply_mapping` on purpose: this surface
+    already has `apply_acquisition_mapping`, and two different acts sharing one
+    verb is how somebody ends up calling the wrong one. The module-level function
+    IS `apply_mapping` (`mappings.authoring`), where there is no ambiguity."""
+    from .mappings.authoring import apply_mapping
+    return apply_mapping(mapping, source, graph=graph, mode=mode,
+                         mapping_name=mapping_name)
+
+
+def mapping_property_node_type() -> str:
+    """The node type a PROPERTY column produces, read from the datamodel — so an
+    editor says "this field is a property" without typing a class name."""
+    from .mappings.authoring import property_node_type
+    return property_node_type()
+
+
+def mapping_schema_version() -> str:
+    from .mappings.authoring import SCHEMA_VERSION
+    return SCHEMA_VERSION
+
+
+def mapping_formats() -> Tuple[str, ...]:
+    """The source formats a mapping can describe."""
+    from .mappings.authoring import FORMATS
+    return tuple(FORMATS)
+
+
 # ── connection resolution: REPORT-ONLY (S1) ───────────────────────────────────
 # `Graph.validate_connection` is permissive by construction (it resolves the
 # datamodel's CLASS names through the node_type-keyed map). These two ops measure

{s3dgraphy-1.6.0.dev15 → s3dgraphy-1.6.0.dev16}/src/s3dgraphy/importer/base_importer.py

@@ -15,6 +15,36 @@ from typing import Dict, Any, Optional
 # Configurazione logging opzionale per debug
 logger = logging.getLogger(__name__)
 
+def _isna(value) -> bool:
+    """Is this a missing value? — WITHOUT requiring pandas.
+
+    The two row-cleaning helpers below used `pd.isna`, and that made the whole
+    mapping layer depend on pandas even for sources that have nothing to do with
+    a dataframe. Measured: applying an **XML** mapping through the em-bridge
+    failed with `No module named 'pandas'` on every record — and the bridge
+    sidecar excludes pandas ON PURPOSE (it is a 12 MB dependency for the xlsx
+    path alone, see EMStudio's `build-bridge.sh`). So an XML import was
+    impossible in exactly the build meant to run it.
+
+    pandas is still used when it is THERE, because it knows about `NaT`, masked
+    values and numpy scalars, and a hand-rolled check would quietly disagree with
+    it on a dataframe. Absent, the float-NaN identity (`x != x`) is the whole of
+    what a non-dataframe source can produce.
+    """
+    try:
+        import pandas as pd                        # noqa: PLC0415 — optional
+    except ImportError:
+        return value != value if isinstance(value, float) else False
+    try:
+        result = pd.isna(value)
+    except (TypeError, ValueError):
+        return False
+    # pd.isna on a list/array answers elementwise; a row value that is a
+    # sequence is not "missing", and `bool(array)` would raise
+    return bool(result) if isinstance(result, bool) or getattr(
+        result, "ndim", 0) == 0 else False
+
+
 class BaseImporter(ABC):
     """
     Abstract base class for all importers.
@@ -250,11 +280,9 @@ class BaseImporter(ABC):
 
     def _is_invalid_id(self, value) -> bool:
         """Check if a value is invalid (NaN, None, empty string)."""
-        import pandas as pd
-        
         if value is None:
             return True
-        if pd.isna(value):
+        if _isna(value):
             return True
         if str(value).strip() == '':
             return True
@@ -265,9 +293,7 @@ class BaseImporter(ABC):
 
     def _clean_value_for_ui(self, value):
         """Clean any value to be safe for Blender UI (always returns string)."""
-        import pandas as pd
-        
-        if value is None or pd.isna(value):
+        if value is None or _isna(value):
             return ""
         
         # Convert to string and clean