sdata 1.5.0__tar.gz → 1.6.0__tar.gz

sdata-1.6.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE-MIT
+include README.md

{sdata-1.5.0/sdata.egg-info → sdata-1.6.0}/PKG-INFO

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: sdata
-Version: 1.5.0
+Version: 1.6.0
 Summary: a structured data format
 Author-email: Ingolf Lepenies <lepy@tuta.io>
 Maintainer-email: Ingolf Lepenies <lepy@tuta.io>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/lepy/sdata
 Project-URL: Documentation, https://lepy.github.io/sdata/
 Keywords: open data
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.9

{sdata-1.5.0 → sdata-1.6.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=64.0.0", "wheel"]
+requires = ["setuptools>=77.0.0", "wheel"]  # >=77: PEP-639-Lizenzfelder
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -7,7 +7,11 @@ name = "sdata"
 dynamic = ["version"]                 # Single Source: sdata/__init__.py:__version__
 description = "a structured data format"
 readme = "README.md"
-license = { text = "MIT" }            # RFC 0008 A7 / RFC 0013
+license = "MIT"                       # SPDX (PEP 639); RFC 0008 A7 / RFC 0013
+# Nur die eigene Lizenz: das einzige vendored Modul (sdata/contrib/sobol_seq.py,
+# MIT) trägt seinen Lizenztext im Dateikopf. Kein Muster ohne Treffer — setuptools
+# warnt sonst und lehnt solche Builds ab 2027-02-18 ab.
+license-files = ["LICENSE-MIT"]
 requires-python = ">=3.9"
 authors = [{ name = "Ingolf Lepenies", email = "lepy@tuta.io" }]
 maintainers = [{ name = "Ingolf Lepenies", email = "lepy@tuta.io" }]
@@ -18,7 +22,6 @@ dependencies = ["numpy", "pandas", "suuid>=0.2.0"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3.9",

{sdata-1.5.0 → sdata-1.6.0}/sdata/__init__.py

@@ -1,7 +1,7 @@
 # -*-coding: utf-8-*-
 from __future__ import division
 
-__version__ = '1.5.0'
+__version__ = '1.6.0'
 __revision__ = None
 __version_info__ = tuple([int(num) for num in __version__.split('.')])
 

{sdata-1.5.0 → sdata-1.6.0}/sdata/base.py

@@ -403,6 +403,26 @@ class Base:
         else:
             return spec
 
+    @classmethod
+    def _class_for_spec(cls, class_spec: str) -> Optional[Type['Base']]:
+        """Konkrete Klasse für ``from_dict`` (``None`` = dynamische Klasse wie bisher).
+
+        Auf ``Base`` selbst aufgerufen bleibt das generische Verhalten. Auf einer
+        Unterklasse: die gespeicherte Klasse, wenn sie ``cls`` oder eine bereits
+        geladene Unterklasse davon ist (Abgleich über ``modul:Name``), sonst
+        ``cls``. Es wird nichts aus den Daten heraus importiert.
+        """
+        if cls is Base:
+            return None
+        module, _, name = class_spec.rpartition(":")
+        stack = [cls]
+        while stack:
+            k = stack.pop()
+            if k.__name__ == name and (not module or k.__module__ == module):
+                return k
+            stack.extend(k.__subclasses__())
+        return cls
+
     @classmethod
     def from_dict(cls, d: Dict[str, Any], *, strict: bool = False) -> 'Base':
         """
@@ -417,7 +437,11 @@ class Base:
         metadata = Metadata.from_dict(d.get("metadata", {}))
         class_spec = metadata.get(cls.SDATA_CLASS).value or "sdata.base:Base"
         class_name = cls.classname_from_classspec(class_spec)
-        b = sdata_factory(class_name)
+        target = cls._class_for_spec(class_spec)
+        if target is None:
+            b = sdata_factory(class_name)
+        else:
+            b = target(name=metadata.get(cls.SDATA_NAME).value or class_name)
         b.metadata = metadata
         b.data = d.get("data", {})
         b.description = d.get("description", "")

{sdata-1.5.0 → sdata-1.6.0}/sdata/deprecated/data.py

@@ -24,7 +24,40 @@ import json
 import hashlib
 import base64
 import re
-from sdata.contrib.sqlitedict import SqliteDict
+import pickle
+import sqlite3
+
+# Schlüssel/Wert-Ablage im Dateiformat des früher vendorten ``sqlitedict``
+# (Apache-2.0): Tabelle "unnamed" (key TEXT PRIMARY KEY, value BLOB), Werte
+# gepickelt. So bleiben mit älteren sdata-Versionen geschriebene Dateien lesbar
+# und neu geschriebene für ältere Versionen lesbar.
+_SQLITEDICT_TABLE = "unnamed"
+
+
+def _sqlitedict_write(filepath, items):
+    con = sqlite3.connect(filepath)
+    try:
+        with con:
+            con.execute(f'CREATE TABLE IF NOT EXISTS "{_SQLITEDICT_TABLE}" '
+                        '(key TEXT PRIMARY KEY, value BLOB)')
+            con.executemany(
+                f'REPLACE INTO "{_SQLITEDICT_TABLE}" (key, value) VALUES (?, ?)',
+                [(k, sqlite3.Binary(pickle.dumps(v, protocol=pickle.HIGHEST_PROTOCOL)))
+                 for k, v in items.items()])
+    finally:
+        con.close()
+
+
+def _sqlitedict_read(filepath):
+    """Alle Einträge lesen. Achtung: Werte werden ent-pickelt — nur vertrauenswürdige Dateien öffnen."""
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(filepath)
+    con = sqlite3.connect(filepath)
+    try:
+        rows = con.execute(f'SELECT key, value FROM "{_SQLITEDICT_TABLE}"').fetchall()
+    finally:
+        con.close()
+    return {k: pickle.loads(bytes(v)) for k, v in rows}
 
 if sys.version_info < (3, 0):
     from StringIO import StringIO
@@ -1260,13 +1293,13 @@ class Data(object):
             df = self.df
         df.columns = df.columns.astype(str)
 
-        with SqliteDict(filepath, autocommit=True) as sqdict:
-            sqdict['metadata'] = self.metadata.df.to_parquet()
-            sqdict['table'] = df.to_parquet()
-
-            description = self.description_to_df().copy()
-            description.columns = description.columns.astype(str)
-            sqdict['description'] = description.to_parquet()
+        description = self.description_to_df().copy()
+        description.columns = description.columns.astype(str)
+        _sqlitedict_write(filepath, {
+            'metadata': self.metadata.df.to_parquet(),
+            'table': df.to_parquet(),
+            'description': description.to_parquet(),
+        })
 
     @classmethod
     def from_sqlite(cls, filepath, **kwargs):
@@ -1277,13 +1310,13 @@ class Data(object):
         :return: sdata.Data
         """
 
-        with SqliteDict(filepath) as sqdict:
-            metadata = sdata.Metadata.from_dataframe(pd.read_parquet(BytesIO(sqdict['metadata'])))
-            df_table = pd.read_parquet(BytesIO(sqdict['table']))
-            df_description = pd.read_parquet(BytesIO(sqdict['description']))
-            data = Data(metadata=metadata, table=df_table)
-            data.description_from_df(df_description)
-            return data
+        sqdict = _sqlitedict_read(filepath)
+        metadata = sdata.Metadata.from_dataframe(pd.read_parquet(BytesIO(sqdict['metadata'])))
+        df_table = pd.read_parquet(BytesIO(sqdict['table']))
+        df_description = pd.read_parquet(BytesIO(sqdict['description']))
+        data = Data(metadata=metadata, table=df_table)
+        data.description_from_df(df_description)
+        return data
 
     @classmethod
     def metadata_from_hdf5(cls, filepath, **kwargs):

{sdata-1.5.0 → sdata-1.6.0}/sdata/doe.py

@@ -3,10 +3,50 @@
 
 import collections
 import sdata
-from sdata.contrib.ranger import Range
 import sdata.contrib.sobol_seq
 from sdata.contrib.sobol_seq import Sobol
 import pandas as pd
+from sdata.sclass.dataframe import DataFrame
+
+
+class Range:
+    """Geschlossenes Intervall ``[min, max]`` eines DoE-Parameters.
+
+    Ersetzt das früher vendorte ``ranger.Range`` (BSD); sdata nutzt davon nur
+    :meth:`closed`, :attr:`min`, :attr:`max`, :attr:`length` und die Textform
+    ``"[min , max]"``, die so auch in den Metadaten landet.
+    """
+
+    __slots__ = ("min", "max")
+
+    def __init__(self, lower, upper):
+        if lower > upper:
+            raise ValueError("Lower bound cannot be greater than upper bound")
+        self.min = lower
+        self.max = upper
+
+    @classmethod
+    def closed(cls, lower, upper):
+        return cls(lower, upper)
+
+    @property
+    def length(self):
+        return self.max - self.min
+
+    def __eq__(self, other):
+        if not isinstance(other, Range):
+            return NotImplemented
+        return (self.min, self.max) == (other.min, other.max)
+
+    def __hash__(self):
+        return hash((self.min, self.max))
+
+    def __repr__(self):
+        return f"[{self.min!r} , {self.max!r}]"
+
+    __str__ = __repr__
+
+
 class DOE():
     """
     DoE Generator
@@ -56,7 +96,7 @@ class DOE():
         X = S.i4_sobol_generate(dim_num=self.dim_num, n=n, skip=1)
         df = pd.DataFrame(X, columns=self._ranges.keys())
         df["doe_id"] = range(1, len(X)+1)
-        df.set_index("doe_id", inplace=True)
+        df = df.set_index("doe_id")
         return df
 
     def gen_sobol(self, n=1):
@@ -64,19 +104,36 @@ class DOE():
         X = S.i4_sobol_generate(dim_num=self.dim_num, n=n, skip=1)
         df = pd.DataFrame(X, columns=self._ranges.keys())
         df["doe_id"] = range(1, len(X)+1)
-        df.set_index("doe_id", inplace=True)
+        df = df.set_index("doe_id")
         for param_name, r in self._ranges.items():
             df[param_name] *= r.length
             df[param_name] += r.min
         return df
 
     def to_data(self, name, df_doe, uid=None):
-        """
+        """Design-Tabelle als :class:`~sdata.sclass.dataframe.DataFrame` verpacken.
+
+        Die Parameterbereiche landen in den Objekt-Metadaten (je Parameter ein
+        Attribut mit dem Bereich als Wert).
 
-        :param df_doe: design table
-        :return: sdata.Data
+        :param name: Name des Datenobjekts.
+        :param df_doe: Design-Tabelle (z. B. aus :meth:`gen_sobol`).
+        :param uid: optionale Identität — eine :class:`~sdata.suuid.SUUID` oder
+          ein UUID-Hex-String; ohne Angabe wird die SUUID deterministisch aus
+          Klasse und ``name`` abgeleitet.
+        :return: sdata.sclass.dataframe.DataFrame
         """
-        data = sdata.Data(name=name, uuid=uid, table=df_doe, description="my DoE")
+        kwargs = {}
+        if isinstance(uid, sdata.SUUID):
+            kwargs["suuid"] = uid
+        elif uid is not None:
+            # Fremd vorgegebene UUID (Hex, mit oder ohne Bindestriche) übernehmen.
+            kwargs["suuid"] = sdata.SUUID(DataFrame.__name__, name, huuid=str(uid).replace("-", ""))
+        # Benannten Index (z. B. "doe_id") zur Spalte machen: DataFrame
+        # serialisiert ohne Index, die Versuchs-ID ginge sonst verloren.
+        if df_doe.index.name is not None and df_doe.index.name not in df_doe.columns:
+            df_doe = df_doe.reset_index()
+        data = DataFrame(df=df_doe, name=name, description="my DoE", **kwargs)
         for parameter_name, r in self.ranges.items():
             data.metadata.add(parameter_name, r, unit="?", description=f"parameter range {parameter_name}",
                               label=rf"${parameter_name}$")

{sdata-1.5.0 → sdata-1.6.0}/sdata/imagemeta.py

@@ -57,6 +57,10 @@ class UnsupportedImageFormatError(ImageMetadataError):
     """Das Bildformat wird (zum Schreiben) nicht unterstützt."""
 
 
+class StripNotSupportedError(ImageMetadataError):
+    """Die Nutzlast lässt sich für dieses Format nicht verlustfrei entfernen (TIFF)."""
+
+
 class PayloadTooLargeError(ImageMetadataError):
     """Die Nutzlast passt nicht in ein einzelnes Format-Segment (z. B. JPEG ``APP1``)."""
 
@@ -104,6 +108,16 @@ def _png_embed(data: bytes, payload: str) -> bytes:
     return bytes(out)
 
 
+def _png_strip(data: bytes) -> bytes:
+    """Entferne sdata-Text-Chunks (``iTXt``/``tEXt`` mit Schlüsselwort ``sdata``)."""
+    out = bytearray(_PNG_MAGIC)
+    for ctype, cdata in _png_chunks(data):
+        if ctype in (b"iTXt", b"tEXt") and cdata.split(b"\x00", 1)[0] == _SID:
+            continue
+        out += _png_make_chunk(ctype, cdata)
+    return bytes(out)
+
+
 def _png_extract(data: bytes) -> Optional[str]:
     """Lies die sdata-Nutzlast aus ``iTXt``/``tEXt`` mit Schlüsselwort ``sdata``."""
     for ctype, cdata in _png_chunks(data):
@@ -228,6 +242,16 @@ def _jp2_embed(data: bytes, payload: str) -> bytes:
     return bytes(out)
 
 
+def _jp2_strip(data: bytes) -> bytes:
+    """Entferne die ``uuid``-Box mit der sdata-UUID; alle übrigen Boxen bleiben verbatim."""
+    out = bytearray()
+    for tbox, start, cstart, end in _jp2_boxes(data):
+        if tbox == b"uuid" and data[cstart:cstart + 16] == SDATA_JP2_UUID:
+            continue
+        out += data[start:end]
+    return bytes(out)
+
+
 def _jp2_extract(data: bytes) -> Optional[str]:
     """Lies die sdata-Nutzlast aus der ``uuid``-Box mit der sdata-UUID."""
     for tbox, _start, cstart, end in _jp2_boxes(data):
@@ -373,6 +397,18 @@ def _webp_embed(data: bytes, payload: str) -> bytes:
     return b"RIFF" + struct.pack("<I", len(out) + 4) + b"WEBP" + bytes(out)
 
 
+def _webp_strip(data: bytes) -> bytes:
+    """Entferne den ``sdAT``-Chunk und setze die RIFF-Länge neu."""
+    out = bytearray()
+    for fourcc, body in _webp_chunks(data):
+        if fourcc == _WEBP_FOURCC:
+            continue
+        out += fourcc + struct.pack("<I", len(body)) + body
+        if len(body) & 1:
+            out += b"\x00"
+    return b"RIFF" + struct.pack("<I", len(out) + 4) + b"WEBP" + bytes(out)
+
+
 def _webp_extract(data: bytes) -> Optional[str]:
     """Lies die sdata-Nutzlast aus dem ``sdAT``-Chunk."""
     for fourcc, body in _webp_chunks(data):
@@ -445,6 +481,14 @@ def _tiff_embed(data: bytes, payload: str) -> bytes:
     return bytes(blob)
 
 
+def _tiff_strip(data: bytes) -> bytes:
+    """Für TIFF nicht umkehrbar: ``_tiff_embed`` lenkt den Header auf eine angehängte
+    IFD-Kopie um und bewahrt den ursprünglichen IFD-Offset nicht auf."""
+    raise StripNotSupportedError(
+        "TIFF: the original IFD offset is not preserved by embed(); "
+        "the original bytes cannot be restored")
+
+
 def _tiff_extract(data: bytes) -> Optional[str]:
     """Lies die sdata-Nutzlast aus dem privaten TIFF-Tag (inline oder per Offset)."""
     e = _tiff_endian(data)
@@ -470,6 +514,16 @@ _HANDLERS = {
     "tiff": (_tiff_embed, _tiff_extract),
 }
 
+#: ``fmt -> strip``: Umkehrung von :func:`embed`, ``strip(embed(x, p)) == x``.
+_STRIPPERS = {
+    "png": _png_strip,
+    "jpeg": _jpeg_strip,
+    "jp2": _jp2_strip,
+    "gif": _gif_strip,
+    "webp": _webp_strip,
+    "tiff": _tiff_strip,
+}
+
 
 def detect_format(data: bytes) -> Optional[str]:
     """Erkenne das Bildformat an den Magic-Bytes.
@@ -531,3 +585,34 @@ def extract(data: bytes, fmt: Optional[str] = None) -> Optional[str]:
     if fmt not in _HANDLERS:
         return None
     return _HANDLERS[fmt][1](data)
+
+
+def strippable_formats() -> Tuple[str, ...]:
+    """Formate, für die :func:`strip` die Original-Bytes bitgleich herstellt."""
+    return tuple(f for f, fn in _STRIPPERS.items() if fn is not _tiff_strip)
+
+
+def strip(data: bytes, fmt: Optional[str] = None) -> bytes:
+    """Entferne eine eingebettete sdata-Nutzlast (Umkehrung von :func:`embed`).
+
+    Für die Formate aus :func:`strippable_formats` gilt ``strip(embed(x, p)) == x``,
+    sofern ``x`` selbst keine sdata-Nutzlast trug. So lässt sich ein
+    inhaltsbasierter Hash über die Bytes *ohne* Nutzlast bilden, der sich durch
+    das Einbetten nicht ändert. Bilder ohne Nutzlast werden unverändert (dasselbe
+    Objekt) zurückgegeben.
+
+    :param data: die Bild-Bytes.
+    :param fmt: Format-Schlüssel; ``None`` → automatische Erkennung.
+    :return: die Bild-Bytes ohne sdata-Nutzlast.
+    :raises UnsupportedImageFormatError: wenn das Format unbekannt/nicht unterstützt ist.
+    :raises StripNotSupportedError: wenn eine Nutzlast vorliegt, das Format sie aber
+        nicht verlustfrei entfernen kann (TIFF).
+    """
+    fmt = fmt or detect_format(data)
+    if fmt not in _STRIPPERS:
+        raise UnsupportedImageFormatError(
+            f"unsupported image format: {fmt!r} "
+            f"(supported: {', '.join(_STRIPPERS)})")
+    if _HANDLERS[fmt][1](data) is None:
+        return data
+    return _STRIPPERS[fmt](data)

{sdata-1.5.0 → sdata-1.6.0}/sdata/iolib/json1sqlitestore.py

@@ -550,5 +550,5 @@ class JSON1SQLiteStore:
             query += f" WHERE {filter_str}"
 
         df = pd.read_sql_query(query, self.conn)
-        df.set_index("id", inplace=True)
+        df = df.set_index("id")
         return df

{sdata-1.5.0 → sdata-1.6.0}/sdata/metadata.py

@@ -14,7 +14,41 @@ import os
 import hashlib
 import re
 import copy
-from sdata.contrib.sortedcontainers.sorteddict import SortedDict
+
+
+class SortedDict(dict):
+    """``dict``, das in Schlüssel-Reihenfolge iteriert.
+
+    Ersetzt das früher vendorte ``sortedcontainers.SortedDict``; sdata braucht
+    davon nur die sortierte Iteration. Sortiert wird bei jedem Durchlauf —
+    für Metadaten-Größen (wenige hundert Attribute) unerheblich.
+    """
+
+    __slots__ = ()
+
+    def __iter__(self):
+        return iter(sorted(dict.keys(self)))
+
+    def __reversed__(self):
+        return iter(sorted(dict.keys(self), reverse=True))
+
+    def keys(self):
+        return list(self)
+
+    def values(self):
+        return [self[k] for k in self]
+
+    def items(self):
+        return [(k, self[k]) for k in self]
+
+    def copy(self):
+        return type(self)(self)
+
+    __copy__ = copy
+
+    def __repr__(self):
+        return f"{type(self).__name__}({dict(self.items())!r})"
+
 
 def extract_name_unit(value):
     """extract name and unit from a combined string
@@ -527,10 +561,11 @@ class Metadata(object):
     @classmethod
     def from_dataframe(cls, df):
         """create metadata from dataframe"""
-        df["unit"] = df.unit.fillna("")
-        df["label"] =df.label.fillna("")
-        df["description"] =df.description.fillna("")
-        df["symbol"] = df["symbol"].fillna("") if "symbol" in df.columns else ""
+        # astype(object): leere Spalten liest pandas als float64 (NaN); ein
+        # String-Fill auf float64 ist deprecated (pandas ≥ 3.1).
+        for key in ("unit", "label", "description"):
+            df[key] = df[key].astype(object).fillna("")
+        df["symbol"] = df["symbol"].astype(object).fillna("") if "symbol" in df.columns else ""
         d = df.to_dict(orient='index')
         metadata = cls.from_dict(d)
         return metadata
@@ -574,7 +609,7 @@ class Metadata(object):
         # Index nach Spalte "name" (Spalte behalten). Kein df.name.values, da das
         # in neueren pandas-Versionen ein StringArray ist, den set_index als
         # unhashbaren Key behandelt (TypeError).
-        df.set_index("name", drop=False, inplace=True)
+        df = df.set_index("name", drop=False)
         metadata = cls.from_dataframe(df)
         return metadata
 

{sdata-1.5.0 → sdata-1.6.0}/sdata/sclass/blob.py

@@ -1,4 +1,5 @@
 import base64
+import errno as _errno
 import logging
 import hashlib
 import os
@@ -18,6 +19,44 @@ except ImportError:  # pragma: no cover - optionales Backend (sdata[blob])
     logger.warning('fsspec not installed')
     fsspec = None
 
+
+class ContentUnavailableError(ValueError):
+    """Der Inhalt eines Blob konnte nicht gelesen oder geprüft werden (RFC 0019).
+
+    Unterklasse von ``ValueError``, damit ältere ``except ValueError`` um
+    :attr:`Blob.content_bytes` weiter greifen. ``uri`` nennt die Quelle,
+    ``__cause__`` den ursprünglichen Fehler des Backends.
+    """
+
+    uri = None  # Quelle; von _unavailable gesetzt
+
+
+class ContentNotFoundError(FileNotFoundError, ContentUnavailableError):
+    """Die Quelle existiert nicht (zugleich ``FileNotFoundError``)."""
+
+
+class ContentPermissionError(PermissionError, ContentUnavailableError):
+    """Keine Berechtigung für die Quelle (zugleich ``PermissionError``)."""
+
+
+def _unavailable(uri: str, exc: BaseException) -> ContentUnavailableError:
+    """Übersetzt einen Backend-Fehler; der Aufrufer schreibt ``raise … from exc``.
+
+    Der OS-Fehlertyp steht in der Basisliste vorne, damit ``errno`` und
+    ``filename`` gesetzt werden; ``uri`` wird nachträglich gesetzt, weil
+    ``OSError.__new__`` keine Schlüsselwort-Argumente annimmt.
+    """
+    msg = f"Failed to access URI '{uri}': {exc}"
+    code = getattr(exc, "errno", None)
+    if isinstance(exc, FileNotFoundError):
+        err = ContentNotFoundError(code or _errno.ENOENT, msg, uri)
+    elif isinstance(exc, PermissionError):
+        err = ContentPermissionError(code or _errno.EACCES, msg, uri)
+    else:
+        err = ContentUnavailableError(msg)
+    err.uri = uri
+    return err
+
 class Blob(ContentIntegrityMixin, Base):
     """
     A derived class from Base that represents a generic binary large object (Blob).
@@ -221,8 +260,12 @@ class Blob(ContentIntegrityMixin, Base):
         Caches the result for subsequent accesses.
 
         :return: The content as bytes.
-        :raises ValueError: If loading fails or no value set.
-        :raises Exception: If fsspec encounters an error (e.g., invalid URI, missing dependencies like s3fs for S3).
+        :raises ContentNotFoundError: the URI does not exist (also ``FileNotFoundError``).
+        :raises ContentPermissionError: no permission (also ``PermissionError``).
+        :raises ContentUnavailableError: any other backend error, e.g. a directory,
+          a missing backend such as s3fs or an unknown protocol (RFC 0019).
+        :raises ValueError: no content/value set or unknown content_type.
+        :raises ImportError: fsspec is not installed.
         """
         if getattr(self, '_content_cache', None) is not None:
             return self._content_cache
@@ -245,7 +288,7 @@ class Blob(ContentIntegrityMixin, Base):
                 with fsspec.open(val, 'rb') as f:
                     loaded_bytes = f.read()
             except Exception as e:
-                raise ValueError(f"Failed to load from URI '{val}': {str(e)}")
+                raise _unavailable(val, e) from e
         else:
             raise ValueError(f"Unknown content_type: {ctype}")
 
@@ -264,7 +307,15 @@ class Blob(ContentIntegrityMixin, Base):
     def exists(self) -> bool:
         """
         Test whether the blob content exists.
-        For 'uri', checks if the path/URI is accessible via fsspec; for 'bytes', always True if value set.
+
+        For 'uri', asks the fsspec backend whether the path exists — an existing
+        but unreadable path (permissions, directory) counts as existing. For
+        'bytes', True if a value is set. False also without content or for an
+        unknown content_type.
+
+        :raises ContentUnavailableError: the existence cannot be checked, e.g.
+          missing backend such as s3fs or unknown protocol (RFC 0019).
+        :raises ImportError: fsspec is not installed.
         """
         content = self.data.get('content')
         if content is None:
@@ -279,14 +330,12 @@ class Blob(ContentIntegrityMixin, Base):
             return True  # In-memory, assumes exists if set
         elif ctype == 'uri':
             if fsspec is None:
-                logger.warning('fsspec not installed')
-                return False
+                raise ImportError("fsspec is required for URI exists() (pip install sdata[blob]).")
             try:
                 fs, _, paths = fsspec.core.get_fs_token_paths(val)
-                return fs.exists(paths[0])
+                return bool(fs.exists(paths[0]))
             except Exception as e:
-                logger.warning(f"Failed to check existence for URI '{val}': {str(e)}")
-                return False
+                raise _unavailable(val, e) from e
         else:
             return False
 
@@ -309,11 +358,13 @@ class Blob(ContentIntegrityMixin, Base):
     def open(self, mode: str = "rb"):
         """Return a file-like handle to the content; use as a context manager.
 
-        For ``uri`` content a **streaming** fsspec handle is returned (no full
-        in-memory load); for ``bytes`` content an :class:`io.BytesIO` over the
-        decoded bytes.
+        For ``uri`` content the source is opened **immediately** and a
+        streaming file object is returned (no full in-memory load); errors
+        surface at the call, translated like :attr:`content_bytes` (RFC 0019).
+        For ``bytes`` content an :class:`io.BytesIO` over the decoded bytes.
 
         :param mode: open mode (default ``"rb"``).
+        :raises ContentUnavailableError: (or its subclasses) the URI cannot be opened.
         :raises ValueError: if no content/value is set or the content_type is unknown.
         :raises ImportError: if fsspec is required (uri) but not installed.
         """
@@ -324,7 +375,11 @@ class Blob(ContentIntegrityMixin, Base):
         if ctype == 'uri':
             if fsspec is None:
                 raise ImportError("fsspec is required for uri open() (pip install sdata[blob]).")
-            return fsspec.open(content['value'], mode)
+            uri = content['value']
+            try:
+                return fsspec.open(uri, mode).open()
+            except Exception as e:
+                raise _unavailable(uri, e) from e
         elif ctype == 'bytes':
             return io.BytesIO(self.content_bytes)
         else: