transformnd 0.7.2__tar.gz → 0.9.0__tar.gz

{transformnd-0.7.2 → transformnd-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transformnd
-Version: 0.7.2
+Version: 0.9.0
 Summary: ND coordinate transformations
 Author: Chris Barnes
 Author-email: Chris Barnes <chris.barnes@gerbi-gmb.de>
@@ -86,6 +86,11 @@ See the [tutorial here](https://github.com/clbarnes/transformnd/blob/main/exampl
 It is a [marimo](https://marimo.io) notebook.
 Open it with `uv run --group examples marimo edit examples/tutorial.py`.
 
+## Usage
+
+`transformnd` is pre-1.0 and the API is subject to change.
+Production users should pin the maximum dependency version at the next minor version, like `uv add --bounds minor`.
+
 ## Implemented transforms
 
 All transforms are accessed under the `transformnd.transforms` subpackage.
@@ -138,11 +143,11 @@ Methods which MUST be implemented:
 
 Methods which SHOULD be implemented if applicable:
 
-- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU)
+- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU). The base class implementation returns `self`.
 - `is_identity`: if you can cheaply check whether your transformation is an identity transformation. The base class implementation returns `False`.
 - `to_affine`: if your transformation can be represented as an affine matrix. The base class implementation returns `None`.
 - `invert`: if your transformation can be inverted (default None if not)
-  - This automatically implements `__invert__` (the `~my_transform` operator), which returns `NotImplemented` (probably raising `NotImplementedError`) if `invert` would return `None`.
+  - This automatically implements `__invert__` (the `~` operator), which returns `NotImplemented` (probably raising `NotImplementedError`) if `invert` would return `None`.
 
 ## Contributing
 

{transformnd-0.7.2 → transformnd-0.9.0}/README.md

@@ -31,6 +31,11 @@ See the [tutorial here](https://github.com/clbarnes/transformnd/blob/main/exampl
 It is a [marimo](https://marimo.io) notebook.
 Open it with `uv run --group examples marimo edit examples/tutorial.py`.
 
+## Usage
+
+`transformnd` is pre-1.0 and the API is subject to change.
+Production users should pin the maximum dependency version at the next minor version, like `uv add --bounds minor`.
+
 ## Implemented transforms
 
 All transforms are accessed under the `transformnd.transforms` subpackage.
@@ -83,11 +88,11 @@ Methods which MUST be implemented:
 
 Methods which SHOULD be implemented if applicable:
 
-- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU)
+- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU). The base class implementation returns `self`.
 - `is_identity`: if you can cheaply check whether your transformation is an identity transformation. The base class implementation returns `False`.
 - `to_affine`: if your transformation can be represented as an affine matrix. The base class implementation returns `None`.
 - `invert`: if your transformation can be inverted (default None if not)
-  - This automatically implements `__invert__` (the `~my_transform` operator), which returns `NotImplemented` (probably raising `NotImplementedError`) if `invert` would return `None`.
+  - This automatically implements `__invert__` (the `~` operator), which returns `NotImplemented` (probably raising `NotImplementedError`) if `invert` would return `None`.
 
 ## Contributing
 

transformnd-0.9.0/pyproject.toml

@@ -0,0 +1,125 @@
+[project]
+name = "transformnd"
+version = "0.9.0"
+description = "ND coordinate transformations"
+readme = "README.md"
+requires-python = ">=3.12, <4.0"
+dependencies = [
+    "numpy>=2",
+    "networkx>=3",
+    "array_api_compat>=1.14",
+    "typing-extensions>=4.15.0",
+]
+license = "MIT"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: GIS",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[[project.authors]]
+name = "Chris Barnes"
+email = "chris.barnes@gerbi-gmb.de"
+
+[project.urls]
+documentation = "https://transformnd.readthedocs.io/en/latest/"
+source = "https://github.com/clbarnes/transformnd"
+issues = "https://github.com/clbarnes/transformnd/issues"
+
+[project.optional-dependencies]
+thinplatesplines = ["morphops>=0.1.13"]
+movingleastsquares = ["molesq>=0.4.0"]
+pandas = ["pandas>=3.0.2"]
+shapely = ["shapely>=2.1.2"]
+polars = ["polars>=1.40.1"]
+vectorfield = ["scipy>=1.17.1"]
+vectorfield-dask = [
+    "dask>=2026.3.0",
+    "dask-image>=2026.5.0",
+]
+transforms = [
+    "transformnd[thinplatesplines]",
+    "transformnd[movingleastsquares]",
+    "transformnd[vectorfield]",
+    "transformnd[vectorfield-dask]",
+]
+adapters = [
+    "transformnd[pandas]",
+    "transformnd[shapely]",
+    "transformnd[polars]",
+]
+all = [
+    "transformnd[transforms]",
+    "transformnd[adapters]",
+]
+
+[dependency-groups]
+test = [
+    "pytest",
+    "jax",
+    "dask>=2026.3.0",
+]
+lint = [
+    "ruff",
+    "mypy",
+    "prek>=0.3.9",
+    "types-shapely>=2.1.0.20260408",
+    "pydoclint>=0.8.6",
+]
+doc = ["pdoc>=16.0.0"]
+examples = [
+    "marimo>=0.9",
+    "matplotlib>=3.10.8",
+    "pandas>=3.0.2",
+    "pooch>=1.9.0",
+    "scikit-image>=0.26.0",
+]
+bench = ["pytest-benchmark>=5.2.3"]
+
+[[dependency-groups.dev]]
+include-group = "test"
+
+[[dependency-groups.dev]]
+include-group = "lint"
+
+[[dependency-groups.dev]]
+include-group = "doc"
+
+[[dependency-groups.dev]]
+include-group = "examples"
+
+[[dependency-groups.dev]]
+include-group = "bench"
+
+[build-system]
+requires = ["uv_build>=0.11.0,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.mypy]
+ignore_missing_imports = true
+check_untyped_defs = true
+
+[tool.pytest]
+testpaths = [
+    "tests",
+    "bench",
+]
+addopts = ["--benchmark-skip"]
+
+[tool.pydoclint]
+arg-type-hints-in-docstring = false
+allow-init-docstring = true
+
+[tool.ruff.lint]
+external = [
+    "DOC",
+    "D",
+]

transformnd-0.7.2/pyproject.toml → transformnd-0.9.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "transformnd"
-version = "0.7.2"
+version = "0.9.0"
 description = "ND coordinate transformations"
 readme = "README.md"
 authors = [{ name = "Chris Barnes", email = "chris.barnes@gerbi-gmb.de" }]

{transformnd-0.7.2 → transformnd-0.9.0}/src/transformnd/__init__.py

@@ -8,12 +8,12 @@ You can find some examples here:
 
 """
 
-from .base import Transform, TransformSequence, TransformWrapper
-from .util import SpaceRef
-from .types import Spaces, TransformSignature, NDims
+from .base import Transform, TransformSequence, TransformFnWrapper
+from .types import TransformSignature, NDims, SpaceRef
 from . import transforms
 from . import adapters
 from .graph import TransformGraph
+from .spaced import Spaced
 from importlib.metadata import version as _version
 
 __version__ = _version("transformnd")
@@ -22,11 +22,11 @@ __all__ = [
     "Transform",
     "TransformGraph",
     "TransformSequence",
-    "TransformWrapper",
+    "TransformFnWrapper",
     "TransformSignature",
     "SpaceRef",
     "transforms",
     "adapters",
-    "Spaces",
     "NDims",
+    "Spaced",
 ]

{transformnd-0.7.2 → transformnd-0.9.0}/src/transformnd/base.py

@@ -11,14 +11,12 @@ from types import ModuleType
 from array_api_compat import array_namespace
 
 from .util import (
-    SpaceRef,
-    same_or_none,
-    space_str,
     ArrayT,
+    join_strs,
 )
 from itertools import pairwise
 
-from .types import TransformSignature, Spaces, NDims
+from .types import TransformSignature, NDims
 
 if TYPE_CHECKING:
     from .transforms import Affine
@@ -30,19 +28,14 @@ class Transform[ArrayT](ABC):
     def __init__(
         self,
         ndims: NDims,
-        *,
-        spaces: Spaces = Spaces(None, None),
     ):
         """
         Parameters
         ----------
         ndims
             Source and target dimensionality.
-        spaces
-            Optional source and target spaces
         """
         self.ndims: NDims = ndims
-        self.spaces: Spaces = spaces
 
     def is_identity(self) -> bool:
         """Whether this is a no-op transformation."""
@@ -105,18 +98,18 @@ class Transform[ArrayT](ABC):
         """
         pass
 
-    def invert(self) -> Transform | None:
+    def invert(self) -> Transform[ArrayT] | None:
         """Invert the transformation, returning `None` if not possible."""
         return None
 
-    def __invert__(self) -> Transform:
+    def __invert__(self) -> Transform[ArrayT]:
         """Invert transformation if possible.
 
         Returns `NotImplemented` otherwise (will raise `NotImplementedError`).
 
         Returns
         -------
-        Transform
+        Transform[ArrayT]
             Inverted transformation.
         """
         t = self.invert()
@@ -141,10 +134,9 @@ class Transform[ArrayT](ABC):
         Returns
         -------
         Self
-            A new transform instance with parameters on the target device,
-            or NotImplemented if the subclass does not support device placement.
+            A new transform instance with parameters on the target device
         """
-        return NotImplemented
+        return self
 
     def __or__(self, other: Transform[ArrayT]) -> TransformSequence[ArrayT]:
         """Compose transformations into a sequence.
@@ -166,7 +158,6 @@ class Transform[ArrayT](ABC):
         transforms = as_transform_list(self) + as_transform_list(other)
         return TransformSequence[ArrayT](
             transforms,
-            spaces=Spaces(self.spaces.source, other.spaces.target),
         )
 
     def __ror__(self, other: Transform[ArrayT]) -> TransformSequence[ArrayT]:
@@ -189,17 +180,13 @@ class Transform[ArrayT](ABC):
         transforms = as_transform_list(other) + as_transform_list(self)
         return TransformSequence(
             transforms,
-            spaces=Spaces(other.spaces.source, self.spaces.target),
         )
 
     def __str__(self) -> str:
-        cls_name = type(self).__name__
-        src = space_str(self.spaces.source)
-        tgt = space_str(self.spaces.target)
-        return f"{cls_name}[{src}->{tgt}]"
+        return f"{type(self).__qualname__}@{hex(id(self))}[{self.ndims}]"
 
 
-class TransformWrapper(Transform[ArrayT]):
+class TransformFnWrapper(Transform[ArrayT]):
     """Wrapper around an arbitrary function which transforms coordinates."""
 
     def __init__(
@@ -207,8 +194,6 @@ class TransformWrapper(Transform[ArrayT]):
         fn: TransformSignature[ArrayT],
         in_ndim: int,
         out_ndim: int,
-        *,
-        spaces: Spaces = Spaces(None, None),
     ):
         """Wrapper around an arbitrary function.
 
@@ -223,46 +208,28 @@ class TransformWrapper(Transform[ArrayT]):
             Dimensionality of the input coordinates.
         out_ndim
             Dimensionality of the output coordinates.
-        spaces
-            Optional source and target spaces
         """
-        super().__init__(NDims(in_ndim, out_ndim), spaces=spaces)
+        super().__init__(NDims(in_ndim, out_ndim))
         self.fn = fn
 
     def apply(self, coords: ArrayT) -> ArrayT:
         self._validate_coords(coords)
         return self.fn(coords)
 
+    def __str__(self) -> str:
+        return f"{super().__str__()}({self.fn})"
 
-def _with_spaces(
-    t: Transform[ArrayT],
-    source_space: SpaceRef | None = None,
-    target_space: SpaceRef | None = None,
-) -> Transform[ArrayT]:
-    src_tgt = (t.spaces.source, t.spaces.target)
-    src = same_or_none(src_tgt[0], source_space, default=None)
-    tgt = same_or_none(src_tgt[1], target_space, default=None)
-    if (src, tgt) != src_tgt:
-        t = copy(t)
-        t.spaces = Spaces(src, tgt)
-    return t
-
-
-def infer_spaces(
-    transforms: Sequence[Transform[ArrayT]], source_space=None, target_space=None
-) -> list[Transform[ArrayT]]:
-    prev_tgts = [source_space]
-    next_srcs = []
-    for t1, t2 in pairwise(transforms):
-        prev_tgts.append(t1.spaces.target)
-        next_srcs.append(t2.spaces.source)
+    @classmethod
+    def from_flat(cls, fn: TransformSignature[ArrayT]) -> Self:
+        """Create a 1D transform from a function which would take and return a 1D array."""
 
-    next_srcs.append(target_space)
+        def fn2(arr: ArrayT) -> ArrayT:
+            xp = array_namespace(arr)
+            flat = xp.reshape(arr, (-1,))
+            transformed = fn(flat)
+            return xp.expand_dims(transformed, 1)
 
-    out = []
-    for t, next_src, prev_tgt in zip(transforms, next_srcs, prev_tgts):
-        out.append(_with_spaces(t, prev_tgt, next_src))
-    return out
+        return cls(fn2, 1, 1)
 
 
 def as_transform_list(t: Transform[ArrayT]) -> list[Transform[ArrayT]]:
@@ -273,36 +240,39 @@ def as_transform_list(t: Transform[ArrayT]) -> list[Transform[ArrayT]]:
 
 
 class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
-    """Chain transforms, applying one after another."""
+    """Chain transforms, applying one after another.
+
+    The `TransformSequence()` constructor takes a sequence of transforms which must not be empty.
+    Empty sequences can be handled with `TransformSequence.empty(ndim: int)`.
+    """
 
     def __init__(
         self,
         transforms: Sequence[Transform[ArrayT]],
-        *,
-        spaces: Spaces = Spaces(None, None),
     ) -> None:
         """Combine transforms by chaining them.
 
-        Also checks for consistent dimensionality and space references,
-        inferring if None.
+        Empty sequences raise an error;
+        use the `TransformSequence.empty(ndim)` constructor instead.
+
+        Also checks for consistent dimensionality.
 
         Parameters
         ----------
         transforms :
             Items which are a TransformSequences
             will each still be treated as a single transform.
-        spaces :
-            Optional source and target spaces.
-            Can also be inferred from the first and last transforms.
 
         Raises
         ------
         ValueError
-            If spaces are incompatible.
+            If spaces are incompatible, or no spaces are given.
         """
-        ts = infer_spaces(transforms, *spaces)
+        ts = list(transforms)
         if not ts:
-            raise ValueError("Empty transform sequence")
+            raise ValueError(
+                "Empty transform sequence; use TransformSequence.empty(ndim)"
+            )
 
         for idx, (t1, t2) in enumerate(pairwise(ts)):
             if t1.ndims.target != t2.ndims.source:
@@ -312,16 +282,20 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
                     f"and the next source is {t2.ndims.source}D"
                 )
 
-        spaces = Spaces(ts[0].spaces.source, ts[-1].spaces.target)
         ndims = NDims(ts[0].ndims.source, ts[-1].ndims.target)
 
-        super().__init__(
-            ndims,
-            spaces=spaces,
-        )
+        super().__init__(ndims)
 
         self.transforms: list[Transform[ArrayT]] = ts
 
+    @classmethod
+    def empty(cls, ndim: int) -> Self:
+        from .transforms import Identity
+
+        out = cls([Identity(ndim)])
+        out.transforms.pop()
+        return out
+
     def __iter__(self) -> Iterator[Transform[ArrayT]]:
         """Iterate through component transforms.
 
@@ -341,13 +315,15 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
         return len(self.transforms)
 
     def invert(self) -> Transform[ArrayT] | None:
+        if self.is_empty():
+            return type(self).empty(self.ndims.source)
+
         try:
             transforms = [~t for t in reversed(self.transforms)]
         except NotImplementedError:
             return None
         return type(self)(
             transforms,
-            spaces=self.spaces.invert(),
         )
 
     def apply(self, coords: ArrayT) -> ArrayT:
@@ -357,45 +333,13 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
 
     def to_device(self, xp: ModuleType, device: str | None = None) -> Self:
         result = copy(self)
-        result.transforms = [t.to_device(xp, device) for t in self.transforms]
+        if not self.is_empty():
+            result.transforms = [t.to_device(xp, device) for t in self.transforms]
         return result
 
-    def list_spaces(self, skip_none: bool = False) -> list[SpaceRef]:
-        """List spaces in this transform.
-
-        Parameters
-        ----------
-        skip_none
-            Whether to skip undefined spaces, default False.
-
-        Returns
-        -------
-        list[SpaceRef]
-            The list of spaces.
-        """
-        spaces = [self.spaces.source] + [t.spaces.target for t in self.transforms]
-        if skip_none:
-            spaces = [s for s in spaces if s is not None]
-        return spaces
-
-    def split(self) -> Iterator[Transform[ArrayT]]:
-        """Split the sequence where an intermediate space is known."""
-        this_seq = []
-
-        for t in self.transforms:
-            if t.spaces.source is not None and t.spaces.target is not None:
-                yield t
-                continue
-
-            this_seq.append(t)
-            if t.spaces.target is not None:
-                yield type(self)(this_seq)
-                this_seq = []
-
     def __str__(self) -> str:
-        cls_name = type(self).__name__
-        spaces_str = "->".join(space_str(s) for s in self.list_spaces())
-        return f"{cls_name}[{spaces_str}]"
+        spaces_str = join_strs(self.transforms, "|")
+        return f"{super().__str__()}({spaces_str})"
 
     def __getitem__(self, idx: slice | int):
         if isinstance(idx, int):
@@ -405,10 +349,16 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
     def is_identity(self) -> bool:
         return all(t.is_identity() for t in self)
 
+    def is_empty(self) -> bool:
+        return not self.transforms
+
     def flatten(self, drop_inverse: bool = True) -> Self:
         """Flatten nested sequences."""
         from .transforms.bijection import Bijection
 
+        if self.is_empty():
+            return copy(self)
+
         out: list[Transform[ArrayT]] = []
 
         for t in self.transforms:
@@ -418,7 +368,7 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
                 out.extend(t.flatten())
             else:
                 out.append(t)
-        return TransformSequence(out, spaces=self.spaces)  # type:ignore
+        return TransformSequence(out)  # type:ignore
 
     def simplify(self, drop_inverse: bool = True):
         """Reduce the number of transformations in this sequence if possible.
@@ -433,7 +383,8 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
         Does not check whether transforms invert each other,
         e.g. `Translation(1) | Translation(-1)`.
         """
-        from .transforms import Identity
+        if self.is_empty():
+            return copy(self)
 
         out: list[Transform[ArrayT]] = []
         affine = None
@@ -459,11 +410,13 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
             add_to_output(affine, out)
 
         if not out:
-            out.append(Identity(self.ndims.source))
+            return type(self).empty(self.ndims.source)
 
-        return type(self)(out, spaces=self.spaces)
+        return type(self)(out)
 
     def to_affine(self) -> Affine[ArrayT] | None:
+        if self.is_empty():
+            return Affine.identity(self.ndims.source)  # type:ignore
         simple = self.simplify(True)
         if len(simple) != 1:
             return None
@@ -475,6 +428,5 @@ def add_to_output(transform: Transform, lst: list[Transform]) -> bool:
         return False
 
     transform = copy(transform)
-    transform.spaces = Spaces(None, None)
     lst.append(transform)
     return True