ome-arrow 0.0.2__py3-none-any.whl

ome_arrow/meta.py

@@ -0,0 +1,90 @@
+"""
+Meta-definition for OME-Arrow format.
+"""
+
+import pyarrow as pa
+
+from ._version import version as ome_arrow_version
+
+OME_ARROW_TAG_TYPE = "ome.arrow"
+OME_ARROW_TAG_VERSION = ome_arrow_version
+
+# OME_ARROW_STRUCT: ome-arrow record (describes one image/value).
+#  - type/version: quick identity & evolution.
+#  - id/name/acquisition_datetime: identity & provenance.
+#  - pixels_meta: pixels struct (sizes, units, channels).
+#  - planes: list of planes struct entries, one per (t,c,z).
+#  - masks: reserved for future labels/ROIs (placeholder).
+OME_ARROW_STRUCT: pa.StructType = pa.struct(
+    [
+        pa.field("type", pa.string()),  # must be "ome.arrow"
+        pa.field("version", pa.string()),  # e.g., "1.0.0"
+        pa.field("id", pa.string()),  # stable image identifier
+        pa.field("name", pa.string()),  # human label
+        pa.field("acquisition_datetime", pa.timestamp("us")),
+        # PIXELS: OME-like "Pixels" header summarizing shape & scale.
+        #  - dimension_order: hint like "XYZCT" (or "XYCT" when Z==1).
+        #  - type: numeric storage type (e.g., "uint16").
+        #  - size_*: axis lengths.
+        #  - physical_size_* (+ *_unit): microscope scale in micrometers.
+        #  - channels: list of channel struct entries (one per channel).
+        pa.field(
+            "pixels_meta",
+            pa.struct(
+                [
+                    pa.field("dimension_order", pa.string()),  # "XYZCT" / "XYCT"
+                    pa.field("type", pa.string()),  # "uint8","uint16","float",...
+                    pa.field("size_x", pa.int32()),  # width  (pixels)
+                    pa.field("size_y", pa.int32()),  # height (pixels)
+                    pa.field("size_z", pa.int32()),  # z-slices (1 for 2D)
+                    pa.field("size_c", pa.int16()),  # channels
+                    pa.field("size_t", pa.int32()),  # time points
+                    pa.field("physical_size_x", pa.float32()),  # µm per pixel (X)
+                    pa.field("physical_size_y", pa.float32()),  # µm per pixel (Y)
+                    pa.field("physical_size_z", pa.float32()),  # µm per z-step
+                    pa.field("physical_size_x_unit", pa.string()),  # usually "µm"
+                    pa.field("physical_size_y_unit", pa.string()),
+                    pa.field("physical_size_z_unit", pa.string()),
+                    pa.field(
+                        "channels",
+                        pa.list_(
+                            # CHANNELS: one entry per channel (e.g., DNA, Mito, ER).
+                            #  - emission_um / excitation_um: wavelengths (micrometers).
+                            #  - illumination: modality (e.g., "Epifluorescence").
+                            #  - color_rgba: preferred display color
+                            #       (packed 0xRRGGBBAA).
+                            pa.struct(
+                                [
+                                    pa.field("id", pa.string()),
+                                    pa.field("name", pa.string()),
+                                    pa.field("emission_um", pa.float32()),
+                                    pa.field("excitation_um", pa.float32()),
+                                    pa.field("illumination", pa.string()),
+                                    pa.field("color_rgba", pa.uint32()),
+                                ]
+                            )
+                        ),
+                    ),
+                ]
+            ),
+        ),
+        # PLANES: one 2D image plane for a specific (t, c, z).
+        #  - pixels: flattened numeric list (Y*X) for analysis-ready computation.
+        pa.field(
+            "planes",
+            pa.list_(
+                pa.struct(
+                    [
+                        pa.field("z", pa.int32()),
+                        pa.field("t", pa.int32()),
+                        pa.field("c", pa.int16()),
+                        pa.field(
+                            "pixels", pa.list_(pa.uint16())
+                        ),  # keep numeric (not PNG/JPEG)
+                    ]
+                )
+            ),
+        ),
+        pa.field("masks", pa.null()),  # reserved for future annotations
+    ]
+)

ome_arrow/transform.py

@@ -0,0 +1,182 @@
+"""
+Module for transforming OME-Arrow data
+(e.g., slices, projections, or other changes).
+"""
+
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+import numpy as np
+import pyarrow as pa
+
+from ome_arrow.meta import OME_ARROW_STRUCT
+
+
+def slice_ome_arrow(
+    data: Dict[str, Any] | pa.StructScalar,
+    x_min: int,
+    x_max: int,
+    y_min: int,
+    y_max: int,
+    t_indices: Optional[Iterable[int]] = None,
+    c_indices: Optional[Iterable[int]] = None,
+    z_indices: Optional[Iterable[int]] = None,
+    fill_missing: bool = True,
+) -> pa.StructScalar:
+    """
+    Create a cropped copy of an OME-Arrow record.
+
+    Crops spatially to [y_min:y_max, x_min:x_max] (half-open) and, if provided,
+    filters/reindexes T/C/Z to the given index sets.
+
+    Parameters
+    ----------
+    data : dict | pa.StructScalar
+        OME-Arrow record.
+    x_min, x_max, y_min, y_max : int
+        Half-open crop bounds in pixels (0-based).
+    t_indices, c_indices, z_indices : Iterable[int] | None
+        Optional explicit indices to keep for T, C, Z. If None, keep all.
+        Selected indices are reindexed to 0..len-1 in the output.
+    fill_missing : bool
+        If True, any missing (t,c,z) planes in the selection are zero-filled.
+
+    Returns
+    -------
+    pa.StructScalar
+        New OME-Arrow record with updated sizes and planes.
+    """
+    # Unwrap to dict
+    row = data.as_py() if isinstance(data, pa.StructScalar) else dict(data)
+    pm = dict(row.get("pixels_meta", {}))
+
+    sx = int(pm.get("size_x", 1))
+    sy = int(pm.get("size_y", 1))
+    sz = int(pm.get("size_z", 1))
+    sc = int(pm.get("size_c", 1))
+    st = int(pm.get("size_t", 1))
+    if not (0 <= x_min < x_max <= sx and 0 <= y_min < y_max <= sy):
+        raise ValueError(
+            f"Crop bounds out of range: x[{x_min},{x_max}) within [0,{sx}), "
+            f"y[{y_min},{y_max}) within [0,{sy})."
+        )
+
+    # Normalize T/C/Z selections (keep all if None)
+    def _norm(sel: Optional[Iterable[int]], size: int) -> List[int]:
+        return (
+            list(range(size))
+            if sel is None
+            else sorted({int(i) for i in sel if 0 <= int(i) < size})
+        )
+
+    keep_t = _norm(t_indices, st)
+    keep_c = _norm(c_indices, sc)
+    keep_z = _norm(z_indices, sz)
+    if len(keep_t) == 0 or len(keep_c) == 0 or len(keep_z) == 0:
+        raise ValueError("Selection must keep at least one index in each of T/C/Z.")
+
+    # Reindex maps (old -> new)
+    t_map = {t: i for i, t in enumerate(keep_t)}
+    c_map = {c: i for i, c in enumerate(keep_c)}
+    z_map = {z: i for i, z in enumerate(keep_z)}
+
+    new_sx = x_max - x_min
+    new_sy = y_max - y_min
+    new_st = len(keep_t)
+    new_sc = len(keep_c)
+    new_sz = len(keep_z)
+
+    # Fast access to incoming planes
+    planes_in: List[Dict[str, Any]] = list(row.get("planes", []))
+    if not planes_in:
+        raise ValueError("Record contains no planes to slice.")
+
+    # Group incoming planes by (t,c,z)
+    by_tcz: Dict[Tuple[int, int, int], Dict[str, Any]] = {}
+    for p in planes_in:
+        tt = int(p["t"])
+        cc = int(p["c"])
+        zz = int(p["z"])
+        by_tcz[(tt, cc, zz)] = p
+
+    # Helper to crop one plane
+    expected_len = sx * sy
+
+    def _crop_pixels(flat: Iterable[int]) -> List[int]:
+        arr = np.asarray(flat)
+        if arr.size != expected_len:
+            # be strict: malformed plane
+            raise ValueError(f"Plane has {arr.size} pixels; expected {expected_len}.")
+        arr = arr.reshape(sy, sx)
+        sub = arr[y_min:y_max, x_min:x_max]
+        return sub.ravel().astype(arr.dtype, copy=False).tolist()
+
+    # Build new plane list in dense (t,c,z) order using selections
+    planes_out: List[Dict[str, Any]] = []
+    for tt in keep_t:
+        for cc in keep_c:
+            for zz in keep_z:
+                src = by_tcz.get((tt, cc, zz))
+                if src is None:
+                    if not fill_missing:
+                        continue
+                    # zero-fill missing plane
+                    planes_out.append(
+                        {
+                            "t": t_map[tt],
+                            "c": c_map[cc],
+                            "z": z_map[zz],
+                            "pixels": [0] * (new_sx * new_sy),
+                        }
+                    )
+                else:
+                    cropped = _crop_pixels(src["pixels"])
+                    planes_out.append(
+                        {
+                            "t": t_map[tt],
+                            "c": c_map[cc],
+                            "z": z_map[zz],
+                            "pixels": cropped,
+                        }
+                    )
+
+    # Filter channel metadata to kept channels and reindex
+    channels_in = list(pm.get("channels", []) or [])
+    channels_out: List[Dict[str, Any]] = []
+    # If channels metadata length mismatches, synthesize minimal entries
+    if len(channels_in) != sc:
+        channels_in = [
+            {"id": f"ch-{i}", "name": f"C{i}", "color_rgba": 0xFFFFFFFF}
+            for i in range(sc)
+        ]
+    for old_c in keep_c:
+        meta = dict(channels_in[old_c])
+        meta["id"] = f"ch-{c_map[old_c]}"
+        # ensure name string
+        if "name" in meta:
+            meta["name"] = str(meta["name"])
+        else:
+            meta["name"] = f"C{c_map[old_c]}"
+        channels_out.append(meta)
+
+    # Update pixels_meta
+    pm_out = dict(pm)
+    pm_out.update(
+        {
+            "size_x": new_sx,
+            "size_y": new_sy,
+            "size_z": new_sz,
+            "size_c": new_sc,
+            "size_t": new_st,
+            "channels": channels_out,
+        }
+    )
+
+    # If dimension order encoded XYCT/XYZCT etc., keep it as-is (no axis permutation).
+    # (Optional: you could normalize to XYCT if new_sz==1, else XYZCT.)
+
+    # Assemble new record
+    rec_out = dict(row)
+    rec_out["pixels_meta"] = pm_out
+    rec_out["planes"] = planes_out
+
+    return pa.scalar(rec_out, type=OME_ARROW_STRUCT)

ome_arrow/utils.py

@@ -0,0 +1,83 @@
+"""
+Utility functions for ome-arrow.
+"""
+
+from typing import Any, Dict
+
+import pyarrow as pa
+
+
+def verify_ome_arrow(data: Any, struct: pa.StructType) -> bool:
+    """Return True if `data` conforms to the given Arrow StructType.
+
+    This tries to convert `data` into a pyarrow scalar using `struct`
+    as the declared type. If conversion fails, the data does not match.
+
+    Args:
+        data: A nested Python dict/list structure to test.
+        struct: The expected pyarrow.StructType schema.
+
+    Returns:
+        bool: True if conversion succeeds, False otherwise.
+    """
+    try:
+        pa.scalar(data, type=struct)
+        return True
+    except (TypeError, pa.ArrowInvalid, pa.ArrowTypeError):
+        return False
+
+
+def describe_ome_arrow(data: pa.StructScalar | dict) -> Dict[str, Any]:
+    """
+    Describe the structure of an OME-Arrow image record.
+
+    Reads `pixels_meta` from the OME-Arrow struct to report TCZYX
+    dimensions and classify whether it's a 2D image, 3D z-stack,
+    movie/timelapse, or 4D timelapse-volume. Also flags whether it is
+    multi-channel (C > 1) or single-channel.
+
+    Args:
+        data: OME-Arrow row as a pa.StructScalar or plain dict.
+
+    Returns:
+        dict with keys:
+            - shape: (T, C, Z, Y, X)
+            - type: classification string
+            - summary: human-readable text
+    """
+    # --- Unwrap StructScalar if needed ---
+    if isinstance(data, pa.StructScalar):
+        data = data.as_py()
+
+    pm = data.get("pixels_meta", {})
+    t = int(pm.get("size_t", 1))
+    c = int(pm.get("size_c", 1))
+    z = int(pm.get("size_z", 1))
+    y = int(pm.get("size_y", 1))
+    x = int(pm.get("size_x", 1))
+
+    # --- Basic dimensional classification ---
+    if t == 1 and z == 1:
+        kind = "2D image"
+    elif t == 1 and z > 1:
+        kind = "3D image (z-stack)"
+    elif t > 1 and z == 1:
+        kind = "movie / timelapse"
+    elif t > 1 and z > 1:
+        kind = "4D timelapse-volume"
+    else:
+        kind = "unknown"
+
+    # --- Channel classification ---
+    channel_info = f"multi-channel ({c} channels)" if c > 1 else "single-channel"
+
+    # --- Summary ---
+    summary = f"{kind}, {channel_info} - shape (T={t}, C={c}, Z={z}, Y={y}, X={x})"
+
+    return {
+        "shape": (t, c, z, y, x),
+        "type": kind,
+        "channels": c,
+        "is_multichannel": c > 1,
+        "summary": summary,
+    }

ome_arrow/view.py

@@ -0,0 +1,286 @@
+"""
+Viewing utilities for OME-Arrow data.
+"""
+
+import contextlib
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pyarrow as pa
+import pyvista as pv
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.image import AxesImage
+
+
+def view_matplotlib(
+    data: dict[str, object] | pa.StructScalar,
+    tcz: tuple[int, int, int] = (0, 0, 0),
+    autoscale: bool = True,
+    vmin: int | None = None,
+    vmax: int | None = None,
+    cmap: str = "gray",
+    show: bool = True,
+) -> tuple[Figure, Axes, AxesImage]:
+    if isinstance(data, pa.StructScalar):
+        data = data.as_py()
+
+    pm = data["pixels_meta"]
+    sx, sy = int(pm["size_x"]), int(pm["size_y"])
+    t, c, z = (int(x) for x in tcz)
+
+    plane = next(
+        (
+            p
+            for p in data["planes"]
+            if int(p["t"]) == t and int(p["c"]) == c and int(p["z"]) == z
+        ),
+        None,
+    )
+    if plane is None:
+        raise ValueError(f"plane (t={t}, c={c}, z={z}) not found")
+
+    pix = plane["pixels"]
+    if len(pix) != sx * sy:
+        raise ValueError(f"pixels len {len(pix)} != size_x*size_y ({sx * sy})")
+
+    img = np.asarray(pix, dtype=np.uint16).reshape(sy, sx).copy()
+
+    if (vmin is None or vmax is None) and autoscale:
+        lo, hi = int(img.min()), int(img.max())
+        if hi == lo:
+            hi = lo + 1
+        vmin = lo if vmin is None else vmin
+        vmax = hi if vmax is None else vmax
+
+    fig, ax = plt.subplots()
+    im: AxesImage = ax.imshow(img, cmap=cmap, vmin=vmin, vmax=vmax)
+    ax.axis("off")
+
+    if show:
+        plt.show()
+
+    return fig, ax, im
+
+
+def view_pyvista(
+    data: dict | pa.StructScalar,
+    c: int = 0,
+    downsample: int = 1,
+    scaling_values: tuple[float, float, float] | None = None,  # (Z, Y, X)
+    opacity: str | float = "sigmoid",
+    clim: tuple[float, float] | None = None,
+    show_axes: bool = True,
+    backend: str = "auto",  # "auto" | "trame" | "html" | "static"
+    interpolation: str = "nearest",  # "nearest" or "linear"
+    background: str = "black",
+    percentile_clim: tuple[float, float] = (1.0, 99.9),  # robust contrast
+    sampling_scale: float = 0.5,  # smaller = denser rays (sharper, slower)
+    show: bool = True,
+) -> pv.Plotter:
+    """
+    Jupyter-inline interactive volume view using PyVista backends.
+    Tries 'trame' → 'html' → 'static' when backend='auto'.
+
+    sampling_scale controls ray step via the mapper after add_volume.
+    """
+    import warnings
+
+    import numpy as np
+
+    # ---- unwrap OME-Arrow row
+    row = data.as_py() if isinstance(data, pa.StructScalar) else data
+    pm = row["pixels_meta"]
+    sx, sy, sz = int(pm["size_x"]), int(pm["size_y"]), int(pm["size_z"])
+    sc, _st = int(pm["size_c"]), int(pm["size_t"])
+    if not (0 <= c < sc):
+        raise ValueError(f"Channel out of range: 0..{sc - 1}")
+
+    # ---- spacing (dx, dy, dz) in world units
+    dx = float(pm.get("physical_size_x", 1.0) or 1.0)
+    dy = float(pm.get("physical_size_y", 1.0) or 1.0)
+    dz = float(pm.get("physical_size_z", 1.0) or 1.0)
+
+    # optional override from legacy scaling tuple (Z, Y, X)
+    if scaling_values is None and "scaling_values" in pm:
+        try:
+            sz_legacy, sy_legacy, sx_legacy = pm["scaling_values"]
+            dz, dy, dx = float(sz_legacy), float(sy_legacy), float(sx_legacy)
+        except Exception:
+            pass
+    elif scaling_values is not None:
+        sz_legacy, sy_legacy, sx_legacy = scaling_values
+        dz, dy, dx = float(sz_legacy), float(sy_legacy), float(sx_legacy)
+
+    # ---- rebuild (Z,Y,X) for T=0, channel c
+    vol_zyx = np.zeros((sz, sy, sx), dtype=np.uint16)
+    for p in row["planes"]:
+        if int(p["t"]) == 0 and int(p["c"]) == c:
+            z = int(p["z"])
+            vol_zyx[z] = np.asarray(p["pixels"], dtype=np.uint16).reshape(sy, sx)
+
+    # optional downsampling (keep spacing consistent)
+    if downsample > 1:
+        vol_zyx = vol_zyx[::downsample, ::downsample, ::downsample]
+        dz, dy, dx = dz * downsample, dy * downsample, dx * downsample
+
+    # VTK expects (X,Y,Z) memory order
+    vol_xyz = vol_zyx.transpose(2, 1, 0)  # (nx, ny, nz)
+    nx, ny, nz = map(int, vol_xyz.shape)
+
+    # ---- contrast limits (robust percentiles, like napari)
+    if clim is None:
+        lo, hi = np.percentile(vol_xyz, percentile_clim)
+        lo = float(lo)
+        hi = float(hi if hi > lo else lo + 1.0)
+        clim = (lo, hi)
+
+    # ---- backend selection
+    def _try_backend(name: str) -> bool:
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore", message=".*notebook backend.*", category=UserWarning
+            )
+            try:
+                pv.set_jupyter_backend(name)
+                return True
+            except Exception:
+                return False
+
+    if backend == "auto":
+        (
+            "trame"
+            if _try_backend("trame")
+            else "html"
+            if _try_backend("html")
+            else "static"
+        )
+    else:
+        backend if _try_backend(backend) else "static"
+
+    pv.OFF_SCREEN = False
+
+    # ---- build dataset
+    img = pv.ImageData()
+    img.dimensions = (nx, ny, nz)
+    img.spacing = (dx, dy, dz)
+    img.origin = (0.0, 0.0, 0.0)
+    img.point_data.clear()
+    img.point_data["scalars"] = np.asfortranarray(vol_xyz).ravel(order="F")
+
+    # Make "scalars" active across PyVista versions
+    try:
+        img.point_data.set_active_scalars("scalars")
+    except AttributeError:
+        try:
+            img.point_data.active_scalars_name = "scalars"
+        except Exception:
+            img.set_active_scalars("scalars")
+
+    # ---- render
+    pl = pv.Plotter()
+    pl.set_background(background)
+
+    # sensible opacity behavior relative to spacing
+    base_sample = max(min(dx, dy, dz), 1e-6)  # avoid zero
+
+    vol_actor = pl.add_volume(
+        img,
+        cmap="gray",  # napari-like
+        opacity=opacity,
+        clim=clim,
+        shade=False,  # microscopy usually unshaded
+        scalar_bar_args={"title": "intensity"},
+        opacity_unit_distance=base_sample,  # keep opacity consistent
+        # no sampling_distance kwarg here (set via mapper below)
+    )
+
+    # -- crispness & interpolation (version-safe)
+    try:
+        prop = getattr(vol_actor, "prop", None) or vol_actor.GetProperty()
+        # nearest vs linear sampling
+        if interpolation.lower().startswith("near"):
+            prop.SetInterpolationTypeToNearest()
+        else:
+            prop.SetInterpolationTypeToLinear()
+        # stop pre-map smoothing if available (big win for microscopy)
+        if hasattr(prop, "SetInterpolateScalarsBeforeMapping"):
+            prop.SetInterpolateScalarsBeforeMapping(False)
+        # also expose scalar opacity unit distance in case kwarg unsupported
+        if hasattr(prop, "SetScalarOpacityUnitDistance"):
+            prop.SetScalarOpacityUnitDistance(base_sample)
+    except Exception:
+        pass
+
+    # -- ray sampling density via mapper (works across many VTK versions)
+    try:
+        mapper = getattr(vol_actor, "mapper", None) or vol_actor.GetMapper()
+        # lock sample distance if API allows
+        if hasattr(mapper, "SetAutoAdjustSampleDistances"):
+            mapper.SetAutoAdjustSampleDistances(False)
+        if hasattr(mapper, "SetUseJittering"):
+            mapper.SetUseJittering(False)
+        if hasattr(mapper, "SetSampleDistance"):
+            mapper.SetSampleDistance(float(base_sample * sampling_scale))
+    except Exception:
+        pass
+
+    if show_axes:
+        pl.add_axes()
+
+    pl.show_bounds(
+        color="white",
+        grid=None,
+        location="outer",
+        ticks="both",
+        xtitle="X (µm)",
+        ytitle="Y (µm)",
+        ztitle="Z (µm)",
+    )
+
+    def _force_white_bounds(*_args: object, **_kwargs: object) -> None:
+        try:
+            ren = pl.renderer
+
+            # Modern cube-axes path
+            if getattr(ren, "cube_axes_actor", None):
+                ca = ren.cube_axes_actor
+                # axis line colors
+                for prop in (
+                    ca.GetXAxesLinesProperty(),
+                    ca.GetYAxesLinesProperty(),
+                    ca.GetZAxesLinesProperty(),
+                ):
+                    prop.SetColor(1, 1, 1)
+                # titles and tick labels
+                for i in (0, 1, 2):  # 0:X, 1:Y, 2:Z
+                    ca.GetTitleTextProperty(i).SetColor(1, 1, 1)
+                    ca.GetLabelTextProperty(i).SetColor(1, 1, 1)
+                ca.Modified()
+
+            # Older/internal bounds actors
+            if getattr(ren, "_bounds_actors", None):
+                for actor in ren._bounds_actors.values():
+                    actor.GetProperty().SetColor(1, 1, 1)
+                    actor.Modified()
+
+        except Exception:
+            pass
+
+    # run BEFORE drawing the frame so it's visible immediately
+    pl.ren_win.AddObserver("StartEvent", _force_white_bounds)
+
+    # keep the old safety net if you like (optional):
+    pl.iren.add_observer("RenderEvent", _force_white_bounds)
+
+    def _recolor_and_render() -> None:
+        _force_white_bounds()
+        with contextlib.suppress(Exception):
+            pl.render()  # immediate redraw so you see the white bounds now
+
+    pl.add_key_event("r", _recolor_and_render)
+
+    if show:
+        pl.show()
+
+    return pl

ome_arrow-0.0.2.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: ome-arrow
+Version: 0.0.2
+Summary: Using OME specifications with Apache Arrow for fast, queryable, and language agnostic bioimage data.
+Author: Dave Bunten
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bioio>=3
+Requires-Dist: bioio-ome-tiff>=1.4
+Requires-Dist: bioio-ome-zarr>=3.0.3
+Requires-Dist: bioio-tifffile>=1.3
+Requires-Dist: fire>=0.7
+Requires-Dist: ipywidgets>=8.1.8
+Requires-Dist: jupyterlab-widgets>=3.0.16
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pillow>=12
+Requires-Dist: pyarrow>=22
+Requires-Dist: pyvista>=0.46.4
+Requires-Dist: trame>=3.12
+Requires-Dist: trame-vtk>=2.10
+Requires-Dist: trame-vuetify>=3.1
+Dynamic: license-file
+
+# ome-arrow
+
+Using OME specifications with Apache Arrow for fast, queryable, and language agnostic bioimage data.

ome_arrow-0.0.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+ome_arrow/__init__.py,sha256=DfQsw8l0mx1Qt3YiiMv2SUljKETP3wS5hrD5eBbjMDM,583
+ome_arrow/_version.py,sha256=huLsL1iGeXWQKZ8bjwDdIWC7JOkj3wnzBh-HFMZl1PY,704
+ome_arrow/core.py,sha256=NUCV9KUH3yCOlpetRS5NNVG_phodutE1F2ujDBPhHgY,18351
+ome_arrow/export.py,sha256=CCTnEdHko4Z0i5LEHuNGFLznWSsPyAFcS42H5nHU22Q,14875
+ome_arrow/ingest.py,sha256=zZz94LaLOpmoxnryLeoPsaWV0EzkYkGFizYSVcbd5w8,33016
+ome_arrow/meta.py,sha256=qeD0e_ItAQyZDT7ypkBU0rBh9oHIu2ziz9MCfPpPp9g,4199
+ome_arrow/transform.py,sha256=0275_Mn1mlGXSWJ86llch8JoJyvqEOfvG-ub1dUWFNI,5997
+ome_arrow/utils.py,sha256=XHovcqmjqoiBpKvXY47-_yUwf07f8zVE_F9BR_VKaPU,2383
+ome_arrow/view.py,sha256=DT8i56uV8Rw22KkqwjPPPKWJWNtfgR9OkI8Qj1WD8Ds,9355
+ome_arrow-0.0.2.dist-info/licenses/LICENSE,sha256=9-2Pyhu3vTt2RJU8DorHQtHeNO_e5RLeFJTyOU4hOi4,1508
+ome_arrow-0.0.2.dist-info/METADATA,sha256=XrGmDrHe-QMpEeDzUP4hVEmfh1P4Z8qyGMmGuMPWsfo,1164
+ome_arrow-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ome_arrow-0.0.2.dist-info/top_level.txt,sha256=aWOtkGXo_pfU-yy82guzGhz8Zh2h2nFl8Kc5qdzMGuE,10
+ome_arrow-0.0.2.dist-info/RECORD,,

ome_arrow-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+