From 35f92d79626b1040e5d2b5492c40124574db86bc Mon Sep 17 00:00:00 2001 From: Zach Burnett Date: Mon, 5 Aug 2024 10:17:08 -0400 Subject: [PATCH 1/3] replace usages of ``pkg_resources`` with ``importlib.metadata`` (#941) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * replace usages of ``pkg_resources`` with ``importlib.metadata`` add change log entry * update pint version * clean up _helpers.py * use select syntax for entry point * add py39 dict syntax * catch empty case * rebuild environment * update docs dependencies and env file --------- Co-authored-by: Çağtay Fabry --- .github/workflows/docs.yml | 2 +- .ruff.toml | 2 +- CHANGELOG.md | 3 +++ doc/rtd_environment.yml | 4 ++-- pyproject.toml | 12 +++++++++++- weldx/config.py | 11 +++++++++-- weldx/constants.py | 1 - weldx/tests/_helpers.py | 3 +-- weldx/tests/transformations/_util.py | 5 +---- 9 files changed, 29 insertions(+), 14 deletions(-) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index aed853505..156c4e416 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -54,7 +54,7 @@ jobs: init-shell: >- bash powershell - cache-environment: true + cache-environment: false - name: activate build env run: micromamba activate rtd diff --git a/.ruff.toml b/.ruff.toml index f6d0285ea..1979526df 100644 --- a/.ruff.toml +++ b/.ruff.toml @@ -77,5 +77,5 @@ required-imports = [ "from __future__ import annotations", ] -[flake8-import-conventions] +[lint.flake8-import-conventions] extend-aliases = { xarray = "xr" } diff --git a/CHANGELOG.md b/CHANGELOG.md index fc81211b7..eae44edb2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,9 +6,12 @@ - rename (fix typo) argument to `lcs_child_in_parent` in `CoordinateSystemManager.add_cs` \[{pull}`936`\]. +- replace usages of `pkg_resources` with `importlib.metadata` \[{pull}`941`\]. + ### Dependencies - pin `weldx-widgets>=0.2.3` for viz \[{pull}`939`\]. +- pin `pint>=0.21` \[{pull}`941`\]. ## 0.6.8 (07.06.2024) diff --git a/doc/rtd_environment.yml b/doc/rtd_environment.yml index 9c6638dc8..a7f689520 100644 --- a/doc/rtd_environment.yml +++ b/doc/rtd_environment.yml @@ -32,5 +32,5 @@ dependencies: # pip packages - pip - pip: - - ../ - - ./json_mime_render_plugin/ + - weldx @ file:/../..// + - json_mime_render_plugin @ file:/..//json_mime_render_plugin diff --git a/pyproject.toml b/pyproject.toml index c78d5081b..4fd4335f2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -51,13 +51,23 @@ dependencies = [ "networkx>=2.8.2", "numpy>=1.20,<2", "pandas>=1.5", - "pint>=0.18", + "pint>=0.21", "pint-xarray>=0.3", "psutil", "scipy>=1.6.2", "sympy>=1.6", "xarray>=2022.9", ] +optional-dependencies.docs = [ + "docutils>=0.19", + "numpydoc>=0.5", + "pydata-sphinx-theme<0.15", # parallel-write-unsafe + "sphinx>=4.1.1,==7.2", + "sphinx-autodoc-typehints>=1.21.8,==2", + "sphinx-copybutton==0.5", + "typing-extensions", + "urllib3<2", +] optional-dependencies.media = [ "av", "dask-image", diff --git a/weldx/config.py b/weldx/config.py index 9033225a5..b2a465fb0 100644 --- a/weldx/config.py +++ b/weldx/config.py @@ -2,10 +2,11 @@ from __future__ import annotations +import importlib.metadata +import sys from pathlib import Path import asdf -import pkg_resources import yaml from asdf.config import ResourceMappingProxy from asdf.versioning import AsdfVersion, split_tag_version @@ -175,7 +176,13 @@ def enable_quality_standard(name: str, version: AsdfVersion | str = None): @staticmethod def load_installed_standards(): """Load all standards that are installed to the active virtual environment.""" - for entry_point in pkg_resources.iter_entry_points("weldx.standard"): + if sys.version_info < (3, 10): + entry_points = importlib.metadata.entry_points().get("weldx.standard", []) + else: + entry_points = importlib.metadata.entry_points().select( + group="weldx.standard" + ) + for entry_point in entry_points: standards = entry_point.load()() if not isinstance(standards, list): standards = [standards] diff --git a/weldx/constants.py b/weldx/constants.py index 1fe816d2c..fedb49a1f 100644 --- a/weldx/constants.py +++ b/weldx/constants.py @@ -16,7 +16,6 @@ WELDX_UNIT_REGISTRY = pint.UnitRegistry( preprocessors=[ - lambda string: string.replace("%", "percent"), # allow %-sign lambda string: string.replace("Δ°", "delta_deg"), # parse Δ° for temperature ], force_ndarray_like=True, diff --git a/weldx/tests/_helpers.py b/weldx/tests/_helpers.py index d63e25111..e4bc8b80c 100644 --- a/weldx/tests/_helpers.py +++ b/weldx/tests/_helpers.py @@ -4,7 +4,6 @@ import numpy as np import pint -from pkg_resources import get_distribution from weldx.constants import Q_ from weldx.geometry import _vector_is_close as vector_is_close @@ -130,7 +129,7 @@ def matrix_is_close(mat_a, mat_b, abs_tol=1e-9) -> bool: return False atol_unit = 1.0 - if isinstance(mat_b, pint.Quantity) and get_distribution("pint").version >= "0.21": + if isinstance(mat_b, pint.Quantity): atol_unit = mat_b.u return np.all(np.isclose(mat_a, mat_b, atol=abs_tol * atol_unit)).__bool__() diff --git a/weldx/tests/transformations/_util.py b/weldx/tests/transformations/_util.py index 86f99a239..904a456f7 100644 --- a/weldx/tests/transformations/_util.py +++ b/weldx/tests/transformations/_util.py @@ -3,7 +3,6 @@ from typing import Any import numpy as np -from pkg_resources import get_distribution from xarray import DataArray import weldx.transformations as tf @@ -78,9 +77,7 @@ def check_coordinate_system( lcs.orientation, orientation_expected, positive_orientation_expected ) - atol_unit = 1.0 - if get_distribution("pint").version >= "0.21": - atol_unit = coordinates_expected.u + atol_unit = coordinates_expected.u assert np.allclose( lcs.coordinates.data, coordinates_expected, atol=1e-9 * atol_unit From 336c835e7e03006ff1ee8fa3fab408cee1bd5d2d Mon Sep 17 00:00:00 2001 From: Zach Burnett Date: Mon, 5 Aug 2024 11:03:24 -0400 Subject: [PATCH 2/3] replace usages of ``copy_arrays`` with ``memmap`` for ``asdf>=3.1.0`` (#940) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * replace usages of ``copy_arrays`` with ``memmap`` for ``asdf>=3.1.0`` * `pre-commit run -a` * compare strings * Update CHANGELOG.md --------- Co-authored-by: Çağtay Fabry --- CHANGELOG.md | 2 +- weldx/asdf/file.py | 28 +++++-- weldx/asdf/util.py | 17 ++-- weldx/tests/asdf_tests/test_asdf_core.py | 84 +++++++++---------- .../tests/asdf_tests/test_asdf_measurement.py | 6 +- 5 files changed, 77 insertions(+), 60 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index eae44edb2..b7beeed13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,8 +5,8 @@ ### Fixes - rename (fix typo) argument to `lcs_child_in_parent` in `CoordinateSystemManager.add_cs` \[{pull}`936`\]. - - replace usages of `pkg_resources` with `importlib.metadata` \[{pull}`941`\]. +- replace usages of `copy_arrays` with `memmap` for `asdf>=3.1.0` \[{pull}`940`\]. ### Dependencies diff --git a/weldx/asdf/file.py b/weldx/asdf/file.py index f75ec0583..decc873ac 100644 --- a/weldx/asdf/file.py +++ b/weldx/asdf/file.py @@ -3,6 +3,7 @@ from __future__ import annotations import copy +import importlib.metadata import io import pathlib import warnings @@ -42,12 +43,23 @@ __all__ = [ "WeldxFile", "DEFAULT_ARRAY_COMPRESSION", - "DEFAULT_ARRAY_COPYING", + "DEFAULT_MEMORY_MAPPING", "DEFAULT_ARRAY_INLINE_THRESHOLD", "_PROTECTED_KEYS", ] +def asdf_open_memory_mapping_kwarg(memmap: bool) -> dict: + if tuple(importlib.metadata.version("asdf").split(".")) >= ( + "3", + "1", + "0", + ): + return {"memmap": memmap} + else: + return {"copy_arrays": not memmap} + + @contextmanager def reset_file_position(fh: SupportsFileReadWrite): """Reset the internal position of the given file after leaving the context. @@ -66,8 +78,8 @@ def reset_file_position(fh: SupportsFileReadWrite): DEFAULT_ARRAY_COMPRESSION = "input" """All arrays will be compressed using this algorithm, if not specified by user.""" -DEFAULT_ARRAY_COPYING = True -"""Stored Arrays will be copied to memory, or not. If False, use memory mapping.""" +DEFAULT_MEMORY_MAPPING = False +"""Stored Arrays will be memory-mapped, or not. If True, use memory mapping.""" DEFAULT_ARRAY_INLINE_THRESHOLD = 10 """Arrays with less or equal elements will be inlined (stored as string, not binary).""" @@ -148,8 +160,8 @@ class WeldxFile(_ProtectedViewDict): - ``lz4``: Use lz4 compression. - ``input``: Use the same compression as in the file read. If there is no prior file, acts as None. - copy_arrays : - When `False`, when reading files, attempt to memory map (memmap) underlying data + memmap : + When `True`, when reading files, attempt to memory map (memmap) underlying data arrays when possible. This avoids blowing the memory when working with very large datasets. array_inline_threshold : @@ -219,19 +231,19 @@ def __init__( ) = None, software_history_entry: Mapping = None, compression: str = DEFAULT_ARRAY_COMPRESSION, - copy_arrays: bool = DEFAULT_ARRAY_COPYING, + memmap: bool = DEFAULT_MEMORY_MAPPING, array_inline_threshold: int = DEFAULT_ARRAY_INLINE_THRESHOLD, ): if write_kwargs is None: write_kwargs = dict(all_array_compression=compression) if asdffile_kwargs is None: - asdffile_kwargs = dict(copy_arrays=copy_arrays) + asdffile_kwargs = asdf_open_memory_mapping_kwarg(memmap=memmap) # this parameter is now (asdf-2.8) a asdf.config parameter, so we store it here. self._array_inline_threshold = array_inline_threshold - # TODO: ensure no mismatching args for compression and copy_arrays. + # TODO: ensure no mismatching args for compression and memmap. self._write_kwargs = write_kwargs self._asdffile_kwargs = asdffile_kwargs diff --git a/weldx/asdf/util.py b/weldx/asdf/util.py index 5f30d8d9b..9da1d5412 100644 --- a/weldx/asdf/util.py +++ b/weldx/asdf/util.py @@ -2,6 +2,7 @@ from __future__ import annotations +import importlib.metadata from collections.abc import Callable, Hashable, Mapping, MutableMapping, Set from contextlib import contextmanager from io import BytesIO, TextIOBase @@ -149,7 +150,7 @@ def read_buffer_context( Buffer containing ASDF file contents open_kwargs Additional keywords to pass to `asdf.AsdfFile.open` - Extensions are always set, ``copy_arrays=True`` is set by default. + Extensions are always set, ``memmap=False`` is set by default. Returns ------- @@ -158,7 +159,13 @@ def read_buffer_context( """ if open_kwargs is None: - open_kwargs = {"copy_arrays": True, "lazy_load": False} + open_kwargs = {"memmap": False, "lazy_load": False} + + if "memmap" in open_kwargs and tuple( + importlib.metadata.version("asdf").split(".") + ) < ("3", "1", "0"): + open_kwargs["copy_arrays"] = not open_kwargs["memmap"] + del open_kwargs["memmap"] buffer.seek(0) @@ -190,7 +197,7 @@ def read_buffer( Buffer containing ASDF file contents open_kwargs Additional keywords to pass to `asdf.AsdfFile.open` - Extensions are always set, ``copy_arrays=True`` is set by default. + Extensions are always set, ``memmap=False`` is set by default. Returns ------- @@ -220,7 +227,7 @@ def write_read_buffer_context( Extensions are always set. open_kwargs Additional keywords to pass to `asdf.AsdfFile.open` - Extensions are always set, ``copy_arrays=True`` is set by default. + Extensions are always set, ``memmap=False`` is set by default. Returns ------- @@ -248,7 +255,7 @@ def write_read_buffer( Extensions are always set. open_kwargs Additional keywords to pass to `asdf.AsdfFile.open` - Extensions are always set, ``copy_arrays=True`` is set by default. + Extensions are always set, ``memmap=False`` is set by default. Returns ------- diff --git a/weldx/tests/asdf_tests/test_asdf_core.py b/weldx/tests/asdf_tests/test_asdf_core.py index b2a07fd63..863b1204b 100644 --- a/weldx/tests/asdf_tests/test_asdf_core.py +++ b/weldx/tests/asdf_tests/test_asdf_core.py @@ -121,15 +121,15 @@ def get_xarray_example_data_array(): return dax -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("select", [{}, {"d4": "z"}]) -def test_xarray_data_array(copy_arrays, lazy_load, select): +def test_xarray_data_array(memmap, lazy_load, select): """Test ASDF read/write of xarray.DataArray.""" dax = get_xarray_example_data_array().sel(**select) tree = {"dax": dax} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: dax_file = data["dax"] assert dax.identical(dax_file) @@ -172,13 +172,13 @@ def get_xarray_example_dataset(): return dsx -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) -def test_xarray_dataset(copy_arrays, lazy_load): +def test_xarray_dataset(memmap, lazy_load): dsx = get_xarray_example_dataset() tree = {"dsx": dsx} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: dsx_file = data["dsx"] assert dsx.identical(dsx_file) @@ -228,25 +228,25 @@ def get_local_coordinate_system(time_dep_orientation: bool, time_dep_coordinates @pytest.mark.parametrize("time_dep_orientation", [False, True]) @pytest.mark.parametrize("time_dep_coordinates", [False, True]) -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) def test_local_coordinate_system( - time_dep_orientation, time_dep_coordinates, copy_arrays, lazy_load + time_dep_orientation, time_dep_coordinates, memmap, lazy_load ): """Test (de)serialization of LocalCoordinateSystem in ASDF.""" lcs = get_local_coordinate_system(time_dep_orientation, time_dep_coordinates) with write_read_buffer_context( - {"lcs": lcs}, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + {"lcs": lcs}, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: assert data["lcs"] == lcs -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("has_ref_time", [True, False]) @pytest.mark.parametrize("has_tdp_orientation", [True, False]) def test_local_coordinate_system_coords_timeseries( - copy_arrays, lazy_load, has_ref_time, has_tdp_orientation + memmap, lazy_load, has_ref_time, has_tdp_orientation ): """Test reading and writing a LCS with a `TimeSeries` as coordinates to asdf.""" # create inputs to lcs __init__ @@ -270,7 +270,7 @@ def test_local_coordinate_system_coords_timeseries( # round trip and compare with write_read_buffer_context( - {"lcs": lcs}, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + {"lcs": lcs}, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: lcs_buffer = data["lcs"] assert lcs_buffer == lcs @@ -337,13 +337,13 @@ def get_example_coordinate_system_manager(): return csm -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) -def test_coordinate_system_manager(copy_arrays, lazy_load): +def test_coordinate_system_manager(memmap, lazy_load): csm = get_example_coordinate_system_manager() tree = {"cs_hierarchy": csm} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: csm_file = data["cs_hierarchy"] assert csm == csm_file @@ -400,25 +400,23 @@ def get_coordinate_system_manager_with_subsystems(nested: bool): return csm_global -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("nested", [True, False]) -def test_coordinate_system_manager_with_subsystems(copy_arrays, lazy_load, nested): +def test_coordinate_system_manager_with_subsystems(memmap, lazy_load, nested): csm = get_coordinate_system_manager_with_subsystems(nested) tree = {"cs_hierarchy": csm} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: csm_file = data["cs_hierarchy"] assert csm == csm_file -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("csm_time_ref", [None, "2000-03-16"]) -def test_coordinate_system_manager_time_dependencies( - copy_arrays, lazy_load, csm_time_ref -): +def test_coordinate_system_manager_time_dependencies(memmap, lazy_load, csm_time_ref): """Test serialization of time components from CSM and its attached LCS.""" lcs_tdp_1_time_ref = None if csm_time_ref is None: @@ -449,15 +447,15 @@ def test_coordinate_system_manager_time_dependencies( tree = {"cs_hierarchy": csm_root} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: csm_file = data["cs_hierarchy"] assert csm_root == csm_file -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) -def test_coordinate_system_manager_with_data(copy_arrays, lazy_load): +def test_coordinate_system_manager_with_data(memmap, lazy_load): """Test if data attached to a CSM is stored and read correctly.""" csm = tf.CoordinateSystemManager("root", "csm") csm.create_cs("cs_1", "root", coordinates=Q_([1, 1, 1], "mm")) @@ -483,7 +481,7 @@ def test_coordinate_system_manager_with_data(copy_arrays, lazy_load): tree = {"csm": csm} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as buffer: csm_buffer = buffer["csm"] @@ -498,7 +496,7 @@ def test_coordinate_system_manager_with_data(copy_arrays, lazy_load): # -------------------------------------------------------------------------------------- -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize( "ts", @@ -518,9 +516,9 @@ def test_coordinate_system_manager_with_data(copy_arrays, lazy_load): ), ], ) -def test_time_series(ts, copy_arrays, lazy_load): +def test_time_series(ts, memmap, lazy_load): with write_read_buffer_context( - {"ts": ts}, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + {"ts": ts}, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: ts_file = data["ts"] if isinstance(ts.data, ME): @@ -536,7 +534,7 @@ def test_time_series(ts, copy_arrays, lazy_load): # -------------------------------------------------------------------------------------- -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize( "coords, interpolation", @@ -546,21 +544,21 @@ def test_time_series(ts, copy_arrays, lazy_load): (dict(time=Q_([1, 2, 3], "s"), space=Q_([4, 5, 6, 7], "m")), "step"), ], ) -def test_generic_series_discrete(coords, interpolation, copy_arrays, lazy_load): +def test_generic_series_discrete(coords, interpolation, memmap, lazy_load): shape = tuple(len(v) for v in coords.values()) data = Q_(np.ones(shape), "m") gs = GenericSeries(data, coords=coords, interpolation=interpolation) with write_read_buffer_context( - {"gs": gs}, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + {"gs": gs}, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: gs_file = data["gs"] assert gs == gs_file -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize( "expr, params, units, dims", @@ -581,11 +579,11 @@ def test_generic_series_discrete(coords, interpolation, copy_arrays, lazy_load): ), ], ) -def test_generic_series_expression(expr, params, units, dims, copy_arrays, lazy_load): +def test_generic_series_expression(expr, params, units, dims, memmap, lazy_load): gs = GenericSeries(expr, parameters=params, units=units, dims=dims) with write_read_buffer_context( - {"gs": gs}, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + {"gs": gs}, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: gs_file = data["gs"] @@ -746,16 +744,16 @@ def test_hashing(algorithm: str, buffer_size: int): # test_asdf_serialization ---------------------------------------------------------- @staticmethod - @pytest.mark.parametrize("copy_arrays", [True, False]) + @pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("store_content", [True, False]) - def test_asdf_serialization(copy_arrays, lazy_load, store_content): + def test_asdf_serialization(memmap, lazy_load, store_content): """Test the asdf serialization of the `ExternalFile` class. Parameters ---------- - copy_arrays : bool - If `False`, arrays are accessed via memory mapping whenever possible while + memmap : bool + If `True`, arrays are accessed via memory mapping whenever possible while reading them. lazy_load : bool If `True`, items from the asdf file are not loaded until accessed. @@ -769,7 +767,7 @@ def test_asdf_serialization(copy_arrays, lazy_load, store_content): ) tree = {"file": ef} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: ef_file = data["file"] @@ -801,10 +799,10 @@ def test_asdf_serialization(copy_arrays, lazy_load, store_content): class TestPointCloud: @staticmethod - @pytest.mark.parametrize("copy_arrays", [True, False]) + @pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize("reshape", [True, False]) - def test_asdf_serialization(copy_arrays, lazy_load, reshape): + def test_asdf_serialization(memmap, lazy_load, reshape): time = None coordinates = [ [0.0, 0.0, 0.0], @@ -822,7 +820,7 @@ def test_asdf_serialization(copy_arrays, lazy_load, reshape): pc = SpatialData(coordinates=coordinates, triangles=triangles, time=time) tree = {"point_cloud": pc} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: pc_file = data["point_cloud"] diff --git a/weldx/tests/asdf_tests/test_asdf_measurement.py b/weldx/tests/asdf_tests/test_asdf_measurement.py index abea5ae4b..bc8239fbf 100644 --- a/weldx/tests/asdf_tests/test_asdf_measurement.py +++ b/weldx/tests/asdf_tests/test_asdf_measurement.py @@ -80,17 +80,17 @@ def measurement_chain_with_equipment() -> MeasurementChain: return mc -@pytest.mark.parametrize("copy_arrays", [True, False]) +@pytest.mark.parametrize("memmap", [True, False]) @pytest.mark.parametrize("lazy_load", [True, False]) @pytest.mark.parametrize( "measurement_chain", [measurement_chain_without_equipment(), measurement_chain_with_equipment()], ) -def test_measurement_chain(copy_arrays, lazy_load, measurement_chain): +def test_measurement_chain(memmap, lazy_load, measurement_chain): """Test the asdf serialization of the measurement chain.""" tree = {"m_chain": measurement_chain} with write_read_buffer_context( - tree, open_kwargs={"copy_arrays": copy_arrays, "lazy_load": lazy_load} + tree, open_kwargs={"memmap": memmap, "lazy_load": lazy_load} ) as data: mc_file = data["m_chain"] assert measurement_chain == mc_file From beacb2e9a6e5748c99a503d8dc32013592cb413f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 23:48:46 +0200 Subject: [PATCH 3/3] [pre-commit.ci] pre-commit autoupdate (#937) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit updates: - [github.com/astral-sh/ruff-pre-commit: v0.4.7 → v0.5.6](https://github.com/astral-sh/ruff-pre-commit/compare/v0.4.7...v0.5.6) - [github.com/tox-dev/pyproject-fmt: 2.1.3 → 2.2.1](https://github.com/tox-dev/pyproject-fmt/compare/2.1.3...2.2.1) - [github.com/nbQA-dev/nbQA: 1.8.5 → 1.8.7](https://github.com/nbQA-dev/nbQA/compare/1.8.5...1.8.7) Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- .pre-commit-config.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 596b0a343..b646b9c71 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -29,7 +29,7 @@ repos: - mdformat-config # ----- Python formatting ----- - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.4.7 + rev: v0.5.6 hooks: # Run ruff linter. - id: ruff @@ -39,7 +39,7 @@ repos: # Run ruff formatter. - id: ruff-format - repo: https://github.com/tox-dev/pyproject-fmt - rev: 2.1.3 + rev: 2.2.1 hooks: - id: pyproject-fmt - repo: https://github.com/abravalheri/validate-pyproject @@ -48,7 +48,7 @@ repos: - id: validate-pyproject # ----- Jupyter Notebooks ----- - repo: https://github.com/nbQA-dev/nbQA - rev: 1.8.5 + rev: 1.8.7 hooks: - id: nbqa-black - id: nbqa-ruff # ruff handles isort