pysits 2.0.0.dev8__tar.gz → 2.0.0.dev10__tar.gz

pysits-2.0.0.dev10/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__claude_ai_SITS_MCP__sits_get_function"
+    ]
+  }
+}

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pysits
-Version: 2.0.0.dev8
+Version: 2.0.0.dev10
 Summary: Python wrapper for the sits R package
 Project-URL: Homepage, https://github.com/e-sensing/pysits
 Project-URL: Issue Tracker, https://github.com/e-sensing/pysits/issues

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/pyproject.toml

@@ -17,7 +17,7 @@
 
 [project]
 name = "pysits"
-version = "2.0.0.dev8"
+version = "2.0.0.dev10"
 description = "Python wrapper for the sits R package"
 readme = "README.md"
 requires-python = ">=3.10,<4"

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/pysits/__init__.py

@@ -87,8 +87,13 @@ from .sits.data import sits_summary as summary
 from .sits.exporters import (
     sits_as_geopandas,
     sits_as_xarray,
+    sits_config_to_hf,
+    sits_from_hf,
+    sits_from_parquet,
     sits_timeseries_to_csv,
     sits_to_csv,
+    sits_to_hf,
+    sits_to_parquet,
     sits_to_xlsx,
 )
 from .sits.impute import (
@@ -276,6 +281,11 @@ __all__ = (
     "sits_as_geopandas",
     "sits_to_xlsx",
     "sits_timeseries_to_csv",
+    "sits_to_parquet",
+    "sits_from_parquet",
+    "sits_to_hf",
+    "sits_from_hf",
+    "sits_config_to_hf",
     # Tuning
     "sits_tuning_hparams",
     "sits_tuning",

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/pysits/backend/functions.py

@@ -58,5 +58,8 @@ r_fnc_colnames = load_function_from_package("base::colnames")
 # Base - rownames (base)
 r_fnc_rownames = load_function_from_package("base::rownames")
 
+# Base - unname (base)
+r_fnc_unname = load_function_from_package("base::unname")
+
 # sits - configuration (internal)
 r_fnc_sits_conf = load_internal_function_from_package("sits:::.conf")

pysits-2.0.0.dev10/pysits/docs/content/sits_config_to_hf.md

@@ -0,0 +1,46 @@
+Describe a collection of sits as a HuggingFace dataset
+
+Data cubes shared on HuggingFace are described by a "sits/sits.yml" file
+in the dataset repository, which sits reads to open the dataset.
+
+This function writes that description from a collection registered in
+sits (see `sits_list_collections`), which is useful when a dataset shares
+images of a known collection (e.g., images of "SENTINEL-2-L2A" downloaded
+from "MPC").
+
+The description of a collection is written as the dataset needs it: the
+bands are named as sits names them in the images, and the properties used
+by sits to reach the provider are not written, as sits defines them when
+it registers a dataset.
+
+Args:
+    source (str): Data source.
+
+    collection (str): Image collection.
+
+    bands (list[str]): Bands shared in the dataset (default is all of
+        them).
+
+    output_dir (str | pathlib.Path): Existing directory where the file
+        "sits/sits.yml" is written (optional). When not informed, the
+        collection definition is only returned.
+
+Returns:
+    SITStructureData: Collection definition of the dataset.
+
+Note:
+    A dataset must describe only the bands it holds, and the resolution of
+    each band is the one the collection declares. If you need to describe
+    a regularized cube, or a cube with custom bands, use `sits_to_hf`.
+
+Examples:
+    import tempfile
+    from pysits import *
+
+    # describe a collection as a HuggingFace dataset
+    sits_config_to_hf(
+        source="MPC",
+        collection="SENTINEL-2-L2A",
+        bands=["B02", "B03", "B04", "B08"],
+        output_dir=tempfile.gettempdir(),
+    )

pysits-2.0.0.dev10/pysits/docs/content/sits_from_hf.md

@@ -0,0 +1,85 @@
+Read data cubes, samples and models shared on HuggingFace
+
+Reads data shared in a HuggingFace repository. The content of the
+repository defines what is read:
+
+- data cubes: datasets describing a collection in a "sits/sits.yml" file
+  (see `sits_to_hf`). The images selected are downloaded to `output_dir`
+  and a local data cube is returned;
+
+- samples: time series saved as ".rds" or ".parquet" files (see
+  `sits_to_parquet`);
+
+- models: models trained by `sits_train` and saved as ".rds" files.
+
+When `file` is not informed, a repository with a "sits/sits.yml" file is
+read as a data cube. Otherwise, the repository must have a single ".rds"
+or ".parquet" file. When there are many, choose one using `file`.
+
+Args:
+    repo (str): HuggingFace repository ("<user>/<repository>").
+
+    file (str): File to be read in the repository (optional).
+
+    type (str): Type of the repository: "dataset" (default) or "model".
+        Data cubes are always shared in datasets.
+
+    bands (list[str]): Bands to be selected in the data cube (optional).
+
+    tiles (list[str]): Tiles to be selected in the data cube (optional).
+
+    roi (dict | geopandas.GeoDataFrame): Region of interest to be selected
+        in the data cube (optional).
+
+    crs (str): The Coordinate Reference System (CRS) of the roi.
+
+    start_date (str): Start date of the data cube ("YYYY-MM-DD").
+
+    end_date (str): End date of the data cube ("YYYY-MM-DD").
+
+    output_dir (str | pathlib.Path): Existing directory where the images
+        of the data cube are saved (required for data cubes).
+
+    n_tries (int): Number of attempts to download the same image.
+
+    multicores (int): Number of cores for parallel downloading.
+
+    progress (bool): Show progress bar?
+
+    **kwargs: Other parameters to read data cubes: `labels` (dict) and
+        `version` (str) select results produced by sits (e.g.,
+        probabilities).
+
+Returns:
+    SITSCubeModel | SITSTimeSeriesModel | SITSMachineLearningMethod: A data
+    cube with local images, a set of samples, or a model.
+
+Note:
+    HuggingFace limits the number of files a user requests in windows of
+    five minutes. For this reason, the images of a data cube are
+    downloaded, each one requested only once, in batches that fit the
+    requests available. When no request is available, the download waits
+    the next window. Images already downloaded in `output_dir` are not
+    requested again, so an interrupted download is resumed by calling
+    `sits_from_hf` again.
+
+    To access private repositories, the HuggingFace access token must be
+    set in the `HF_TOKEN` environment variable.
+
+Examples:
+    import tempfile
+    from pysits import *
+
+    # download a data cube shared in a HuggingFace dataset
+    cube = sits_from_hf(
+        repo="felipemcarlos/sits_mod13q1_sinop",
+        output_dir=tempfile.gettempdir(),
+    )
+
+    # read samples shared in a HuggingFace dataset
+    samples = sits_from_hf(repo="felipemcarlos/sits_samples_modis_ndvi")
+
+    # read a model shared in a HuggingFace model repository
+    model = sits_from_hf(
+        repo="felipemcarlos/sits_rfor_modis_ndvi", type="model"
+    )

pysits-2.0.0.dev10/pysits/docs/content/sits_from_parquet.md

@@ -0,0 +1,26 @@
+Read sits time series from the Parquet format
+
+Reads a file written by `sits_to_parquet` and rebuilds the time series,
+with its class, column order and nested series.
+
+Files written by other programs are also read. Their class is then
+inferred from the columns, which must include "longitude", "latitude",
+"start_date", "end_date" and "label".
+
+Args:
+    file (str | pathlib.Path): Full path or HTTP(S) URL of the file to
+        read (valid file name with extension ".parquet").
+
+Returns:
+    SITSTimeSeriesModel: Time series.
+
+Raises:
+    httpx2.HTTPError: If a remote file cannot be downloaded.
+
+Examples:
+    import tempfile
+    from pysits import *
+
+    parquet_file = tempfile.gettempdir() + "/samples.parquet"
+    sits_to_parquet(samples_modis_ndvi, file=parquet_file)
+    samples = sits_from_parquet(parquet_file)

pysits-2.0.0.dev10/pysits/docs/content/sits_to_hf.md

@@ -0,0 +1,76 @@
+Describe a data cube as a HuggingFace dataset
+
+Data cubes shared on HuggingFace are described by files sits reads to
+understand the dataset. They are kept in a "sits" directory of the
+repository, so they are not mixed with the other files of the dataset:
+
+- "sits/sits.yml": the collection definition of the dataset;
+
+- "sits/cache.rds": the data cube of the dataset. When it is available,
+  sits loads it instead of reading each image of the dataset.
+
+This function writes these files in `output_dir`, as they must be uploaded
+to the repository (i.e., the "sits" directory and the images, named as
+sits names them, in the root of the repository). Nothing is uploaded by
+this function.
+
+The collection definition is written from a data cube: the bands, their
+resolution and, for results produced by sits (e.g., probabilities,
+classified maps), the labels of the classification.
+
+Each type of cube is described the way sits reads it:
+
+- image raster cubes are described band by band;
+
+- embeddings have only base satellite and sensor described;
+
+- results produced by sits inform only their resolution and the labels
+  of the classification.
+
+A dataset can share more than one result of the same classification
+(e.g., probabilities and the classified map), which are described
+together when they are informed as a list of cubes. A cache describes a
+single cube, so it is not written for a list of cubes.
+
+Args:
+    cube (SITSCubeModel | list[SITSCubeModel]): Data cube or list of cubes
+        to be shared as a dataset.
+
+    output_dir (str | pathlib.Path): Existing directory where the files of
+        the dataset are written (optional). When not informed, the
+        collection definition is only returned.
+
+    repo (str): HuggingFace repository where the images are uploaded
+        ("<user>/<dataset>"). Required to write the cache of a data cube,
+        unless the cube was read from HuggingFace.
+
+Returns:
+    SITStructureData: Collection definition of the dataset.
+
+Note:
+    Images must be named in the dataset as sits names them
+    (`sits_cube_copy` and `sits_regularize` do it), and only the bands
+    shared in the dataset must be described.
+
+Examples:
+    import tempfile
+    from pysits import *
+
+    # create a cube
+    data_dir = r_package_dir("extdata/raster/mod13q1", package="sits")
+    cube = sits_cube(
+        source="BDC",
+        collection="MOD13Q1-6.1",
+        data_dir=data_dir,
+    )
+
+    # get the collection definition of the cube
+    collection_conf = sits_to_hf(cube)
+
+    # write the files describing the dataset ("sits/sits.yml" and
+    # "sits/cache.rds"), to be uploaded with the images of the cube
+    sits_to_hf(
+        cube,
+        output_dir=tempfile.gettempdir(),
+        repo="user/dataset",
+    )

pysits-2.0.0.dev10/pysits/docs/content/sits_to_parquet.md

@@ -0,0 +1,23 @@
+Export sits time series to the Parquet format
+
+Writes a set of time series to a Parquet file. The layout is long: one
+row per sample and date, with the time series as plain columns. The
+file metadata keeps what is needed to rebuild the data with
+`sits_from_parquet` (class, column order and bands). It also follows
+GeoParquet 1.1, so tools like GDAL and QGIS read the file as points.
+
+Args:
+    data (SITSTimeSeriesModel): Time series.
+
+    file (str | pathlib.Path): Full path of the exported file (valid
+        file name with extension ".parquet").
+
+Returns:
+    None
+
+Examples:
+    import tempfile
+    from pysits import *
+
+    parquet_file = tempfile.gettempdir() + "/samples.parquet"
+    sits_to_parquet(samples_modis_ndvi, file=parquet_file)

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/pysits/sits/exporters/__init__.py

@@ -17,7 +17,14 @@
 
 """Exporters module."""
 
-from .files import sits_timeseries_to_csv, sits_to_csv, sits_to_xlsx
+from .files import (
+    sits_from_parquet,
+    sits_timeseries_to_csv,
+    sits_to_csv,
+    sits_to_parquet,
+    sits_to_xlsx,
+)
+from .hf import sits_config_to_hf, sits_from_hf, sits_to_hf
 from .sf import sits_as_geopandas
 from .xarray import sits_as_xarray
 
@@ -27,4 +34,9 @@ __all__ = (
     "sits_to_csv",
     "sits_to_xlsx",
     "sits_timeseries_to_csv",
+    "sits_to_parquet",
+    "sits_from_parquet",
+    "sits_to_hf",
+    "sits_from_hf",
+    "sits_config_to_hf",
 )

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/pysits/sits/exporters/files.py

@@ -17,10 +17,15 @@
 
 """Files exporter."""
 
+from pathlib import Path
+
 from pysits.backend.pkgs import r_pkg_sits
 from pysits.conversions.decorators import function_call
 from pysits.docs import attach_doc
 from pysits.models.data.frame import SITSFrame
+from pysits.models.data.ts import SITSTimeSeriesModel
+from pysits.models.resolver import resolve_and_invoke_content_class
+from pysits.network import fetch_to_tempfile, is_remote
 
 
 @function_call(r_pkg_sits.sits_to_csv, SITSFrame)
@@ -41,3 +46,28 @@ def sits_to_xlsx(*args, **kwargs) -> None:
 @attach_doc("sits_timeseries_to_csv")
 def sits_timeseries_to_csv(*args, **kwargs) -> None:
     """Export a full sits timeseries to CSV format."""
+
+
+@function_call(r_pkg_sits.sits_to_parquet, lambda x: None)
+@attach_doc("sits_to_parquet")
+def sits_to_parquet(*args, **kwargs) -> None:
+    """Export sits time series to the Parquet format."""
+
+
+@function_call(r_pkg_sits.sits_from_parquet, resolve_and_invoke_content_class)
+def _sits_from_parquet(*args, **kwargs) -> SITSTimeSeriesModel:
+    """Read sits time series from a local Parquet file."""
+
+
+@attach_doc("sits_from_parquet")
+def sits_from_parquet(file: str | Path) -> SITSTimeSeriesModel:
+    """Read sits time series from the Parquet format."""
+    # If file is remote
+    if is_remote(file):
+        # Download it to a temporary file
+        with fetch_to_tempfile(str(file), suffix=".parquet") as local_file:
+            # Read it
+            return _sits_from_parquet(local_file)
+
+    # Otherwise, read it directly
+    return _sits_from_parquet(file)

pysits-2.0.0.dev10/pysits/sits/exporters/hf.py

@@ -0,0 +1,74 @@
+#
+# Copyright (C) 2025 sits developers.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+
+"""HuggingFace exporter."""
+
+from pysits.backend.functions import r_fnc_unname
+from pysits.backend.pkgs import r_pkg_sits
+from pysits.conversions.common import convert_to_r
+from pysits.conversions.decorators import function_call, rpy2_fix_type_custom
+from pysits.docs import attach_doc
+from pysits.models.data.base import SITStructureData
+from pysits.models.data.cube import SITSCubeModel
+from pysits.models.data.ts import SITSTimeSeriesModel
+from pysits.models.ml import SITSMachineLearningMethod
+from pysits.models.resolver import resolve_and_invoke_content_class
+
+
+#
+# HuggingFace-specific converters functions
+#
+def convert_hf_cubes(obj: object) -> object:
+    """Convert a list of cubes to an unnamed R list."""
+    if isinstance(obj, list | tuple):
+        return r_fnc_unname(convert_to_r(obj))
+
+    return obj
+
+
+#
+# HuggingFace-specific converters config
+#
+hf_converters = {
+    "cube": convert_hf_cubes,
+}
+
+
+#
+# HuggingFace
+#
+@function_call(r_pkg_sits.sits_from_hf, resolve_and_invoke_content_class)
+@attach_doc("sits_from_hf")
+def sits_from_hf(
+    *args, **kwargs
+) -> SITSCubeModel | SITSTimeSeriesModel | SITSMachineLearningMethod:
+    """Read data cubes, samples and models shared on HuggingFace."""
+
+
+@rpy2_fix_type_custom(converters=hf_converters)
+@function_call(r_pkg_sits.sits_to_hf, SITStructureData)
+@attach_doc("sits_to_hf")
+def sits_to_hf(
+    cube: SITSCubeModel | list[SITSCubeModel], *args, **kwargs
+) -> SITStructureData:
+    """Describe a data cube as a HuggingFace dataset."""
+
+
+@function_call(r_pkg_sits.sits_config_to_hf, SITStructureData)
+@attach_doc("sits_config_to_hf")
+def sits_config_to_hf(*args, **kwargs) -> SITStructureData:
+    """Describe a collection of sits as a HuggingFace dataset."""

{pysits-2.0.0.dev8 → pysits-2.0.0.dev10}/tests/test_exporters.py

@@ -25,8 +25,15 @@ import pytest
 from pysits.backend.pkgs import r_pkg_sits
 from pysits.models.data.frame import SITSFrame
 from pysits.models.data.matrix import SITSConfusionMatrix
+from pysits.models.data.ts import SITSTimeSeriesModel
 from pysits.sits.context import cerrado_2classes
-from pysits.sits.exporters import sits_timeseries_to_csv, sits_to_csv, sits_to_xlsx
+from pysits.sits.exporters import (
+    sits_from_parquet,
+    sits_timeseries_to_csv,
+    sits_to_csv,
+    sits_to_parquet,
+    sits_to_xlsx,
+)
 from pysits.sits.ml import sits_rfor
 from pysits.sits.ts import sits_sample, sits_validate
 
@@ -94,3 +101,46 @@ def test_sits_to_xlsx(tmp_path: Path, accuracy):
     r_pkg_sits.sits_to_xlsx(accuracy._instance, file=str(r_file))
 
     assert read_xlsx(py_file) == read_xlsx(r_file)
+
+
+def test_sits_parquet(tmp_path: Path):
+    """Test time series export / import using parquet."""
+    # local file
+    file = tmp_path / "samples.parquet"
+
+    # export samples as parquet
+    sits_to_parquet(cerrado_2classes, file=file)
+
+    # import samples from parquet
+    samples = sits_from_parquet(file)
+
+    # samples must be a time series model
+    assert isinstance(samples, SITSTimeSeriesModel)
+
+    # metadata and nested series must be equal to the original samples
+    metadata = samples.drop(columns="time_series")
+    expected = cerrado_2classes.drop(columns="time_series")
+
+    assert metadata.equals(expected)
+    assert all(
+        ts.equals(expected_ts)
+        for ts, expected_ts in zip(
+            samples["time_series"], cerrado_2classes["time_series"], strict=True
+        )
+    )
+
+
+def test_sits_from_parquet_remote(http_server):
+    """Test time series import using remote parquet file."""
+    # remote file
+    directory, base_url = http_server
+
+    # export samples as parquet
+    sits_to_parquet(cerrado_2classes, file=directory / "samples.parquet")
+
+    # import samples from parquet
+    samples = sits_from_parquet(f"{base_url}/samples.parquet")
+
+    # samples must be a time series model
+    assert isinstance(samples, SITSTimeSeriesModel)
+    assert len(samples) == len(cerrado_2classes)

pysits-2.0.0.dev10/tests/test_exporters_hf.py

@@ -0,0 +1,154 @@
+#
+# Copyright (C) 2025 sits developers.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+
+"""Unit tests for HuggingFace export operations."""
+
+from pathlib import Path
+
+import httpx2
+import pytest
+
+from pysits.backend.pkgs import r_pkg_sits
+from pysits.models.data.base import SITStructureData
+from pysits.models.data.cube import SITSCubeModel
+from pysits.models.data.ts import SITSTimeSeriesModel
+from pysits.models.ml import SITSMachineLearningMethod
+from pysits.sits.exporters import sits_config_to_hf, sits_from_hf, sits_to_hf
+
+
+#
+# Helpers
+#
+def list_files(directory: Path) -> list[str]:
+    """List the files of a directory."""
+    return sorted(
+        file.relative_to(directory).as_posix()
+        for file in directory.rglob("*")
+        if file.is_file()
+    )
+
+
+#
+# Fixtures
+#
+@pytest.fixture(scope="module")
+def hf_online() -> None:
+    """Skip the tests of a module when HuggingFace is not accessible."""
+    try:
+        httpx2.head("https://huggingface.co", follow_redirects=True)
+
+    except httpx2.HTTPError:
+        pytest.skip("HuggingFace is not accessible")
+
+
+#
+# Tests
+#
+def test_sits_to_hf(local_cube, tmp_path: Path):
+    """Test data cube described as a HuggingFace dataset."""
+    py_dir = tmp_path / "python"
+    r_dir = tmp_path / "r"
+    list_dir = tmp_path / "list"
+
+    for directory in (py_dir, r_dir, list_dir):
+        directory.mkdir()
+
+    # single cube, definition and cache are written
+    result = sits_to_hf(local_cube, output_dir=py_dir, repo="user/dataset")
+    r_pkg_sits.sits_to_hf(
+        local_cube._instance, output_dir=str(r_dir), repo="user/dataset"
+    )
+
+    # validate the results
+    assert isinstance(result, SITStructureData)
+    assert list_files(py_dir) == ["sits/cache.rds", "sits/sits.yml"]
+
+    # read the results
+    result_py = (py_dir / "sits/sits.yml").read_text()
+    result_r = (r_dir / "sits/sits.yml").read_text()
+
+    assert result_py == result_r
+
+    # convert list of cubes
+    sits_to_hf([local_cube], output_dir=list_dir)
+
+    # test - only the definition is written, cache is not supported
+    assert list_files(list_dir) == ["sits/sits.yml"]
+
+
+def test_sits_config_to_hf(tmp_path: Path):
+    """Test collection described as a HuggingFace dataset."""
+    py_dir = tmp_path / "python"
+    r_dir = tmp_path / "r"
+
+    for directory in (py_dir, r_dir):
+        directory.mkdir()
+
+    # convert collection
+    result = sits_config_to_hf(
+        source="MPC",
+        collection="SENTINEL-2-L2A",
+        bands=["B02", "B03"],
+        output_dir=py_dir,
+    )
+
+    # convert collection in R
+    r_pkg_sits.sits_config_to_hf(
+        source="MPC",
+        collection="SENTINEL-2-L2A",
+        bands=["B02", "B03"],
+        output_dir=str(r_dir),
+    )
+
+    # validate the results
+    assert isinstance(result, SITStructureData)
+    assert list_files(py_dir) == ["sits/sits.yml"]
+
+    # read the results
+    result_py = (py_dir / "sits/sits.yml").read_text()
+    result_r = (r_dir / "sits/sits.yml").read_text()
+
+    assert result_py == result_r
+
+
+@pytest.mark.parametrize(
+    "repo, options, expected",
+    [
+        (
+            "felipemcarlos/sits_mod13q1_sinop",
+            {"start_date": "2013-09-14", "end_date": "2013-10-16"},
+            SITSCubeModel,
+        ),
+        ("felipemcarlos/sits_samples_modis_ndvi", {}, SITSTimeSeriesModel),
+        (
+            "felipemcarlos/sits_rfor_modis_ndvi",
+            {"type": "model"},
+            SITSMachineLearningMethod,
+        ),
+    ],
+)
+def test_sits_from_hf(hf_online, tmp_path: Path, repo: str, options: dict, expected):
+    """Test data cube, samples and model read from HuggingFace."""
+    result = sits_from_hf(
+        repo,
+        output_dir=tmp_path,
+        progress=False,
+        **options,
+    )
+
+    # validate the results
+    assert isinstance(result, expected)