Normalize internal helper and module names across blosc2

Author: FrancescAlted

src/blosc2/__init__.py

@@ -253,7 +253,7 @@ class FPAccuracy(Enum):
 The C-Blosc2 version's string."""
 
 if IS_WASM:
-    from ._wasm_jit import init_wasm_jit_helpers
+    from .wasm_jit import init_wasm_jit_helpers
 
     _WASM_MINIEXPR_ENABLED = init_wasm_jit_helpers()
 
@@ -538,7 +538,7 @@ def _raise(exc):
 from .batch_store import Batch, BatchStore
 from .vlarray import VLArray, vlarray_from_cframe
 from .ref import Ref
-from .b2objects import _open_b2object
+from .b2objects import open_b2object
 
 from .c2array import c2context, C2Array, URLPath
 
@@ -549,7 +549,7 @@ def _raise(exc):
     lazyexpr,
     LazyArray,
     LazyUDF,
-    _open_lazyarray,
+    open_lazyarray,
     get_expr_operands,
     validate_expr,
     evaluate,

src/blosc2/b2objects.py

@@ -24,7 +24,7 @@
 _B2OBJECT_DSL_VERSION = 1
 
 
-def _make_b2object_carrier(
+def make_b2object_carrier(
     kind: str,
     shape,
     dtype,
@@ -39,19 +39,19 @@ def _make_b2object_carrier(
     return blosc2.empty(shape=shape, dtype=dtype, chunks=chunks, blocks=blocks, **kwargs)
 
 
-def _write_b2object_payload(array, payload: dict[str, Any]) -> None:
+def write_b2object_payload(array, payload: dict[str, Any]) -> None:
     array.schunk.vlmeta[_B2OBJECT_META_KEY] = payload
 
 
-def _encode_operand_reference(obj):
+def encode_operand_reference(obj):
     return blosc2.Ref.from_object(obj).to_dict()
 
 
-def _decode_operand_reference(payload):
+def decode_operand_reference(payload):
     return blosc2.Ref.from_dict(payload).open()
 
 
-def _encode_b2object_payload(obj) -> dict[str, Any] | None:
+def encode_b2object_payload(obj) -> dict[str, Any] | None:
     if isinstance(obj, blosc2.C2Array):
         return blosc2.Ref.c2array_ref(obj.path, obj.urlbase).to_dict()
     if isinstance(obj, blosc2.LazyExpr):
@@ -61,7 +61,7 @@ def _encode_b2object_payload(obj) -> dict[str, Any] | None:
             "kind": "lazyexpr",
             "version": _B2OBJECT_VERSION,
             "expression": expression,
-            "operands": {key: _encode_operand_reference(value) for key, value in operands.items()},
+            "operands": {key: encode_operand_reference(value) for key, value in operands.items()},
         }
     if isinstance(obj, blosc2.LazyUDF):
         if not isinstance(obj.func, DSLKernel):
@@ -92,13 +92,13 @@ def _encode_b2object_payload(obj) -> dict[str, Any] | None:
             "dsl_source": obj.func.dsl_source,
             "dtype": np.dtype(obj.dtype).str,
             "shape": list(obj.shape),
-            "operands": {f"o{i}": _encode_operand_reference(value) for i, value in enumerate(obj.inputs)},
+            "operands": {f"o{i}": encode_operand_reference(value) for i, value in enumerate(obj.inputs)},
             "kwargs": kwargs,
         }
     return None
 
 
-def _decode_b2object_payload(payload: dict[str, Any]):
+def decode_b2object_payload(payload: dict[str, Any]):
     kind = payload.get("kind")
     version = payload.get("version")
     if version != _B2OBJECT_VERSION:
@@ -107,24 +107,24 @@ def _decode_b2object_payload(payload: dict[str, Any]):
         ref = blosc2.Ref.from_dict(payload)
         return ref.open()
     if kind == "lazyexpr":
-        return _decode_structured_lazyexpr(payload)
+        return decode_structured_lazyexpr(payload)
     if kind == "lazyudf":
-        return _decode_structured_lazyudf(payload)
+        return decode_structured_lazyudf(payload)
     raise ValueError(f"Unsupported persisted Blosc2 object kind: {kind!r}")
 
 
-def _decode_structured_lazyexpr(payload):
+def decode_structured_lazyexpr(payload):
     expression = payload.get("expression")
     if not isinstance(expression, str):
         raise TypeError("Structured LazyExpr payload requires a string 'expression'")
     operands_payload = payload.get("operands")
     if not isinstance(operands_payload, dict):
         raise TypeError("Structured LazyExpr payload requires a mapping 'operands'")
-    operands = {key: _decode_operand_reference(value) for key, value in operands_payload.items()}
+    operands = {key: decode_operand_reference(value) for key, value in operands_payload.items()}
     return blosc2.lazyexpr(expression, operands=operands)
 
 
-def _decode_structured_lazyudf(payload):
+def decode_structured_lazyudf(payload):
     function_kind = payload.get("function_kind")
     if function_kind != "dsl":
         raise ValueError(f"Unsupported structured LazyUDF function kind: {function_kind!r}")
@@ -167,31 +167,31 @@ def _decode_structured_lazyudf(payload):
         func.dsl_source = dsl_source
 
     operands = tuple(
-        _decode_operand_reference(operands_payload[f"o{n}"]) for n in range(len(operands_payload))
+        decode_operand_reference(operands_payload[f"o{n}"]) for n in range(len(operands_payload))
     )
     return blosc2.lazyudf(func, operands, dtype=np.dtype(dtype), shape=tuple(shape_payload), **kwargs)
 
 
-def _read_b2object_marker(obj) -> dict[str, Any] | None:
+def read_b2object_marker(obj) -> dict[str, Any] | None:
     schunk = getattr(obj, "schunk", obj)
     if _B2OBJECT_META_KEY not in schunk.meta:
         return None
     return schunk.meta[_B2OBJECT_META_KEY]
 
 
-def _read_b2object_payload(obj) -> dict[str, Any]:
+def read_b2object_payload(obj) -> dict[str, Any]:
     schunk = getattr(obj, "schunk", obj)
     return schunk.vlmeta[_B2OBJECT_META_KEY]
 
 
-def _open_b2object(obj):
-    marker = _read_b2object_marker(obj)
+def open_b2object(obj):
+    marker = read_b2object_marker(obj)
     if marker is None:
         return None
 
-    payload = _read_b2object_payload(obj)
+    payload = read_b2object_payload(obj)
     if marker.get("version") != _B2OBJECT_VERSION:
         raise ValueError(f"Unsupported persisted Blosc2 object version: {marker.get('version')!r}")
     if marker.get("kind") != payload.get("kind"):
         raise ValueError("Persisted Blosc2 object marker/payload kind mismatch")
-    return _decode_b2object_payload(payload)
+    return decode_b2object_payload(payload)

src/blosc2/blosc2_ext.pyx

@@ -726,7 +726,7 @@ def destroy():
     blosc2_destroy()
 
 
-def _register_wasm_jit_helpers(uintptr_t instantiate_ptr, uintptr_t free_ptr):
+def register_wasm_jit_helpers(uintptr_t instantiate_ptr, uintptr_t free_ptr):
     cdef me_wasm_jit_instantiate_helper instantiate_helper = (
         <me_wasm_jit_instantiate_helper>instantiate_ptr
     )

src/blosc2/c2array.py

@@ -18,7 +18,7 @@
 import requests
 
 import blosc2
-from blosc2.b2objects import _encode_b2object_payload, _make_b2object_carrier, _write_b2object_payload
+from blosc2.b2objects import encode_b2object_payload, make_b2object_carrier, write_b2object_payload
 from blosc2.info import InfoReporter, format_nbytes_info
 
 _subscriber_data = {
@@ -240,13 +240,13 @@ def __init__(self, path: str, /, urlbase: str | None = None, auth_token: str | N
         self._cparams = blosc2.CParams(**cparams)
 
     def _to_b2object_payload(self) -> dict:
-        payload = _encode_b2object_payload(self)
+        payload = encode_b2object_payload(self)
         if payload is None:
             raise TypeError("Unsupported persisted Blosc2 object")
         return payload
 
     def _to_b2object_carrier(self, **kwargs):
-        array = _make_b2object_carrier(
+        array = make_b2object_carrier(
             "c2array",
             self.shape,
             self.dtype,
@@ -255,7 +255,7 @@ def _to_b2object_carrier(self, **kwargs):
             cparams=self.cparams,
             **kwargs,
         )
-        _write_b2object_payload(array, self._to_b2object_payload())
+        write_b2object_payload(array, self._to_b2object_payload())
         return array
 
     def to_cframe(self) -> bytes:

src/blosc2/core.py

@@ -1959,7 +1959,7 @@ def from_cframe(
     if "vlarray" in schunk.meta:
         return blosc2.vlarray_from_cframe(cframe, copy=copy)
     if "b2o" in schunk.meta:
-        return blosc2._open_b2object(ndarray_from_cframe(cframe, copy=copy))
+        return blosc2.open_b2object(ndarray_from_cframe(cframe, copy=copy))
     if "b2nd" in schunk.meta:
         return ndarray_from_cframe(cframe, copy=copy)
     return schunk_from_cframe(cframe, copy=copy)

src/blosc2/dict_store.py

@@ -19,7 +19,7 @@
 import blosc2
 from blosc2.c2array import C2Array
 from blosc2.embed_store import EmbedStore
-from blosc2.schunk import SChunk, _process_opened_object
+from blosc2.schunk import SChunk, process_opened_object
 
 if TYPE_CHECKING:
     from collections.abc import Iterator, Set
@@ -227,7 +227,7 @@ def _opened_external_kind(
         rel_path: str,
     ) -> str | None:
         """Return the supported external leaf kind for an already opened object."""
-        processed = _process_opened_object(opened)
+        processed = process_opened_object(opened)
         if isinstance(processed, blosc2.BatchStore):
             kind = "batchstore"
         elif isinstance(processed, blosc2.VLArray):
@@ -425,7 +425,7 @@ def __getitem__(
                     mmap_mode=self.mmap_mode,
                     dparams=self.dparams,
                 )
-                return self._annotate_external_value(key, _process_opened_object(opened))
+                return self._annotate_external_value(key, process_opened_object(opened))
             else:
                 urlpath = os.path.join(self.working_dir, filepath)
                 if os.path.exists(urlpath):
@@ -501,7 +501,7 @@ def values(self) -> Iterator[blosc2.NDArray | SChunk | C2Array]:
                         offset = self.offsets[filepath]["offset"]
                         yield self._annotate_external_value(
                             key,
-                            _process_opened_object(
+                            process_opened_object(
                                 blosc2.blosc2_ext.open(
                                     self.b2z_path,
                                     mode="r",
@@ -541,7 +541,7 @@ def items(self) -> Iterator[tuple[str, blosc2.NDArray | SChunk | C2Array]]:
                             key,
                             self._annotate_external_value(
                                 key,
-                                _process_opened_object(
+                                process_opened_object(
                                     blosc2.blosc2_ext.open(
                                         self.b2z_path,
                                         mode="r",

src/blosc2/dsl_kernel.py

@@ -257,7 +257,7 @@ def specialize_dsl_miniexpr_inputs(expr_string: str, operands: dict):
     return specialize_miniexpr_inputs(expr_string, operands)
 
 
-class _DSLValidator:
+class DSLValidator:
     _binop_map: ClassVar[dict[type[ast.operator], str]] = {
         ast.Add: "+",
         ast.Sub: "-",
@@ -526,7 +526,7 @@ def _extract_dsl(self, func, validate: bool = True):
         if dsl_func is None:
             raise ValueError("No function definition found in sliced DSL source")
         if validate:
-            _DSLValidator(dsl_source).validate(dsl_func)
+            DSLValidator(dsl_source).validate(dsl_func)
         input_names = self._input_names_from_signature(dsl_func)
         if _PRINT_DSL_KERNEL:
             func_name = getattr(func, "__name__", "<dsl_kernel>")
@@ -613,7 +613,7 @@ def validate_dsl(func):
     }
 
 
-class _DSLBuilder:
+class DSLBuilder:
     _binop_map: ClassVar[dict[type[ast.operator], str]] = {
         ast.Add: "+",
         ast.Sub: "-",
@@ -852,9 +852,9 @@ def _cmpop(self, op: ast.cmpop) -> str:
         raise ValueError("Unsupported comparison in DSL")
 
 
-class _DSLReducer:
-    _binop_map: ClassVar[dict[type[ast.operator], str]] = _DSLBuilder._binop_map
-    _cmp_map: ClassVar[dict[type[ast.cmpop], str]] = _DSLBuilder._cmp_map
+class DSLReducer:
+    _binop_map: ClassVar[dict[type[ast.operator], str]] = DSLBuilder._binop_map
+    _cmp_map: ClassVar[dict[type[ast.cmpop], str]] = DSLBuilder._cmp_map
 
     def __init__(self, max_unroll: int = 64):
         self._env: dict[str, str] = {}