s3dgraphy 1.6.0.dev58__tar.gz → 1.6.0.dev59__tar.gz

{s3dgraphy-1.6.0.dev58/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev58
+Version: 1.6.0.dev59
 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>
@@ -48,8 +48,8 @@ Provides-Extra: sync
 Requires-Dist: sqlalchemy>=2.0; extra == "sync"
 Provides-Extra: postgres
 Requires-Dist: psycopg2-binary>=2.9; extra == "postgres"
-Provides-Extra: minio
-Requires-Dist: minio>=7.0; extra == "minio"
+Provides-Extra: s3
+Requires-Dist: boto3>=1.34; extra == "s3"
 Provides-Extra: geo
 Requires-Dist: pyproj>=3.4; extra == "geo"
 Provides-Extra: pdf
@@ -70,7 +70,7 @@ 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[geo,minio,rdf-embedded,sync,visualization]; extra == "full"
+Requires-Dist: s3dgraphy[geo,rdf-embedded,s3,sync,visualization]; extra == "full"
 Provides-Extra: all
 Requires-Dist: s3dgraphy[dev,docs,full,postgres]; extra == "all"
 Dynamic: license-file

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev58"
+version = "1.6.0.dev59"
 description = "3D Stratigraphic Graph Management Library for archaeological and heritage applications"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -113,12 +113,13 @@ postgres = [
     # the PG path of PyArchInitImporter when that lands.
     "psycopg2-binary>=2.9",
 ]
-minio = [
-    # MinIO / S3 object-storage backend for the Resource layer
-    # (s3dgraphy.resources.minio_backend, R2). Without this extra, constructing
+s3 = [
+    # S3 object-storage backend for the Resource layer, any S3-compatible
+    # endpoint (RustFS in the dev stack) through boto3
+    # (s3dgraphy.resources.s3_backend, R2). Without this extra, constructing
     # a client / ingesting raises MissingDependency (like rdflib for TTL);
     # resolve()/manifest work dep-free on an already-populated index.
-    "minio>=7.0",
+    "boto3>=1.34",
 ]
 geo = [
     # Coordinate reprojection for api.reproject / api.georeference_scene (G1).
@@ -178,7 +179,7 @@ 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,sync,minio,geo]",
+    "s3dgraphy[rdf-embedded,visualization,sync,s3,geo]",
 ]
 all = [
     "s3dgraphy[full,dev,docs,postgres]",

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/JSON_config/em.ttl

@@ -874,7 +874,7 @@ em:hasAddress
     a owl:ObjectProperty ;
     rdfs:label "has address"@en ;
     rdfs:domain crm:E73_Information_Object ;
-    rdfs:comment "One of the places where the SAME bytes of a resource can be fetched — the same digest on the disk, on MinIO, on Zenodo: identical copies are one resource with several addresses, and losing one address does not lose the resource. The object is a derived IRI <resource>/address/<i>, number 0 being the resource's url; every locator is also an rdfs:seeAlso of the resource, so a reader that knows nothing of EM finds every copy. Different manifestations are not addresses but sister resources. Maps to: node_datamodel ResourceNode.properties.addresses (data.addresses)."@en .
+    rdfs:comment "One of the places where the SAME bytes of a resource can be fetched — the same digest on the disk, in the S3 store, on Zenodo: identical copies are one resource with several addresses, and losing one address does not lose the resource. The object is a derived IRI <resource>/address/<i>, number 0 being the resource's url; every locator is also an rdfs:seeAlso of the resource, so a reader that knows nothing of EM finds every copy. Different manifestations are not addresses but sister resources. Maps to: node_datamodel ResourceNode.properties.addresses (data.addresses)."@en .
 
 em:locator
     a owl:DatatypeProperty ;

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/api.py

@@ -3150,7 +3150,7 @@ def find_moved_files(graph: Graph, results: Sequence[Dict[str, Any]],
 
 # ── B1 · disk ↔ bucket: the two copies, and what may be let go (E.D., 11 Oct 2026) ──
 def open_object_store(name: Optional[str] = None, config: Any = None):
-    """The object store of the Resource layer — any S3-compatible one (MinIO
+    """The object store of the Resource layer — any S3-compatible one (RustFS
     today). ``S3_*`` environment, ``EM_OBJECT_STORE`` to choose another
     implementation (:func:`s3dgraphy.resources.object_store.register_store`)."""
     from .resources.object_store import open_store
@@ -3345,7 +3345,7 @@ def register_resource(graph: Graph, locator: str, *, name: Optional[str] = None,
     Creates a ResourceNode carrying a new stable ID (a UUID unless ``resource_id`` is
     given) and the ``locator`` as its current ``url``, and adds it to the graph.
     This is the *identity + locator* half only — real ingest (copying bytes into
-    an FS-index or MinIO store) is R1/R2, which will resolve the same ID through
+    an FS-index or S3 store) is R1/R2, which will resolve the same ID through
     their backends. Returns ``{id, locator, kind}``."""
     import uuid
     from .resources import classify_locator
@@ -3371,37 +3371,38 @@ def scan_fs_resources(folder: str) -> List[Dict[str, Any]]:
     return [e.to_dict() for e in backend.entries()]
 
 
-def ingest_minio_resource(path: str, *, resource_id: Optional[str] = None,
-                          config: Any = None) -> Dict[str, Any]:
-    """Ingest a file into the SHARED MinIO/S3 store (R2) and return
+def ingest_s3_resource(path: str, *, resource_id: Optional[str] = None,
+                       config: Any = None) -> Dict[str, Any]:
+    """Ingest a file into the SHARED S3 store (R2) and return
     ``{id, object_key, s3_uri}``.
 
     ``resource_id`` (optional): reuse an EXISTING stable ID instead of minting a
-    fresh one — this is how "promote to MinIO" keeps a resource's identity (the
-    SAME id whether it lives on the file system or in MinIO — one ID space).
+    fresh one — this is how "promote to the S3 store" keeps a resource's identity
+    (the SAME id whether it lives on the file system or in the bucket — one ID
+    space).
 
     By default the connection is read from the ``S3_*`` environment (the SAME
     vars Heriverse-Server uses → one shared object store); pass an explicit
-    :class:`~s3dgraphy.resources.MinioConfig` to override. Needs the optional
-    ``minio`` SDK (``pip install s3dgraphy[minio]``) AND a reachable server —
+    :class:`~s3dgraphy.resources.S3Config` to override. Needs the optional
+    ``boto3`` SDK (``pip install s3dgraphy[s3]``) AND a reachable server —
     raises :class:`MissingDependency` if the SDK is absent."""
-    from .resources import MinioBackend, MinioConfig
-    cfg = config or MinioConfig.from_env()
-    backend = MinioBackend(cfg)
+    from .resources import S3Backend, S3Config
+    cfg = config or S3Config.from_env()
+    backend = S3Backend(cfg)
     rid, key = backend.ingest(path, resource_id=resource_id)
     return {"id": rid, "object_key": key, "s3_uri": f"s3://{cfg.bucket}/{key}"}
 
 
-def presign_minio_resource(object_key: str, *, config: Any = None,
-                           expires_seconds: int = 3600) -> Dict[str, Any]:
-    """Presign a shared-MinIO ``object_key`` (as returned by
-    :func:`ingest_minio_resource`) into a short-lived fetchable
+def presign_s3_resource(object_key: str, *, config: Any = None,
+                        expires_seconds: int = 3600) -> Dict[str, Any]:
+    """Presign a shared-S3 ``object_key`` (as returned by
+    :func:`ingest_s3_resource`) into a short-lived fetchable
     ``{object_key, http_url}``. Stateless (presign by key, no manifest). Connection
     from the ``S3_*`` env by default. Raises :class:`MissingDependency` without the
-    ``minio`` SDK."""
-    from .resources import MinioBackend, MinioConfig
-    cfg = config or MinioConfig.from_env()
-    loc = MinioBackend(cfg).presign_key(object_key, expires_seconds=expires_seconds)
+    ``boto3`` SDK."""
+    from .resources import S3Backend, S3Config
+    cfg = config or S3Config.from_env()
+    loc = S3Backend(cfg).presign_key(object_key, expires_seconds=expires_seconds)
     return {"object_key": object_key, "http_url": loc.value}
 
 

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/resources/__init__.py

@@ -15,7 +15,7 @@ R0 establishes the SEAM only:
   * A pluggable **backend registry** (:class:`ResolverRegistry`) with ONE
     default backend, :class:`PassthroughBackend`, which resolves a resource to
     its stored locator (the ResourceNode ``url``) — so existing graphs resolve
-    unchanged. Real storage backends (R1 FS-index, R2 MinIO) plug in later by
+    unchanged. Real storage backends (R1 FS-index, R2 S3) plug in later by
     registering ahead of the passthrough fallback.
 
 No web framework, no network, no hardcoded EM vocab lists here. See
@@ -41,10 +41,10 @@ from .fs_backend import (
     classify_resource_type,
     em_id_of,
 )
-from .minio_backend import (
-    MinioBackend,
-    MinioConfig,
-    MinioEntry,
+from .s3_backend import (
+    S3Backend,
+    S3Config,
+    S3Entry,
 )
 
 __all__ = [
@@ -64,8 +64,8 @@ __all__ = [
     "classify_resource_type",
     "DOSCO_NODE_TYPES",
     "em_id_of",
-    # R2 — MinIO / S3 backend (optional 'minio' extra)
-    "MinioBackend",
-    "MinioConfig",
-    "MinioEntry",
+    # R2 — S3 backend (optional 's3' extra: boto3)
+    "S3Backend",
+    "S3Config",
+    "S3Entry",
 ]

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/resources/addresses.py

@@ -2,7 +2,7 @@
 la risorsa e la selezione*, «Più risorse per un documento»).
 
 * **The same bytes — the same digest — are ONE resource with several
-  addresses**: the same PDF on the disk, on MinIO, on Zenodo. It is redundancy:
+  addresses**: the same PDF on the disk, in the S3 store, on Zenodo. It is redundancy:
   if an address dies, the resource stays.
 * **Different manifestations** (the scan and the online transcription, two
   editions) are sister ResourceNodes, each with its digest — as before.

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/resources/object_store.py

@@ -1,6 +1,6 @@
 """The object store the Resource layer keeps its bucket in — any S3-compatible one.
 
-MinIO today, tomorrow another (Ceph, Garage, SeaweedFS, AWS S3, a cloud
+RustFS today, tomorrow another (Ceph, Garage, SeaweedFS, AWS S3, a cloud
 provider's): what the rest of s3Dgraphy needs from a bucket is five small things,
 and nothing here names a vendor.
 
@@ -12,9 +12,10 @@ and nothing here names a vendor.
   multipart upload, not of the file);
 * ``put(path, key)`` and ``delete(key)``.
 
-:class:`S3Store` implements them over the S3 API through the ``minio`` SDK —
-which speaks to any S3-compatible endpoint, not only to MinIO. A store that
-needs another client (boto3, a provider's SDK) is one more class with the same
+:class:`S3Store` implements them over the S3 API through ``boto3`` — plain S3
+operations (HeadBucket, CreateBucket, HeadObject, GetObject, PutObject,
+DeleteObject), path-style, which any S3-compatible endpoint speaks. A store that
+needs another client (a provider's SDK) is one more class with the same
 five methods, registered with :func:`register_store`; the connection is read
 from the ``S3_*`` environment (the SAME variables Heriverse-Server uses), and
 ``EM_OBJECT_STORE`` names which implementation opens it (default ``s3``).
@@ -29,10 +30,7 @@ import hashlib
 import os
 from typing import Any, Callable, Dict, Optional
 
-from .minio_backend import MinioConfig
-
-#: the errors an S3 server answers for «no such object»
-_ABSENT = {"NoSuchKey", "NoSuchObject", "NotFound", "404"}
+from .s3_backend import S3Config, ensure_bucket, is_not_found, make_client
 
 
 class StoreError(RuntimeError):
@@ -56,7 +54,7 @@ class ObjectStore:
 
     def key_for(self, resource_id: str, filename: str) -> str:
         """The key a resource's file is kept under: ``<prefix>/<id>/<filename>``
-        (the same layout ``MinioBackend.ingest`` writes and Heriverse reads)."""
+        (the same layout ``S3Backend.ingest`` writes and Heriverse reads)."""
         raise NotImplementedError
 
     def stat(self, key: str) -> Optional[Dict[str, Any]]:
@@ -75,27 +73,24 @@ class ObjectStore:
 
 
 class S3Store(ObjectStore):
-    """Any S3-compatible endpoint, through the ``minio`` SDK (or an injected
-    client with the same ``stat_object`` / ``get_object`` / ``fput_object`` /
-    ``remove_object`` / ``bucket_exists`` / ``make_bucket`` methods)."""
+    """Any S3-compatible endpoint, through a ``boto3`` S3 client (or an injected
+    client with the same ``head_object`` / ``get_object`` / ``upload_file`` /
+    ``delete_object`` / ``head_bucket`` / ``create_bucket`` methods)."""
 
     name = "s3"
 
-    def __init__(self, config: Optional[MinioConfig] = None, client: Any = None):
-        self.config = config or MinioConfig.from_env()
+    def __init__(self, config: Optional[S3Config] = None, client: Any = None):
+        self.config = config or S3Config.from_env()
         self._client = client
 
     def _get_client(self):
         if self._client is None:
             try:
-                from minio import Minio  # type: ignore
+                self._client = make_client(self.config)
             except ImportError as exc:
                 raise StoreUnavailable(
-                    "the object store needs the 'minio' SDK (it speaks to any "
-                    f"S3-compatible server): pip install minio ({exc})") from exc
-            c = self.config
-            self._client = Minio(c.endpoint, access_key=c.access_key,
-                                 secret_key=c.secret_key, secure=c.secure, region=c.region)
+                    "the object store needs the 'boto3' SDK (it speaks to any "
+                    f"S3-compatible server): pip install s3dgraphy[s3] ({exc})") from exc
         return self._client
 
     def locator(self, key: str) -> str:
@@ -111,61 +106,56 @@ class S3Store(ObjectStore):
 
     def stat(self, key: str) -> Optional[Dict[str, Any]]:
         try:
-            obj = self._get_client().stat_object(self.config.bucket, key)
+            head = self._get_client().head_object(Bucket=self.config.bucket, Key=key)
         except StoreError:
             raise
-        except Exception as exc:  # noqa: BLE001 — the SDK's own error classes
-            if str(getattr(exc, "code", "")) in _ABSENT:
+        except Exception as exc:  # noqa: BLE001 — botocore's ClientError & co.
+            if is_not_found(exc):
                 return None
             raise StoreError(f"{self.locator(key)}: {exc}") from exc
-        return {"size": int(getattr(obj, "size", 0) or 0),
-                "etag": str(getattr(obj, "etag", "") or "").strip('"')}
+        return {"size": int(head.get("ContentLength") or 0),
+                "etag": str(head.get("ETag") or "").strip('"')}
 
     def sha256(self, key: str) -> str:
         client = self._get_client()
         try:
-            resp = client.get_object(self.config.bucket, key)
+            body = client.get_object(Bucket=self.config.bucket, Key=key)["Body"]
         except Exception as exc:  # noqa: BLE001
             raise StoreError(f"{self.locator(key)}: {exc}") from exc
         h = hashlib.sha256()
         try:
-            for chunk in resp.stream(1 << 20):
+            for chunk in iter(lambda: body.read(1 << 20), b""):
                 h.update(chunk)
         finally:
-            for closer in ("close", "release_conn"):
-                fn = getattr(resp, closer, None)
-                if fn:
-                    fn()
+            body.close()      # a stream left open is a connection the pool loses
         return h.hexdigest()
 
     def put(self, path: str, key: str) -> None:
         client = self._get_client()
         try:
-            if not client.bucket_exists(self.config.bucket):
-                client.make_bucket(self.config.bucket)
-            client.fput_object(self.config.bucket, key, path)
+            ensure_bucket(client, self.config.bucket)
+            client.upload_file(path, self.config.bucket, key)
         except Exception as exc:  # noqa: BLE001
             raise StoreError(f"{self.locator(key)}: {exc}") from exc
 
     def delete(self, key: str) -> None:
         try:
-            self._get_client().remove_object(self.config.bucket, key)
+            self._get_client().delete_object(Bucket=self.config.bucket, Key=key)
         except Exception as exc:  # noqa: BLE001
             raise StoreError(f"{self.locator(key)}: {exc}") from exc
 
 
-_FACTORIES: Dict[str, Callable[[Optional[MinioConfig]], ObjectStore]] = {
+_FACTORIES: Dict[str, Callable[[Optional[S3Config]], ObjectStore]] = {
     "s3": lambda cfg: S3Store(cfg),
-    "minio": lambda cfg: S3Store(cfg),       # the name it had
 }
 
 
-def register_store(name: str, factory: Callable[[Optional[MinioConfig]], ObjectStore]) -> None:
+def register_store(name: str, factory: Callable[[Optional[S3Config]], ObjectStore]) -> None:
     """Plug in another implementation: ``factory(config) -> ObjectStore``."""
     _FACTORIES[str(name).lower()] = factory
 
 
-def open_store(name: Optional[str] = None, config: Optional[MinioConfig] = None) -> ObjectStore:
+def open_store(name: Optional[str] = None, config: Optional[S3Config] = None) -> ObjectStore:
     """The store the environment names (``EM_OBJECT_STORE``, default ``s3``),
     connected as the ``S3_*`` variables say."""
     chosen = str(name or os.environ.get("EM_OBJECT_STORE") or "s3").lower()

{s3dgraphy-1.6.0.dev58 → s3dgraphy-1.6.0.dev59}/src/s3dgraphy/resources/resolver.py

@@ -4,7 +4,7 @@ Pure Python, no web framework, no network. The resolver maps a **stable
 resource ID** to a concrete :class:`Location`. Storage backends are pluggable
 via :class:`ResolverRegistry`; R0 ships exactly one — :class:`PassthroughBackend`
 — which classifies a resource's *current locator* (a ResourceNode ``url``) into a
-Location without touching bytes. R1 (FS-index) and R2 (MinIO) will register
+Location without touching bytes. R1 (FS-index) and R2 (S3) will register
 richer backends ahead of the passthrough fallback.
 """