bw-processing 0.9.6__tar.gz → 1.1__tar.gz

bw_processing-1.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include src/bw_processing/examples/*.zip
+include src/bw_processing/examples/datapackage_1/*.parquet
+recursive-exclude dev *

{bw_processing-0.9.6/bw_processing.egg-info → bw_processing-1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: bw_processing
-Version: 0.9.6
+Version: 1.1
 Summary: Foo
 Author-email: Chris Mutel <cmutel@gmail.com>
 Maintainer-email: Chris Mutel <cmutel@gmail.com>
@@ -38,6 +38,7 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-randomly; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Dynamic: license-file
 
 # bw-processing
 
@@ -81,7 +82,7 @@ The [Brightway LCA framework](https://brightway.dev/) has stored data used in co
 * **Support for vector and array data**. Vector (i.e. only one possible value per input) and array (i.e. many possible values, also called presamples) data are now both natively supported in data packages.
 * **Portability**. Processed arrays can include metadata that allows for reindexing on other machines, so that processed arrays can be distributed and reused. Before, this was not possible, as integer IDs were randomly assigned on each computer, and would be different from machine to machine or even across Brightway projects.
 * **Dynamic data sources**. Instead of requiring that data for matrix construction be present and savedd on disk, it can now be generated dynamically, either through code running locally or on another computer system. This is a big step towards embeddding life cycle assessment in a web of environmental models.
-* **Use [PyFilesystem2](https://docs.pyfilesystem.org/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
+* **Use [fsspec](https://filesystem-spec.readthedocs.io/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
 * **Simpler handling of numeric values whose sign should be flipped**. Sometimes it is more convenient to specify positive numbers in dataset definitions, even though such numbers should be negative when inserted into the resulting matrices. For example, in the technosphere matrix in life cycle assessment, products produced are positive and products consumed are negative, though both values are given as positive in datasets. Brightway used to use a type mapping dictionary to indicate which values in a matrix should have their sign flipped after insertion. Such mapping dictionaries are brittle and inelegant. `bw_processing` uses an optional boolean vector, called `flip`, to indicate if any values should be flipped.
 * **Separation of uncertainty distribution parameters from other data**. Fitting data to a [probability density function](https://en.wikipedia.org/wiki/Probability_density_function) (PDF), or an estimate of such a PDF, is only one approach to quantitative uncertainty analysis. We would like to support other approaches, including [direct sampling from real data](https://github.com/PascalLesage/presamples/). Therefore, uncertainty distribution parameters are stored separately,  only loaded if needed, and are only one way to express quantitative uncertainty.
 

{bw_processing-0.9.6 → bw_processing-1.1}/README.md

@@ -40,7 +40,7 @@ The [Brightway LCA framework](https://brightway.dev/) has stored data used in co
 * **Support for vector and array data**. Vector (i.e. only one possible value per input) and array (i.e. many possible values, also called presamples) data are now both natively supported in data packages.
 * **Portability**. Processed arrays can include metadata that allows for reindexing on other machines, so that processed arrays can be distributed and reused. Before, this was not possible, as integer IDs were randomly assigned on each computer, and would be different from machine to machine or even across Brightway projects.
 * **Dynamic data sources**. Instead of requiring that data for matrix construction be present and savedd on disk, it can now be generated dynamically, either through code running locally or on another computer system. This is a big step towards embeddding life cycle assessment in a web of environmental models.
-* **Use [PyFilesystem2](https://docs.pyfilesystem.org/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
+* **Use [fsspec](https://filesystem-spec.readthedocs.io/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
 * **Simpler handling of numeric values whose sign should be flipped**. Sometimes it is more convenient to specify positive numbers in dataset definitions, even though such numbers should be negative when inserted into the resulting matrices. For example, in the technosphere matrix in life cycle assessment, products produced are positive and products consumed are negative, though both values are given as positive in datasets. Brightway used to use a type mapping dictionary to indicate which values in a matrix should have their sign flipped after insertion. Such mapping dictionaries are brittle and inelegant. `bw_processing` uses an optional boolean vector, called `flip`, to indicate if any values should be flipped.
 * **Separation of uncertainty distribution parameters from other data**. Fitting data to a [probability density function](https://en.wikipedia.org/wiki/Probability_density_function) (PDF), or an estimate of such a PDF, is only one approach to quantitative uncertainty analysis. We would like to support other approaches, including [direct sampling from real data](https://github.com/PascalLesage/presamples/). Therefore, uncertainty distribution parameters are stored separately,  only loaded if needed, and are only one way to express quantitative uncertainty.
 

{bw_processing-0.9.6 → bw_processing-1.1}/pyproject.toml

@@ -66,7 +66,9 @@ dev = [
 [tool.setuptools]
 license-files = ["LICENSE"]
 include-package-data = true
-packages = ["bw_processing", "bw_processing.examples"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
 
 [tool.setuptools.dynamic]
 version = {attr = "bw_processing.__version__"}

bw_processing-1.1/src/bw_processing/__init__.py

@@ -0,0 +1,52 @@
+__all__ = (
+    "__version__",
+    "as_unique_attributes",
+    "as_unique_attributes_dataframe",
+    "clean_datapackage_name",
+    "create_array",
+    "create_datapackage",
+    "create_datapackage_from_entries",
+    "create_structured_array",
+    "Datapackage",
+    "DatapackageBase",
+    "DEFAULT_LICENSES",
+    "examples_dir",
+    "FilteredDatapackage",
+    "generic_directory_filesystem",
+    "generic_zipfile_filesystem",
+    "INDICES_DTYPE",
+    "load_datapackage",
+    "MatrixEntry",
+    "MatrixName",
+    "MatrixSerializeFormat",
+    "md5",
+    "merge_datapackages_with_mask",
+    "reindex",
+    "reset_index",
+    "safe_filename",
+    "simple_graph",
+    "UNCERTAINTY_DTYPE",
+    "UndefinedInterface",
+)
+
+__version__ = "1.1"
+
+
+from bw_processing.array_creation import create_array, create_structured_array
+from bw_processing.constants import DEFAULT_LICENSES, INDICES_DTYPE, UNCERTAINTY_DTYPE, MatrixSerializeFormat
+from bw_processing.datapackage import (
+    Datapackage,
+    DatapackageBase,
+    FilteredDatapackage,
+    create_datapackage,
+    load_datapackage,
+    simple_graph,
+)
+from bw_processing.examples import examples_dir
+from bw_processing.filesystem import clean_datapackage_name, md5, safe_filename
+from bw_processing.indexing import reindex, reset_index
+from bw_processing.io_helpers import generic_directory_filesystem, generic_zipfile_filesystem
+from bw_processing.matrix_entry import MatrixEntry, MatrixName, create_datapackage_from_entries
+from bw_processing.merging import merge_datapackages_with_mask
+from bw_processing.proxies import UndefinedInterface
+from bw_processing.unique_fields import as_unique_attributes, as_unique_attributes_dataframe

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/constants.py

@@ -4,6 +4,7 @@ from enum import Enum
 import numpy as np
 
 MAX_SIGNED_32BIT_INT = 2147483647
+MAX_SIGNED_64BIT_INT = 9223372036854775807
 
 # We could try to save space by not storing the columns
 # `row_index` and `col_index`, and add them after loading from
@@ -20,7 +21,7 @@ UNCERTAINTY_DTYPE = [
     ("maximum", np.float32),
     ("negative", bool),
 ]
-INDICES_DTYPE = [("row", np.int32), ("col", np.int32)]
+INDICES_DTYPE = [("row", np.int64), ("col", np.int64)]
 
 NAME_RE = re.compile(r"^[\w\-\.]*$")
 

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/datapackage.py

@@ -1,8 +1,12 @@
 import datetime
 import uuid
+import warnings
 from abc import ABC
 from functools import partial
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+if TYPE_CHECKING:
+    from bw_processing.matrix_entry import MatrixEntry
 
 import numpy as np
 import pandas as pd
@@ -11,16 +15,18 @@ from fsspec import AbstractFileSystem
 # Use this instead of fsspec MemoryFileSystem because that is a singleton!?
 from morefs.dict import DictFS
 
-from .constants import (
+from bw_processing.constants import (
     DEFAULT_LICENSES,
     INDICES_DTYPE,
+    MAX_SIGNED_32BIT_INT,
+    MAX_SIGNED_64BIT_INT,
     NUMPY_SERIALIZE_FORMAT_EXTENSION,
     NUMPY_SERIALIZE_FORMAT_NAME,
     PARQUET_SERIALIZE_FORMAT_EXTENSION,
     PARQUET_SERIALIZE_FORMAT_NAME,
     MatrixSerializeFormat,
 )
-from .errors import (
+from bw_processing.errors import (
     Closed,
     InvalidMimetype,
     LengthMismatch,
@@ -29,10 +35,10 @@ from .errors import (
     ShapeMismatch,
     WrongDatatype,
 )
-from .filesystem import clean_datapackage_name
-from .io_helpers import file_reader, file_writer
-from .proxies import Proxy, UndefinedInterface
-from .utils import check_name, check_suffix, load_bytes, resolve_dict_iterator, utc_now
+from bw_processing.filesystem import clean_datapackage_name
+from bw_processing.io_helpers import file_reader, file_writer
+from bw_processing.proxies import Proxy, UndefinedInterface
+from bw_processing.utils import check_name, check_suffix, load_bytes, resolve_dict_iterator, utc_now
 
 
 class DatapackageBase(ABC):
@@ -257,6 +263,12 @@ class DatapackageBase(ABC):
 
         self.data[index] = resource
 
+    def get_max_index_value(self) -> int:
+        """Get maximum index value (max signed 32 or 64 bit integer) for this datapackage"""
+        if self.metadata.get("64_bit_indices"):
+            return MAX_SIGNED_64BIT_INT
+        return MAX_SIGNED_32BIT_INT
+
 
 class FilteredDatapackage(DatapackageBase):
     """A subset of a datapackage. Used in matrix construction or other data manipulation operations.
@@ -360,6 +372,7 @@ class Datapackage(DatapackageBase):
             "combinatorial": combinatorial,
             "sequential": sequential,
             "seed": seed,
+            "64_bit_indices": True,
             "sum_intra_duplicates": sum_intra_duplicates,
             "sum_inter_duplicates": sum_inter_duplicates,
             "matrix_serialize_format_type": matrix_serialize_format_type.value,
@@ -439,6 +452,30 @@ class Datapackage(DatapackageBase):
             **kwargs,
         )
 
+    def add_entries(
+        self,
+        *,
+        matrix: str,
+        entries: list["MatrixEntry"],
+        name: Optional[str] = None,
+    ) -> None:
+        """Add matrix data from a list of :class:`MatrixEntry` objects.
+
+        High-level convenience method that does not require working directly
+        with NumPy arrays.
+
+        Args:
+            matrix: Name of the target matrix (e.g. ``"technosphere"``).
+            entries: List of :class:`.MatrixEntry` instances.
+            name: Optional resource group name; auto-generated if omitted.
+        """
+        self.add_persistent_vector_from_iterator(
+            matrix=matrix,
+            name=name,
+            dict_iterator=(e.as_dict() for e in entries),
+            nrows=len(entries),
+        )
+
     def add_persistent_vector(
         self,
         *,  # Forces use of keyword arguments
@@ -1082,6 +1119,10 @@ def load_datapackage(
 def simple_graph(data: dict, fs: Optional[AbstractFileSystem] = None, **metadata) -> Datapackage:
     """Easy creation of simple datapackages with only persistent vectors.
 
+    .. deprecated::
+        Use :func:`bw_processing.matrix_entry.create_datapackage_from_entries` with
+        :class:`bw_processing.matrix_entry.MatrixEntry` objects instead.
+
     Args:
         * data: is a dictionary.
             The data dictionary has the form::
@@ -1102,6 +1143,11 @@ def simple_graph(data: dict, fs: Optional[AbstractFileSystem] = None, **metadata
         the datapackage.
 
     """
+    warnings.warn(
+        "simple_graph is deprecated; use create_datapackage_from_entries with MatrixEntry objects instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     dp = create_datapackage(fs=fs or DictFS(), **metadata)
     for key, value in data.items():
         indices_array = np.array([row[:2] for row in value], dtype=INDICES_DTYPE)

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/indexing.py

@@ -5,8 +5,8 @@ import numpy as np
 import pandas as pd
 from fsspec import AbstractFileSystem
 
-from .datapackage import Datapackage, load_datapackage
-from .errors import NonUnique
+from bw_processing.datapackage import Datapackage, load_datapackage
+from bw_processing.errors import NonUnique
 
 
 def _get_csv_data(

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/io_helpers.py

@@ -11,12 +11,12 @@ from fsspec.implementations.local import LocalFileSystem
 from fsspec.implementations.zip import ZipFileSystem
 from morefs.dict import DictFS
 
-from .constants import MatrixSerializeFormat
-from .errors import InvalidMimetype
-from .proxies import Proxy
+from bw_processing.constants import MatrixSerializeFormat
+from bw_processing.errors import InvalidMimetype
+from bw_processing.proxies import Proxy
 
 try:
-    from .io_parquet_helpers import load_ndarray_from_parquet, save_arr_to_parquet
+    from bw_processing.io_parquet_helpers import load_ndarray_from_parquet, save_arr_to_parquet
 
     PARQUET = True
 except ImportError:

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/io_parquet_helpers.py

@@ -13,8 +13,8 @@ import numpy
 import numpy as np
 import pyarrow.parquet as pq
 
-from .errors import WrongDatatype
-from .io_pyarrow_helpers import (
+from bw_processing.errors import WrongDatatype
+from bw_processing.io_pyarrow_helpers import (
     numpy_distributions_vector_to_pyarrow_distributions_vector_table,
     numpy_generic_matrix_to_pyarrow_generic_matrix_table,
     numpy_generic_vector_to_pyarrow_generic_vector_table,

bw_processing-1.1/src/bw_processing/matrix_entry.py

@@ -0,0 +1,112 @@
+import dataclasses
+import math
+from enum import Enum
+
+
+class MatrixName(str, Enum):
+    """Standard matrix names used in Brightway.
+
+    Because this is a ``str`` enum, members can be used anywhere a plain
+    string is accepted — no ``.value`` needed::
+
+        MatrixEntry(row=1, col=4, amount=2.5)  # inside a dict keyed by MatrixName
+        dp.add_entries(matrix=MatrixName.technosphere, entries=[...])
+
+    Derived libraries may define additional matrices as plain strings;
+    these three cover the core Brightway LCA workflow.
+    """
+
+    technosphere = "technosphere_matrix"
+    biosphere = "biosphere_matrix"
+    characterization = "characterization_matrix"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclasses.dataclass(frozen=True)
+class MatrixEntry:
+    """A single entry destined for a matrix cell.
+
+    Multiple instances with the same (row, col) are summed during matrix
+    construction, so this is not necessarily the final cell value.
+
+    Field names and defaults match those expected by bw_processing's
+    ``dictionary_formatter``. Convert to a plain dict with ``as_dict()``
+    before passing to bw_processing internals.
+
+    Args:
+        row: Integer row index in the target matrix.
+        col: Integer column index in the target matrix.
+        amount: The numeric value to place at (row, col).
+        flip: If True, multiply the value by -1 when building the matrix.
+        uncertainty_type: Probability distribution type (0 = no uncertainty,
+            2 = lognormal, 3 = normal, etc. — see stats_arrays for full list).
+        loc: Distribution location parameter. For lognormal this is the log
+            of the median; defaults to NaN (no uncertainty).
+        scale: Distribution scale parameter (e.g. standard deviation).
+        shape: Distribution shape parameter.
+        minimum: Lower bound for distribution sampling.
+        maximum: Upper bound for distribution sampling.
+        negative: Whether the underlying value is negative.
+    """
+
+    row: int
+    col: int
+    amount: float
+    flip: bool = False
+    uncertainty_type: int = 0
+    loc: float = math.nan
+    scale: float = math.nan
+    shape: float = math.nan
+    minimum: float = math.nan
+    maximum: float = math.nan
+    negative: bool = False
+
+    def as_dict(self) -> dict:
+        return dataclasses.asdict(self)
+
+
+def create_datapackage_from_entries(
+    data: dict,
+    fs=None,
+    **metadata,
+):
+    """Create a datapackage from a dictionary of :class:`MatrixEntry` lists.
+
+    This is the recommended high-level entry point for building datapackages
+    without working directly with NumPy arrays.
+
+    Args:
+        data: Dictionary mapping matrix names to lists of :class:`MatrixEntry`
+            objects. Use :class:`MatrixName` members as keys for the standard
+            Brightway matrices; derived libraries may use plain strings for
+            additional matrices::
+
+                {
+                    MatrixName.technosphere: [
+                        MatrixEntry(row=1, col=4, amount=2.5),
+                        MatrixEntry(row=2, col=5, amount=7.0, flip=True),
+                    ],
+                    MatrixName.biosphere: [
+                        MatrixEntry(row=10, col=4, amount=0.3),
+                    ],
+                }
+
+        fs: Optional filesystem. Defaults to an in-memory filesystem.
+        **metadata: Additional keyword arguments passed to
+            :func:`create_datapackage` (e.g. ``name``, ``id_``).
+
+    Returns:
+        A :class:`Datapackage` instance.
+    """
+    from bw_processing.datapackage import create_datapackage
+
+    dp = create_datapackage(fs=fs, **metadata)
+    for matrix_name, entries in data.items():
+        dp.add_entries(
+            matrix=matrix_name,
+            entries=entries,
+            name=f"{matrix_name}-data",
+        )
+    return dp

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/merging.py

@@ -7,9 +7,9 @@ import pandas as pd
 from fsspec import AbstractFileSystem
 from morefs.dict import DictFS
 
-from .datapackage import DatapackageBase, create_datapackage
-from .errors import LengthMismatch
-from .io_helpers import file_writer
+from bw_processing.datapackage import DatapackageBase, create_datapackage
+from bw_processing.errors import LengthMismatch
+from bw_processing.io_helpers import file_writer
 
 
 def mask_resource(obj: Any, mask: np.ndarray) -> Any:

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/unique_fields.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-from .errors import InconsistentFields, NonUnique
+from bw_processing.errors import InconsistentFields, NonUnique
 
 
 def greedy_set_cover(data, exclude=None, raise_error=True):

{bw_processing-0.9.6 → bw_processing-1.1/src}/bw_processing/utils.py

@@ -6,9 +6,9 @@ from typing import Any, Union
 import numpy as np
 from numpy.lib.recfunctions import repack_fields
 
-from .array_creation import create_structured_array
-from .constants import INDICES_DTYPE, NAME_RE, UNCERTAINTY_DTYPE
-from .errors import InvalidName
+from bw_processing.array_creation import create_structured_array
+from bw_processing.constants import INDICES_DTYPE, NAME_RE, UNCERTAINTY_DTYPE
+from bw_processing.errors import InvalidName
 
 
 def load_bytes(obj: Any) -> Any:

{bw_processing-0.9.6 → bw_processing-1.1/src/bw_processing.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: bw_processing
-Version: 0.9.6
+Version: 1.1
 Summary: Foo
 Author-email: Chris Mutel <cmutel@gmail.com>
 Maintainer-email: Chris Mutel <cmutel@gmail.com>
@@ -38,6 +38,7 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-randomly; extra == "dev"
 Requires-Dist: setuptools; extra == "dev"
+Dynamic: license-file
 
 # bw-processing
 
@@ -81,7 +82,7 @@ The [Brightway LCA framework](https://brightway.dev/) has stored data used in co
 * **Support for vector and array data**. Vector (i.e. only one possible value per input) and array (i.e. many possible values, also called presamples) data are now both natively supported in data packages.
 * **Portability**. Processed arrays can include metadata that allows for reindexing on other machines, so that processed arrays can be distributed and reused. Before, this was not possible, as integer IDs were randomly assigned on each computer, and would be different from machine to machine or even across Brightway projects.
 * **Dynamic data sources**. Instead of requiring that data for matrix construction be present and savedd on disk, it can now be generated dynamically, either through code running locally or on another computer system. This is a big step towards embeddding life cycle assessment in a web of environmental models.
-* **Use [PyFilesystem2](https://docs.pyfilesystem.org/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
+* **Use [fsspec](https://filesystem-spec.readthedocs.io/en/latest/) for file IO**. The use of this library allows for data packages to be stored on your local computer, or on [many logical or virtual file systems](https://docs.pyfilesystem.org/en/latest/guide.html).
 * **Simpler handling of numeric values whose sign should be flipped**. Sometimes it is more convenient to specify positive numbers in dataset definitions, even though such numbers should be negative when inserted into the resulting matrices. For example, in the technosphere matrix in life cycle assessment, products produced are positive and products consumed are negative, though both values are given as positive in datasets. Brightway used to use a type mapping dictionary to indicate which values in a matrix should have their sign flipped after insertion. Such mapping dictionaries are brittle and inelegant. `bw_processing` uses an optional boolean vector, called `flip`, to indicate if any values should be flipped.
 * **Separation of uncertainty distribution parameters from other data**. Fitting data to a [probability density function](https://en.wikipedia.org/wiki/Probability_density_function) (PDF), or an estimate of such a PDF, is only one approach to quantitative uncertainty analysis. We would like to support other approaches, including [direct sampling from real data](https://github.com/PascalLesage/presamples/). Therefore, uncertainty distribution parameters are stored separately,  only loaded if needed, and are only one way to express quantitative uncertainty.
 

bw_processing-1.1/src/bw_processing.egg-info/SOURCES.txt

@@ -0,0 +1,52 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/bw_processing/__init__.py
+src/bw_processing/array_creation.py
+src/bw_processing/constants.py
+src/bw_processing/datapackage.py
+src/bw_processing/errors.py
+src/bw_processing/filesystem.py
+src/bw_processing/indexing.py
+src/bw_processing/io_helpers.py
+src/bw_processing/io_parquet_helpers.py
+src/bw_processing/io_pyarrow_helpers.py
+src/bw_processing/matrix_entry.py
+src/bw_processing/merging.py
+src/bw_processing/proxies.py
+src/bw_processing/unique_fields.py
+src/bw_processing/utils.py
+src/bw_processing.egg-info/PKG-INFO
+src/bw_processing.egg-info/SOURCES.txt
+src/bw_processing.egg-info/dependency_links.txt
+src/bw_processing.egg-info/requires.txt
+src/bw_processing.egg-info/top_level.txt
+src/bw_processing/examples/__init__.py
+src/bw_processing/examples/datapackage_2.zip
+src/bw_processing/examples/interfaces.py
+src/bw_processing/examples/parquet_files.py
+src/bw_processing/examples/simple.zip
+src/bw_processing/examples/datapackage_1/another name.indices.parquet
+src/bw_processing/examples/datapackage_1/sa-data-vector-from-dict.data.parquet
+src/bw_processing/examples/datapackage_1/sa-data-vector-from-dict.distributions.parquet
+src/bw_processing/examples/datapackage_1/sa-data-vector-from-dict.flip.parquet
+src/bw_processing/examples/datapackage_1/sa-data-vector-from-dict.indices.parquet
+src/bw_processing/examples/datapackage_1/some name.data.parquet
+src/bw_processing/examples/datapackage_1/some name.flip.parquet
+src/bw_processing/examples/datapackage_1/some name.indices.parquet
+tests/test_array_creation.py
+tests/test_datapackage.py
+tests/test_filesystem.py
+tests/test_filtered_datapackage.py
+tests/test_indexing.py
+tests/test_integration.py
+tests/test_interfaces.py
+tests/test_io_parquet_helpers.py
+tests/test_io_pyarrow_helpers.py
+tests/test_loading.py
+tests/test_matrix_entry.py
+tests/test_merging.py
+tests/test_proxies.py
+tests/test_unique_fields.py
+tests/test_utils.py

bw_processing-1.1/tests/test_array_creation.py

@@ -0,0 +1,14 @@
+from bw_processing.array_creation import chunked
+
+
+def test_chunked():
+    c = chunked(range(600), 250)
+    for x in next(c):
+        pass
+    assert x == 249
+    for x in next(c):
+        pass
+    assert x == 499
+    for x in next(c):
+        pass
+    assert x == 599