spatialdata 0.7.3a1__tar.gz → 0.7.3a2__tar.gz

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/.github/workflows/test.yaml

@@ -19,12 +19,12 @@ jobs:
             fail-fast: false
             matrix:
                 include:
-                    - {os: windows-latest, python: "3.11", dask-version: "2025.12.0", name: "Dask 2025.12.0"}
-                    - {os: windows-latest, python: "3.13", dask-version: "latest", name: "Dask latest"}
-                    - {os: ubuntu-latest, python: "3.11", dask-version: "latest", name: "Dask latest"}
-                    - {os: ubuntu-latest, python: "3.13", dask-version: "latest", name: "Dask latest"}
-                    - {os: macos-latest, python: "3.11", dask-version: "latest", name: "Dask latest"}
-                    - {os: macos-latest, python: "3.13", prerelease: "allow", name: "Python 3.13 (pre-release)"}
+                    - {os: windows-latest, python: "3.11", dask-version: "2025.12.0", name: "min dask"}
+                    - {os: windows-latest, python: "3.14", dask-version: "latest"}
+                    - {os: ubuntu-latest, python: "3.11", dask-version: "latest"}
+                    - {os: ubuntu-latest, python: "3.14", dask-version: "latest"}
+                    - {os: macos-latest, python: "3.11", dask-version: "latest"}
+                    - {os: macos-latest, python: "3.14", prerelease: "allow", name: "prerelease"}
         env:
             OS: ${{ matrix.os }}
             PYTHON: ${{ matrix.python }}
@@ -59,7 +59,7 @@ jobs:
                   PLATFORM: ${{ matrix.os }}
                   DISPLAY: :42
               run: |
-                  uv run pytest --cov --color=yes --cov-report=xml
+                  uv run pytest --cov --color=yes --cov-report=xml -n auto --dist worksteal
             - name: Upload coverage to Codecov
               uses: codecov/codecov-action@v5
               with:

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/.pre-commit-config.yaml

@@ -9,18 +9,18 @@ ci:
     skip: []
 repos:
     - repo: https://github.com/rbubley/mirrors-prettier
-      rev: v3.8.1
+      rev: v3.8.3
       hooks:
           - id: prettier
             exclude: ^.github/workflows/test.yaml
     - repo: https://github.com/pre-commit/mirrors-mypy
-      rev: v1.19.1
+      rev: v1.20.2
       hooks:
           - id: mypy
             additional_dependencies: [numpy, types-requests]
             exclude: tests/|docs/
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.15.2
+      rev: v0.15.12
       hooks:
           - id: ruff
             args: [--fix, --exit-non-zero-on-fix]

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spatialdata
-Version: 0.7.3a1
+Version: 0.7.3a2
 Summary: Spatial data format.
 Project-URL: Documentation, https://spatialdata.scverse.org/en/latest
 Project-URL: Source, https://github.com/scverse/spatialdata.git
@@ -38,7 +38,7 @@ License: BSD 3-Clause License
         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: anndata>=0.12.10
+Requires-Dist: anndata>=0.9.1
 Requires-Dist: annsel>=0.1.2
 Requires-Dist: click
 Requires-Dist: dask-image

spatialdata-0.7.3a2/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.7.3a2'
+__version_tuple__ = version_tuple = (0, 7, 3, 'a2')
+
+__commit_id__ = commit_id = None

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/pyproject.toml

@@ -22,7 +22,7 @@ dynamic= [
 license = {file = "LICENSE"}
 readme = "README.md"
 dependencies = [
-    "anndata>=0.12.10",
+    "anndata>=0.9.1",
     "annsel>=0.1.2",
     "click",
     "dask-image",
@@ -69,6 +69,7 @@ test = [
     "pytest",
     "pytest-cov",
     "pytest-mock",
+    "pytest-xdist",
     "torch",
 ]
 docs = [
@@ -102,6 +103,7 @@ strict = true
 addopts = [
     "--import-mode=importlib",  # allow using test files with same name
     "-s",  # print output from tests
+    "-p no:napari",  # napari registers a pytest plugin via its entry point; disable it here since spatialdata tests don't need it
 ]
 # These are all markers coming from xarray, dask or anndata. Added here to silence warnings.
 markers = [

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_core/_elements.py

@@ -21,7 +21,6 @@ from spatialdata.models import (
     PointsModel,
     ShapesModel,
     TableModel,
-    get_axes_names,
     get_model,
 )
 
@@ -50,6 +49,7 @@ class Elements(UserDict[str, T]):
                 raise KeyError(*e.args) from e
 
     def __setitem__(self, key: str, value: T) -> None:
+        # note that each __setitem__ in the subclasses calls get_model(), which performs data validation
         self._add_shared_key(key)
         super().__setitem__(key, value)
 
@@ -72,15 +72,7 @@ class Images(Elements[DataArray | DataTree]):
         schema = get_model(value)
         if schema not in (Image2DModel, Image3DModel):
             raise TypeError(f"Unknown element type with schema: {schema!r}.")
-        ndim = len(get_axes_names(value))
-        if ndim == 3:
-            Image2DModel.validate(value)
-            super().__setitem__(key, value)
-        elif ndim == 4:
-            Image3DModel.validate(value)
-            super().__setitem__(key, value)
-        else:
-            NotImplementedError("TODO: implement for ndim > 4.")
+        super().__setitem__(key, value)
 
 
 class Labels(Elements[DataArray | DataTree]):
@@ -89,15 +81,7 @@ class Labels(Elements[DataArray | DataTree]):
         schema = get_model(value)
         if schema not in (Labels2DModel, Labels3DModel):
             raise TypeError(f"Unknown element type with schema: {schema!r}.")
-        ndim = len(get_axes_names(value))
-        if ndim == 2:
-            Labels2DModel.validate(value)
-            super().__setitem__(key, value)
-        elif ndim == 3:
-            Labels3DModel.validate(value)
-            super().__setitem__(key, value)
-        else:
-            NotImplementedError("TODO: implement for ndim > 3.")
+        super().__setitem__(key, value)
 
 
 class Shapes(Elements[GeoDataFrame]):
@@ -106,7 +90,6 @@ class Shapes(Elements[GeoDataFrame]):
         schema = get_model(value)
         if schema != ShapesModel:
             raise TypeError(f"Unknown element type with schema: {schema!r}.")
-        ShapesModel.validate(value)
         super().__setitem__(key, value)
 
 
@@ -116,7 +99,6 @@ class Points(Elements[DaskDataFrame]):
         schema = get_model(value)
         if schema != PointsModel:
             raise TypeError(f"Unknown element type with schema: {schema!r}.")
-        PointsModel.validate(value)
         super().__setitem__(key, value)
 
 
@@ -126,5 +108,4 @@ class Tables(Elements[AnnData]):
         schema = get_model(value)
         if schema != TableModel:
             raise TypeError(f"Unknown element type with schema: {schema!r}.")
-        TableModel.validate(value)
         super().__setitem__(key, value)

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_core/centroids.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from collections import defaultdict
 from functools import singledispatch
 
-import dask.array as da
+import numpy as np
 import pandas as pd
 import xarray as xr
 from dask.dataframe import DataFrame as DaskDataFrame
@@ -56,40 +55,29 @@ def get_centroids(
     raise ValueError(f"The object type {type(e)} is not supported.")
 
 
-def _get_centroids_for_axis(xdata: xr.DataArray, axis: str) -> pd.DataFrame:
+def _get_centroids_for_labels(xdata: xr.DataArray) -> pd.DataFrame:
     """
-    Compute the component "axis" of the centroid of each label as a weighted average of the xarray coordinates.
+    Compute centroids for all labels in a DataArray in a single O(n_voxels) pass.
 
-    Parameters
-    ----------
-    xdata
-        The xarray DataArray containing the labels.
-    axis
-        The axis for which the centroids are computed.
-
-    Returns
-    -------
-    pd.DataFrame
-        A DataFrame containing one column, named after "axis", with the centroids of the labels along that axis.
-        The index of the DataFrame is the collection of label values, sorted in ascending order.
+    Works for any number of spatial dimensions (2D and 3D labels).
     """
-    centroids: dict[int, float] = defaultdict(float)
-    for i in xdata[axis]:
-        portion = xdata.sel(**{axis: i}).data
-        u = da.unique(portion, return_counts=True)
-        labels_values = u[0].compute()
-        counts = u[1].compute()
-        for j in range(len(labels_values)):
-            label_value = labels_values[j]
-            count = counts[j]
-            centroids[label_value] += count * i.values.item()
-
-    all_labels_values, all_labels_counts = da.unique(xdata.data, return_counts=True)
-    all_labels = dict(zip(all_labels_values.compute(), all_labels_counts.compute(), strict=True))
-    for label_value in centroids:
-        centroids[label_value] /= all_labels[label_value]
-    centroids = dict(sorted(centroids.items(), key=lambda x: x[0]))
-    return pd.DataFrame({axis: centroids.values()}, index=list(centroids.keys()))
+    arr = xdata.data.compute()
+    axes = list(xdata.dims)
+
+    # Map label values to a contiguous range for bincount efficiency.
+    label_ids, inverse = np.unique(arr, return_inverse=True)
+    flat_inverse = inverse.ravel()
+    counts = np.bincount(flat_inverse)  # per-label pixel counts
+
+    # indexing="ij" (matrix convention) ensures the i-th grid varies along the i-th
+    # dimension of the output, correctly aligning with xdata.dims for any number of axes.
+    coord_grids = np.meshgrid(*[xdata[ax].values for ax in axes], indexing="ij")
+    data: dict[str, np.ndarray] = {}
+    for ax, grid in zip(axes, coord_grids, strict=True):
+        coord_sums = np.bincount(flat_inverse, weights=grid.ravel().astype(float))
+        data[ax] = coord_sums / counts  # counts > 0 by construction (unique guarantees this)
+
+    return pd.DataFrame(data, index=label_ids)
 
 
 @get_centroids.register(DataArray)
@@ -109,10 +97,7 @@ def _(
         assert len(e["scale0"]) == 1
         e = next(iter(e["scale0"].values()))
 
-    dfs = []
-    for axis in get_axes_names(e):
-        dfs.append(_get_centroids_for_axis(e, axis))
-    df = pd.concat(dfs, axis=1)
+    df = _get_centroids_for_labels(e)
     if not return_background and 0 in df.index:
         df = df.drop(index=0)  # drop the background label
     t = get_transformation(e, coordinate_system)

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_io/io_points.py

@@ -24,7 +24,7 @@ def _read_points(
     store: str | Path,
 ) -> DaskDataFrame:
     """Read points from a zarr store."""
-    f = zarr.open(store, mode="r")
+    f = zarr.open(Path(store), mode="r")  # Path avoids zarr v3 URL-parsing special chars (e.g. #) in names
 
     version = _parse_version(f, expect_attrs_key=True)
     assert version is not None

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_io/io_raster.py

@@ -316,7 +316,7 @@ def _write_raster(
             **metadata,
         )
     elif isinstance(raster_data, DataTree):
-        _write_raster_datatree(
+        group = _write_raster_datatree(
             raster_type,
             group,
             name,
@@ -409,7 +409,7 @@ def _write_raster_datatree(
     raster_format: RasterFormatType,
     storage_options: JSONDict | list[JSONDict] | None = None,
     **metadata: str | JSONDict | list[JSONDict],
-) -> None:
+) -> zarr.Group:
     """Write raster data of type DataTree to disk.
 
     Parameters
@@ -460,6 +460,15 @@ def _write_raster_datatree(
     # os.replace is called. These can also be alleviated by using 'single-threaded' scheduler.
     da.compute(*dask_delayed, optimize_graph=False)
 
+    # Workaround for https://github.com/scverse/spatialdata/issues/1024.
+    # ome-zarr-py bundles write_multiscales_metadata() as a dask.delayed task in the compute=False
+    # code path (see https://github.com/ome/ome-zarr-py/issues/580). When da.compute() runs with
+    # the 'processes' scheduler that task executes in a subprocess: the on-disk zarr.json is written
+    # correctly, but the zarr.Group held in this process keeps its original in-memory GroupMetadata
+    # and never sees the update. Re-opening the group forces a fresh read from the store.
+    # This workaround should not be needed once https://github.com/ome/ome-zarr-py/issues/580 is fixed.
+    group = zarr.open_group(store=group.store, path=group.path, mode="r+", use_consolidated=False)
+
     trans_group = group["labels"][element_name] if raster_type == "labels" else group
     overwrite_coordinate_transformations_raster(
         group=trans_group,
@@ -467,6 +476,7 @@ def _write_raster_datatree(
         axes=tuple(input_axes),
         raster_format=raster_format,
     )
+    return group
 
 
 def write_image(

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_io/io_shapes.py

@@ -34,7 +34,7 @@ def _read_shapes(
     store: str | Path,
 ) -> GeoDataFrame:
     """Read shapes from a zarr store."""
-    f = zarr.open(store, mode="r")
+    f = zarr.open(Path(store), mode="r")  # Path avoids zarr v3 URL-parsing special chars (e.g. #) in names
     version = _parse_version(f, expect_attrs_key=True)
     assert version is not None
     shape_format = ShapesFormats[version]

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/_io/io_table.py

@@ -22,7 +22,7 @@ from spatialdata.models import TableModel, get_table_keys
 def _read_table(store: str | Path) -> AnnData:
     table = read_anndata_zarr(str(store))
 
-    f = zarr.open(store, mode="r")
+    f = zarr.open(Path(store), mode="r")  # Path avoids zarr v3 URL-parsing special chars (e.g. #) in names
     version = _parse_version(f, expect_attrs_key=False)
     assert version is not None
     table_format = TablesFormats[version]

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/datasets.py

@@ -397,7 +397,10 @@ def blobs_annotating_element(name: BlobsTypes) -> SpatialData:
         index = sdata[name].index
         instance_id = index.compute().tolist() if isinstance(index, dask.dataframe.Index) else index.tolist()
     n = len(instance_id)
-    new_table = AnnData(shape=(n, 0), obs={"region": pd.Categorical([name] * n), "instance_id": instance_id})
+    obs_df = pd.DataFrame(
+        {"region": pd.Categorical([name] * n), "instance_id": instance_id}, index=[str(i) for i in range(n)]
+    )
+    new_table = AnnData(shape=(n, 0), obs=obs_df)
     new_table = TableModel.parse(new_table, region=name, region_key="region", instance_key="instance_id")
     del sdata.tables["table"]
     sdata["table"] = new_table

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/src/spatialdata/models/models.py

@@ -266,7 +266,7 @@ class RasterSchema:
             # Chunk single scale images
             if chunks is not None:
                 if isinstance(chunks, tuple):
-                    chunks = {dim: chunks[index] for index, dim in enumerate(data.dims)}
+                    chunks = dict(zip(data.dims, chunks, strict=True))
                 data = data.chunk(chunks=chunks)
         # recompute coordinates for (multiscale) spatial image
         data = compute_coordinates(data)
@@ -1250,14 +1250,17 @@ Schema_t: TypeAlias = (
 
 def get_model(
     e: SpatialElement,
+    validate: bool = True,
 ) -> Schema_t:
     """
-    Get the model for the given element.
+    Get the model for the given element. Validate using the model if `validate` is `True`.
 
     Parameters
     ----------
     e
         The element.
+    validate
+        Whether to validate the element using the model.
 
     Returns
     -------
@@ -1268,7 +1271,8 @@ def get_model(
         schema: Schema_t,
         e: SpatialElement,
     ) -> Schema_t:
-        schema.validate(e)
+        if validate:
+            schema.validate(e)
         return schema
 
     if isinstance(e, DataArray | DataTree):

{spatialdata-0.7.3a1 → spatialdata-0.7.3a2}/tests/conftest.py

@@ -1,6 +1,17 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+import os
+import sys
+
+# Disable numba JIT for the test suite (the test data is small so initializing the JIT is slower than using plain
+# Python). Force-set (not setdefault) so the runner environment cannot accidentally override with "0".
+os.environ["NUMBA_DISABLE_JIT"] = "1"
+# If a pytest plugin already imported numba before this conftest ran, patch the cached config value too.
+if "numba.core.config" in sys.modules:
+    sys.modules["numba.core.config"].NUMBA_DISABLE_JIT = 1
+
+import copy as _copy
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import Any
 
@@ -33,6 +44,25 @@ from spatialdata.models import (
     TableModel,
 )
 
+
+def _fast_deepcopy_sdata(sd: SpatialData) -> SpatialData:
+    """
+    Fast deepcopy for SpatialData objects in tests.
+
+    Uses copy.deepcopy (which skips model re-validation) and manually restores
+    the attrs that copy.deepcopy loses for DaskDataFrame (issue #503) and
+    GeoDataFrame (issue #286).
+    """
+    points_attrs = {k: _copy.deepcopy(v._attrs) for k, v in sd.points.items()}
+    shapes_attrs = {k: _copy.deepcopy(v.attrs) for k, v in sd.shapes.items()}
+    sd_copy = _copy.deepcopy(sd)
+    for k, attrs in points_attrs.items():
+        sd_copy.points[k]._attrs = attrs
+    for k, attrs in shapes_attrs.items():
+        sd_copy.shapes[k].attrs = attrs
+    return sd_copy
+
+
 SEED = 0
 RNG = default_rng(seed=SEED)
 
@@ -41,16 +71,26 @@ MULTIPOLYGON_PATH = Path(__file__).parent / "data/polygon.json"
 POINT_PATH = Path(__file__).parent / "data/points.json"
 
 
-@pytest.fixture()
-def images() -> SpatialData:
+@pytest.fixture(scope="session")
+def _images_session() -> SpatialData:
     return SpatialData(images=_get_images())
 
 
 @pytest.fixture()
-def labels() -> SpatialData:
+def images(_images_session: SpatialData) -> SpatialData:
+    return _fast_deepcopy_sdata(_images_session)
+
+
+@pytest.fixture(scope="session")
+def _labels_session() -> SpatialData:
     return SpatialData(labels=_get_labels())
 
 
+@pytest.fixture()
+def labels(_labels_session: SpatialData) -> SpatialData:
+    return _fast_deepcopy_sdata(_labels_session)
+
+
 @pytest.fixture()
 def shapes() -> SpatialData:
     return SpatialData(shapes=_get_shapes())
@@ -87,8 +127,8 @@ def tables() -> list[AnnData]:
     return _tables
 
 
-@pytest.fixture()
-def full_sdata() -> SpatialData:
+@pytest.fixture(scope="session")
+def _full_sdata_session() -> SpatialData:
     return SpatialData(
         images=_get_images(),
         labels=_get_labels(),
@@ -98,6 +138,22 @@ def full_sdata() -> SpatialData:
     )
 
 
+@pytest.fixture()
+def full_sdata(_full_sdata_session: SpatialData) -> SpatialData:
+    return _fast_deepcopy_sdata(_full_sdata_session)
+
+
+@pytest.fixture(scope="session")
+def _sdata_full_session() -> SpatialData:
+    return SpatialData(
+        images=_get_images(),
+        labels=_get_labels(),
+        shapes=_get_shapes(),
+        points=_get_points(),
+        tables=_get_tables(region="labels2d"),
+    )
+
+
 @pytest.fixture(
     # params=["labels"]
     params=["full", "empty"]
@@ -110,15 +166,9 @@ def full_sdata() -> SpatialData:
     ]
     # + ["empty_" + x for x in ["table"]] # TODO: empty table not supported yet
 )
-def sdata(request) -> SpatialData:
+def sdata(request, _sdata_full_session: SpatialData) -> SpatialData:
     if request.param == "full":
-        return SpatialData(
-            images=_get_images(),
-            labels=_get_labels(),
-            shapes=_get_shapes(),
-            points=_get_points(),
-            tables=_get_tables(region="labels2d"),
-        )
+        return _fast_deepcopy_sdata(_sdata_full_session)
     if request.param == "empty":
         return SpatialData()
     return request.getfixturevalue(request.param)
@@ -304,18 +354,38 @@ def _get_new_table(spatial_element: None | str | Sequence[str], instance_id: Non
     return TableModel.parse(adata=adata, spatial_element=spatial_element, instance_id=instance_id)
 
 
-@pytest.fixture()
-def labels_blobs() -> ArrayLike:
-    """Create a 2D labels."""
+@pytest.fixture(scope="session")
+def _labels_blobs_session() -> ArrayLike:
     return BlobsDataset()._labels_blobs()
 
 
 @pytest.fixture()
-def sdata_blobs() -> SpatialData:
+def labels_blobs(_labels_blobs_session: ArrayLike) -> ArrayLike:
     """Create a 2D labels."""
+    return deepcopy(_labels_blobs_session)
+
+
+@pytest.fixture(scope="session")
+def _sdata_blobs_session() -> SpatialData:
     from spatialdata.datasets import blobs
 
-    return deepcopy(blobs(256, 300, 3))
+    return blobs(256, 300, 3)
+
+
+@pytest.fixture()
+def sdata_blobs(_sdata_blobs_session: SpatialData) -> SpatialData:
+    """Create a 2D labels."""
+    return _fast_deepcopy_sdata(_sdata_blobs_session)
+
+
+@pytest.fixture()
+def blobs_factory(_sdata_blobs_session: SpatialData) -> Callable[[], SpatialData]:
+    """Return a factory that creates cheap fresh copies of the session-scoped blobs dataset."""
+
+    def _make() -> SpatialData:
+        return _fast_deepcopy_sdata(_sdata_blobs_session)
+
+    return _make
 
 
 def _make_points(coordinates: np.ndarray) -> DaskDataFrame:
@@ -542,7 +612,8 @@ def complex_sdata() -> SpatialData:
             "instance_id": range(1, 51),  # Skip background (0)
             "cell_type": pd.Categorical(RNG.choice(["T cell", "B cell", "Macrophage"], size=50)),
             "size": RNG.uniform(10, 100, size=50),
-        }
+        },
+        index=[str(i) for i in range(50)],
     )
 
     var1 = pd.DataFrame(
@@ -577,7 +648,8 @@ def complex_sdata() -> SpatialData:
             "category": pd.Categorical(RNG.choice(["A", "B", "C"], size=total_items)),
             "value": RNG.normal(size=total_items),
             "count": RNG.poisson(10, size=total_items),
-        }
+        },
+        index=[str(i) for i in range(total_items)],
     )
 
     var2 = pd.DataFrame(
@@ -608,7 +680,8 @@ def complex_sdata() -> SpatialData:
             "cluster": pd.Categorical(RNG.choice(["cluster_1", "cluster_2", "cluster_3"], size=40)),
             "sample": pd.Categorical(["sample_A"] * 20 + ["sample_B"] * 20),
             "qc_pass": RNG.choice([True, False], p=[0.8, 0.2], size=40),
-        }
+        },
+        index=[str(i) for i in range(40)],
     )
 
     var3 = pd.DataFrame(

spatialdata-0.7.3a2/tests/core/operations/conftest.py

@@ -0,0 +1 @@
+from __future__ import annotations