ClimateGraph 0.4.0__tar.gz → 0.4.2__tar.gz

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/appkernel.py

@@ -129,6 +129,10 @@ class AppKernel:
     def _dask_client(self):
         """Yield a dask client, or ``None`` when no cluster was requested.
 
+        One thread per worker: libnetcdf is not thread-safe, so reads serialise
+        behind a global lock that is held per process. Threads therefore queue
+        on it while processes read in parallel.
+
         Yields
         ------
         dask.distributed.Client or None
@@ -138,9 +142,9 @@ class AppKernel:
             return
         from dask.distributed import Client, LocalCluster
 
-        cluster = LocalCluster(n_workers=1, threads_per_worker=self.workers)
+        cluster = LocalCluster(n_workers=self.workers, threads_per_worker=1)
         client = Client(cluster)
-        log.info(f"Dask Client started: 1 worker x {self.workers} threads.")
+        log.info(f"Dask Client started: {self.workers} workers x 1 thread.")
         try:
             yield client
         finally:

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/data/data.py

@@ -477,6 +477,11 @@ class Data(RegistryMixin, ABC):
             var_src = other.get_var(var)
             src_geom_dims = [d for d in var_src.dims if d in set(other.geom_dims)]
 
+            # apply_ufunc needs a core dim whole, and a NetCDF4 file's internal
+            # chunking splits the geometry dims when nothing names them.
+            if var_src.chunks:
+                var_src = var_src.chunk(dict.fromkeys(src_geom_dims, -1))
+
             resampled = xr.apply_ufunc(
                 _resample,
                 var_src,

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/plot/plots.py

@@ -737,17 +737,31 @@ class TimeCycleConfig(BasePlotConfig):
             return self
         # map both to hours for comparison
         bucket_hours = {
+            "minute": 1 / 60,
             "hour": 1,
             "day": 24,
+            "week": 168,
             "month": 720,
             "dayofyear": 24,
             "season": 2160,
+            "quarter": 2160,
         }
         timestep_hours = {
+            TimestepEnum.nanoseconds: 1 / 3.6e12,
+            TimestepEnum.microseconds: 1 / 3.6e9,
+            TimestepEnum.milliseconds: 1 / 3.6e6,
+            TimestepEnum.secondly: 1 / 3600,
+            TimestepEnum.minutely: 1 / 60,
             TimestepEnum.hourly: 1,
             TimestepEnum.daily: 24,
+            TimestepEnum.business_day: 24,
+            TimestepEnum.weekly: 168,
             TimestepEnum.monthly: 720,
-            # extend as needed
+            TimestepEnum.monthly_start: 720,
+            TimestepEnum.quarterly: 2160,
+            TimestepEnum.quarterly_start: 2160,
+            TimestepEnum.yearly: 8760,
+            TimestepEnum.yearly_start: 8760,
         }
         if timestep_hours[self.timestep] > bucket_hours[self.time_buckets.value]:
             raise ValueError(

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/reader/reader/reader.py

@@ -277,6 +277,12 @@ class Reader(ABC):
         return manage_path(spec.paths, sort=spec.load_mode == "unsafe")
 
     open_engine: str = "netcdf4"
+    # One chunk per file, every dim. Chunking runs before `_preprocess`, so dim
+    # names are still file-native here and a dim-keyed spec silently misses;
+    # a scalar sidesteps that. The alternative, deferring to a NetCDF4 file's
+    # internal layout, is often one timestep per chunk. Override per dataset
+    # with `chunks:` in the data block, keyed on the file's own dim names.
+    default_chunks: int | dict = -1
 
     @classmethod
     def _open_many(cls, paths: list[Path], spec: ReadSpec) -> xr.Dataset:
@@ -301,7 +307,7 @@ class Reader(ABC):
         engine = spec.engine or cls.open_engine
         return xr.open_mfdataset(
             paths,
-            chunks={"time": "auto"},
+            chunks=spec.extras.get("chunks", cls.default_chunks),
             engine=engine,
             parallel=engine != "netcdf4",
             preprocess=per_file,
@@ -311,7 +317,11 @@ class Reader(ABC):
     def _open_one(cls, path: Path, spec: ReadSpec) -> Any:
         """Open a single file (unsafe path)."""
         engine = spec.engine or cls.open_engine
-        return xr.open_dataset(path, chunks={"time": "auto"}, engine=engine)
+        return xr.open_dataset(
+            path,
+            chunks=spec.extras.get("chunks", cls.default_chunks),
+            engine=engine,
+        )
 
     @classmethod
     def _to_xarray(cls, raw: Any, spec: ReadSpec) -> xr.Dataset:

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/utils/dataset_utils.py

@@ -243,7 +243,8 @@ def time_resampling(
         ds = ds.sel({"time": slice(start, end)})
         _record(ds, f"selected time interval {start} to {end}")
     if timestep is not None:
-        ds = getattr(ds.resample(time=timestep), reduction_method.value)()
+        freq = getattr(timestep, "value", timestep)
+        ds = getattr(ds.resample(time=freq), reduction_method.value)()
         _record(ds, f"resampled time to {timestep} ({reduction_method.value})")
     return ds
 

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph/utils/general_utils.py

@@ -29,8 +29,13 @@ class TimestepEnum(str, Enum):
     daily = "D"
     weekly = "W"
     monthly = "ME"
-    quarterly = "Q"
-    yearly = "Y"
+    # Period-end spellings: pandas 2.2 deprecated "Q"/"Y" and 3.0 removed them.
+    quarterly = "QE"
+    yearly = "YE"
+    # Period-start spellings: label each bucket with its first instant.
+    monthly_start = "MS"
+    quarterly_start = "QS"
+    yearly_start = "YS"
     hourly = "h"
     minutely = "min"
     secondly = "s"

{climategraph-0.4.0 → climategraph-0.4.2}/ClimateGraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ClimateGraph
-Version: 0.4.0
+Version: 0.4.2
 Summary: A CLI tool for graphing Climate Data
 Author-email: Antonio Andrés Torga Mellado <antonio.torga@ug.uchile.cl>
 License-Expression: MIT

{climategraph-0.4.0 → climategraph-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ClimateGraph
-Version: 0.4.0
+Version: 0.4.2
 Summary: A CLI tool for graphing Climate Data
 Author-email: Antonio Andrés Torga Mellado <antonio.torga@ug.uchile.cl>
 License-Expression: MIT

{climategraph-0.4.0 → climategraph-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name= "ClimateGraph"
-version = "0.4.0"
+version = "0.4.2"
 description = "A CLI tool for graphing Climate Data"
 readme = "README.md"
 license = "MIT"

{climategraph-0.4.0 → climategraph-0.4.2}/tests/test_appkernel.py

@@ -102,3 +102,44 @@ class TestDebugOverride:
         kernel = AppKernel()
         kernel.run(tmp_path / "ignored.yaml", debug_override=False)
         assert kernel.debug is False
+
+
+class TestDaskClient:
+    """``workers`` must buy worker processes, not threads.
+
+    libnetcdf is not thread-safe, so xarray serialises reads behind a lock held
+    per process. Threads queue on it and measure slower than no cluster at all;
+    processes each hold their own and read in parallel.
+    """
+
+    @pytest.fixture
+    def captured_cluster(self, monkeypatch):
+        captured = {}
+
+        class _FakeCluster:
+            def __init__(self, **kwargs):
+                captured.update(kwargs)
+
+            def close(self):
+                pass
+
+        import dask.distributed
+
+        monkeypatch.setattr(dask.distributed, "LocalCluster", _FakeCluster)
+        monkeypatch.setattr(dask.distributed, "Client", lambda cluster: MagicMock())
+        return captured
+
+    def test_workers_become_processes(self, captured_cluster):
+        kernel = AppKernel()
+        kernel.workers = 8
+        with kernel._dask_client() as client:
+            assert client is not None
+        assert captured_cluster["n_workers"] == 8
+        assert captured_cluster["threads_per_worker"] == 1
+
+    def test_no_workers_means_no_cluster(self, captured_cluster):
+        kernel = AppKernel()
+        kernel.workers = None
+        with kernel._dask_client() as client:
+            assert client is None
+        assert captured_cluster == {}