mxalign 0.1.0__py3-none-any.whl

mxalign/transformations/base.py

@@ -0,0 +1,38 @@
+from .registry import register_transformation
+
+
+@register_transformation("rename")
+def transform_rename(ds, rename_dict):
+    new_dict = {}
+    for new_name, old_names in rename_dict.items():
+        for name in ds.keys():
+            if name in old_names:
+                new_dict[name] = new_name
+            else:
+                pass
+    return ds.rename(new_dict)
+
+
+@register_transformation("kelvin_to_celcius")
+def transform_kelvin_to_celcius(ds, variables, inverse=False):
+    T_C2K = 273.15
+    if isinstance(variables, str):
+        variables = [variables]
+    if inverse:
+        t = T_C2K
+    else:
+        t = -T_C2K
+
+    for var in variables:
+        ds[var] = ds[var] + t
+
+    return ds
+
+
+@register_transformation("uv_to_speed")
+def transform(ds, u, v, speed):
+    import numpy as np
+
+    result = np.sqrt(ds[u] ** 2 + ds[v] ** 2)
+    ds[speed] = result
+    return ds

mxalign/transformations/external.py

@@ -0,0 +1,34 @@
+from .registry import register_transformation
+
+
+@register_transformation("external")
+def transform(ds, func_path, inputs, output, **kwargs):
+    func = _resolve_function(func_path)
+
+    input_kwargs = {arg_name: ds[var_name] for arg_name, var_name in inputs.items()}
+
+    all_kwargs = {**input_kwargs, **kwargs}
+    result = func(**all_kwargs)
+    # print(result)
+    ds[output] = (ds.dims, result)
+    return ds
+
+
+def _resolve_function(func_path):
+    import importlib
+
+    module_path, func_name = func_path.rsplit(".", 1)
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as e:
+        raise ImportError(
+            f"Could not import module '{module_path}' required for transform '{func_path}'. "
+            f"Make sure it is installed. Original error: {e}"
+        )
+    try:
+        return getattr(module, func_name)
+    except AttributeError:
+        raise AttributeError(
+            f"Module '{module_path}' has no function '{func_name}'. "
+            f"Check the function name in your config."
+        )

mxalign/transformations/registry.py

@@ -0,0 +1,20 @@
+_TRANSFORMATION_REGISTRY = {}
+
+
+def register_transformation(name):
+    def decorator(func):
+        _TRANSFORMATION_REGISTRY[name] = func
+        return func
+
+    return decorator
+
+
+def available_transformations():
+    return list(_TRANSFORMATION_REGISTRY.keys())
+
+
+def get_transformation(name):
+    try:
+        return _TRANSFORMATION_REGISTRY[name]
+    except KeyError:
+        raise ValueError(f"Unknown transformation: {name}")

mxalign/transformations/transform.py

@@ -0,0 +1,28 @@
+from .registry import get_transformation
+
+
+def transform(name, datasets, *args, **kwargs):
+    transform = get_transformation(name)
+    if isinstance(datasets, dict):
+        keys = list(datasets.keys())
+        datasets = list(datasets.values())
+    else:
+        if not isinstance(datasets, list):
+            datasets = [datasets]
+        keys = None
+
+    if keys:
+        transformed_datasets = dict()
+        for key, ds in zip(keys, datasets):
+            transformed_datasets[key] = transform(ds.copy(), *args, **kwargs)
+    else:
+        transformed_datasets = []
+        for ds in datasets:
+            transformed_datasets.append(transform(ds.copy(), *args, **kwargs))
+
+    transformed_datasets = (
+        transformed_datasets[0]
+        if len(transformed_datasets) == 1
+        else transformed_datasets
+    )
+    return transformed_datasets

mxalign/utils/config.py

@@ -0,0 +1,55 @@
+import yaml
+
+from .dates import Dates
+
+
+def load_yaml(fn: str) -> dict:
+    with open(fn, "r") as f:
+        return yaml.safe_load(f)
+
+
+class Config:
+    def __init__(self, config: str | dict):
+        self.config = load_yaml(config) if isinstance(config, str) else config
+        if not isinstance(self.config, dict):
+            raise TypeError("config should be a dictionary.")
+        self.dates = self.config.pop("dates", None)
+        self._init_datasets()
+        print("Config initialized")
+
+    def __getitem__(self, key):
+        config = self.config.get(key, None)
+        if config:
+            return config.copy()
+        else:
+            return config
+
+    def __call__(self):
+        return self.config
+
+    def _init_datasets(self):
+        for key, loader in self.config["datasets"].items():
+            dates_loader = loader.pop("dates", None)
+            if self.dates:
+                if dates_loader:
+                    keys_all = list(set(self.dates.keys()).union(dates_loader.keys()))
+                    dates = {
+                        key: (
+                            dates_loader[key]
+                            if key in dates_loader.keys()
+                            else self.dates[key]
+                        )
+                        for key in keys_all
+                    }
+                else:
+                    dates = self.dates.copy()
+            else:
+                if dates_loader:
+                    dates = dates_loader.copy()
+                else:
+                    dates = None
+
+            if dates:
+                dates = Dates(**dates)
+                loader["files"] = dates.substitute(loader["files"])
+            self.config["datasets"][key] = loader

mxalign/utils/dates.py

@@ -0,0 +1,76 @@
+import numpy as np
+from earthkit.data.utils.patterns import Pattern
+
+
+class Dates:
+    def __init__(
+        self,
+        start: str | np.datetime64,
+        end: str | np.datetime64,
+        period: str | np.timedelta64,
+        range: str | np.timedelta64,
+        step: str | np.timedelta64,
+    ):
+        self._start = (
+            np.datetime64(start) if not isinstance(start, np.datetime64) else start
+        )
+        self._end = np.datetime64(end) if not isinstance(end, np.datetime64) else end
+        self._period = to_timedelta64(period) if isinstance(period, str) else period
+        self._range = to_timedelta64(range) if isinstance(range, str) else range
+        self._step = to_timedelta64(step) if isinstance(step, str) else step
+        valid_times = set()
+        lead_times = set()
+        reference_times = set()
+        date = self._start
+        while date <= self._end:
+            # print(date)
+            reference_times.add(date)
+            delta = np.timedelta64(0, "s")
+            while delta <= self._range:
+                valid_times.add(date + delta)
+                lead_times.add(delta)
+                delta += self._step
+            date += self._period
+        self.valid_times = list(valid_times)
+        self.reference_times = list(reference_times)
+        # FIXME: can we simplify this? earthkit.data.utils.patterns.Pattern does not accept np.int64
+        self.lead_times = sorted([int(t.astype(int)) for t in lead_times])
+
+    def substitute(self, path: str):
+        pattern = Pattern(path)
+        paths = pattern.substitute(
+            dict(reference_time=self.reference_times),
+            # dict(lead_time=self.lead_times),
+            # dict(valid_time=self.valid_times),
+            allow_extra=True,
+        )
+        return sorted(paths)
+
+
+def to_timedelta64(freq: str) -> np.timedelta64:
+    """
+    Convert a frequency string to a numpy timedelta64 object.
+    The frequency string should be in the format of a number followed by a time unit,
+    e.g. '1D', '2H', '3M', etc.
+    The time unit can be one of the following:
+    - 'Y' for years
+    - 'M' for months
+    - 'W' for weeks
+    - 'D' for days
+    - 'h' for hours
+    - 'm' for minutes
+    - 's' for seconds
+    - 'ms' for milliseconds
+    Parameters
+    ----------
+    freq : str
+        The frequency string to convert.
+
+    Returns
+    -------
+    np.timedelta64
+        The converted numpy timedelta64 object.
+    """
+    value = freq[:-1]
+    unit = freq[-1]
+    return np.timedelta64(value, unit)

mxalign/utils/projections.py

@@ -0,0 +1,104 @@
+import cartopy.crs as ccrs
+
+
+def create_cartopy_crs(projection, kws_projection, kws_globe=None) -> ccrs.Projection:
+    """Create a Cartopy coordinate reference system (CRS) based on the specified projection.
+
+    This function creates a Cartopy projection object using the provided projection name
+    and associated keyword arguments.
+
+    Parameters
+    ----------
+    projection : str
+        Name of the projection to create. Must be one of the supported projections
+        defined in PROJECTIONS.
+    projection_kws : dict[str, str]
+        Dictionary of keyword arguments to pass to the projection constructor.
+    globe_kws: dict[str, str], optional
+        Optional globe parameters which will be used to create a ccrs.Globe object.
+
+    Returns
+    -------
+    ccrs.Projection
+        The created Cartopy projection object.
+    Raises
+    ------
+    AssertionError
+        If the specified projection is not supported (not in PROJECTIONS).
+
+    Examples
+    --------
+    >>> projection_kws = {'central_longitude': 0,}
+    >>> globe_kws = {'ellipse': 'WGS84'}}
+    >>> crs = create_cartopy_crs('latlon', projection_kws, globe_kws)
+    """
+
+    # - Get the cartopy projection (crs)
+    try:
+        projection = PROJECTIONS[projection]
+    except KeyError:
+        raise ValueError(f"Unsupported projection: {projection}")
+    kws_projection.copy()
+
+    # - Move globe keywords to different dictionary
+    if kws_globe:
+        globe = ccrs.Globe(**kws_globe)
+
+    crs = projection(globe=globe, **kws_projection)
+    return crs
+
+
+PROJECTIONS = dict(
+    lcc=ccrs.LambertConformal,
+    latlon=ccrs.PlateCarree,
+    PlateCarree=ccrs.PlateCarree,
+    Mercator=ccrs.Mercator,
+    Orthographic=ccrs.Orthographic,
+)
+
+BUILTIN = dict(
+    cerra=dict(
+        projection="lcc",
+        kws_globe=dict(
+            semimajor_axis=6371229.0,
+            semiminor_axis=6371229.0,
+        ),
+        kws_projection=dict(
+            central_longitude=8.0,
+            central_latitude=50.0,
+            standard_parallels=[50.0, 50.0],
+        ),
+        kws_grid=dict(
+            lon_ll=-17.4859,
+            lat_ll=20.2923,
+            lon_ur=74.1051,
+            lat_ur=63.7695,
+            dx=5500.0,
+            dy=5500.0,
+            nx=1069,
+            ny=1069,
+        ),
+    ),
+    uwcw=dict(
+        projection="lcc",
+        kws_globe=dict(
+            semimajor_axis=6371229.0,
+            semiminor_axis=6371229.0,
+        ),
+        kws_projection=dict(
+            central_longitude=-1.96590281,
+            central_latitude=55.5164337,
+            standard_parallels=[55.499996, 55.499996],
+        ),
+        kws_grid=dict(
+            lon_ll=-25.4470005,
+            lat_ll=39.6389999,
+            lon_ur=40.1508102,
+            lat_ur=62.6713715,
+            dx=2000.0,
+            dy=2000.0,
+            nx=1909,
+            ny=1609,
+        ),
+    ),
+)

mxalign/utils/save.py

@@ -0,0 +1,62 @@
+from earthkit.data.utils.patterns import Pattern
+
+
+class DatasetPath:
+    def __init__(self, name, ds):
+        self.name = name
+        if ds.time.is_forecast():
+            years = ds["reference_time"].groupby(ds["reference_time"].dt.year).count()
+            self.year = int(years.isel(year=years.argmax())["year"].values)
+            ds_month = ds.sel(reference_time=ds.reference_time.dt.year == self.year)
+            months = (
+                ds_month["reference_time"]
+                .groupby(ds_month["reference_time"].dt.month)
+                .count()
+            )
+            self.month = int(months.isel(month=months.argmax())["month"].values)
+            ds_day = ds_month.sel(
+                reference_time=ds_month.reference_time.dt.month == self.month
+            )
+            days = (
+                ds_day["reference_time"]
+                .groupby(ds_day["reference_time"].dt.day)
+                .count()
+            )
+            self.day = int(days.isel(day=days.argmax())["day"].values)
+        elif ds.time.is_observation():
+            years = ds["valid_time"].groupby(ds["valid_time"].dt.year).count()
+            self.year = int(years.isel(year=years.argmax())["year"].values)
+            ds_month = ds.sel(valid_time=ds.valid_time.dt.year == self.year)
+            months = (
+                ds_month["valid_time"].groupby(ds_month["valid_time"].dt.month).count()
+            )
+            self.month = int(months.isel(month=months.argmax())["month"].values)
+            ds_day = ds_month.sel(valid_time=ds_month.valid_time.dt.month == self.month)
+            days = ds_day["valid_time"].groupby(ds_day["valid_time"].dt.day).count()
+            self.day = int(days.isel(day=days.argmax())["day"].values)
+
+    def substitute(self, path: str):
+        pattern = Pattern(path)
+        path = pattern.substitute(
+            dict(name=self.name),
+            dict(year=self.year),
+            dict(month=self.month),
+            dict(day=self.day),
+            allow_extra=True,
+        )
+        return path
+
+
+def save_dataset(method, name, ds, **kwargs):
+    save_fn = getattr(ds, method)
+    dataset = DatasetPath(name, ds)
+    path = dataset.substitute(kwargs.pop("path"))
+    print(f"Saving to {path}")
+    save_fn(path, **kwargs)
+
+
+def save_metrics(method, ds, **kwargs):
+    save_fn = getattr(ds, method)
+    path = kwargs.pop("path")
+    print(f"Saving to {path}")
+    save_fn(path, **kwargs)

mxalign/verification.py

@@ -0,0 +1,57 @@
+from .transformations.external import _resolve_function
+from functools import partial
+
+
+class Metric:
+    def __init__(self, name, func_path, ds_ref, inputs, **kwargs):
+        self.name = name
+        func = _resolve_function(func_path)
+        self._is_xskillscore = func.__module__.startswith("xskillscore")
+        self._dim = kwargs.get("dim", None)
+
+        kwarg_ref = {}
+        kwarg_ds = []
+        for input_arg, ds_type in inputs.items():
+            if ds_type == "reference":
+                kwarg_ref[input_arg] = (
+                    self._rechunk(ds_ref) if self._is_xskillscore else ds_ref
+                )
+            else:
+                kwarg_ds.append(input_arg)
+        if len(kwarg_ds) > 1:
+            raise ValueError(
+                f"More than one predictor-input argument defined for function {func_path}"
+            )
+        partial_kwargs = {**kwarg_ref, **kwargs}
+        self._func = partial(func, **partial_kwargs)
+        self._kwarg_ds = kwarg_ds[0]
+
+    def compute(self, ds):
+        if self._is_xskillscore:
+            ds = self._rechunk(ds)
+        kwarg_ds = {self._kwarg_ds: ds}
+        return self._func(**kwarg_ds)
+
+    def _rechunk(self, ds):
+        if self._dim is None:
+            return ds
+        dim = [self._dim] if isinstance(self._dim, str) else self._dim
+        dim_other = [d for d in ds.dims if d not in dim]
+        chunks = {d: -1 for d in dim}
+        for d in dim_other:
+            chunks[d] = 1
+        return ds.chunk(chunks)
+
+
+def verify(fcst, obs, func_path, inputs, **kwargs):
+    func = _resolve_function(func_path=func_path)
+    datasets = {
+        "forecast": fcst,
+        "observation": obs,
+    }
+    input_kwargs = {arg_name: datasets[ds_type] for arg_name, ds_type in inputs.items()}
+
+    all_kwargs = {**input_kwargs, **kwargs}
+
+    result = func(**all_kwargs)
+    return result

mxalign-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: mxalign
+Version: 0.1.0
+Summary: Add your description here
+Author-email: Michiel Van Ginderachter <michiel.vanginderachter@meteo.be>
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: bokeh>=3.8.2
+Requires-Dist: cartopy>=0.25.0
+Requires-Dist: dask>=2026.1.2
+Requires-Dist: distributed>=2026.1.2
+Requires-Dist: earthkit-data>=0.19.0
+Requires-Dist: h5netcdf>=1.8.1
+Requires-Dist: h5py>=3.15.1
+Requires-Dist: netcdf4>=1.7.4
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: scipy>=1.17.0
+Requires-Dist: xarray>=2026.1.0
+Requires-Dist: zarr<3.0
+Provides-Extra: earthkit
+Requires-Dist: earthkit-meteo>=0.6.1; extra == 'earthkit'
+Provides-Extra: jobqueue
+Requires-Dist: dask-jobqueue>=0.9.0; extra == 'jobqueue'
+Provides-Extra: verification
+Requires-Dist: xskillscore>=0.0.29; extra == 'verification'
+Description-Content-Type: text/markdown
+
+# Meteo-xAlign
+
+**An xarray based package for alignment of meteorological datasets**
+
+## What is this?
+
+`mxalign` is an `xarray`-based package designed for the alignment and verification of meteorological datasets. It standardizes operations across datasets by attaching properties along three main axes:
+- **Space:** Grid or point-based data
+- **Time:** Forecasts, observations, or climatology
+- **Uncertainty:** Deterministic, ensemble, or quantile forecasts
+
+Currently, `mxalign` also acts as a full execution engine. It can load datasets (e.g., Anemoi inference outputs, observation datasets), apply transformations, align datasets in both space and time to match a reference, safely broadcast NaNs, and execute verification metrics on scaled Dask clusters (Local or Slurm).
+
+> ⚠️ **Roadmap & Future Architecture Changes (planned for v0.2.0):**
+> Currently, `mxalign` handles both alignment and the execution of the verification tooling pipeline, including loading and validation. In the upcoming `v0.2.0` release, this architecture will be refactored:
+> - **Loading** will be split out into [`mlwp-data-loaders`](https://github.com/mlwp-tools/mlwp-data-loaders).
+> - **Validation** of loaded `xr.Dataset`s will be moved to [`mlwp-data-specs`](https://github.com/mlwp-tools/mlwp-data-specs) (which will contain the requirements for each of the dataset traits and the validation logic).
+> - **Execution** of the full verification pipeline (loading, transformations, alignment, and verification) from configuration files may be moved to a separate package in future releases.
+> - **Tests** will be added to `mxalign` (building on test datasets already integrated into `mlwp-data-loaders`) that ensure that all alignment operations work correctly (Testing notebook execution inside `mxalign` is explicitly excluded from the current roadmap).
+
+## Python API
+
+`mxalign` provides building blocks for manual alignment, transformations, and interpolations of `xarray` datasets. This is ideal for interactive use in Jupyter notebooks or custom Python scripts.
+
+```python
+import xarray as xr
+from mxalign import load, align_space, align_time, transform
+
+# Load datasets (using registered loaders)
+ds_obs = load(name="observations_loader", files=["obs.nc"])
+ds_fcst = load(name="anemoi_inference", files=["forecast.nc"])
+
+# Align the forecast spatially to match the observation reference
+ds_fcst_aligned_space = align_space(ds_fcst, reference=ds_obs, method="interpolation")
+
+# Align datasets temporally
+datasets = {"obs": ds_obs, "fcst": ds_fcst_aligned_space}
+aligned_datasets = align_time(datasets, method="intersection")
+```
+
+For a more comprehensive interactive example, check out the [introductory notebook](./examples/introduction.ipynb).
+
+## Executing via a Configuration
+
+For full verification pipeline execution, `mxalign` uses a YAML configuration file. This allows you to declaratively define how datasets are loaded, transformed, aligned, and verified.
+
+### Configuration Contents
+
+The configuration file is divided into several main sections:
+
+```yaml
+datasets:
+  # Define datasets to load, specifying the loader, files, and variables
+  obs_data:
+    loader: observations_loader
+    files: ["obs.nc"]
+  fcst_data:
+    loader: anemoi_inference
+    files: ["forecast.nc"]
+
+transformations:
+  # Apply transformations to loaded datasets
+
+alignment:
+  # Define reference dataset and alignment methods (space, time, NaN broadcasting)
+  reference: obs_data
+  time:
+    method: intersection
+
+verification:
+  # Specify the reference dataset and the metrics to calculate
+  reference: obs_data
+  metrics:
+    # define metrics here
+```
+
+### Running from the Command Line
+
+The CLI uses Dask to distribute the workload and supports both local execution and execution on Slurm-managed HPC clusters.
+
+**Local Execution**
+Run the pipeline on a local Dask cluster:
+```bash
+mxalign local path/to/config.yaml --n_workers 4 --threads_per_worker 1
+```
+
+**Slurm Execution**
+Run the pipeline on a Slurm cluster:
+```bash
+mxalign slurm path/to/config.yaml --account your_account --queue your_queue --cores 8 --memory 64GB
+```
+
+### Running from Python
+
+You can also execute the entire configuration-driven pipeline directly from Python using the `Runner` class.
+
+```python
+from mxalign.runner import Runner
+
+# Initialize the runner with a YAML config file or a dictionary
+runner = Runner("path/to/config.yaml")
+
+# Execute the pipeline: loads, transforms, aligns, and verifies the datasets
+runner.run()
+
+# The resulting aligned datasets and computed metrics are accessible via:
+aligned_datasets = runner.datasets
+metrics = runner.metrics
+```

mxalign-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+mxalign/__init__.py,sha256=zCGKgXlTyEMwLtd-Zy-RfLBxH6jbuR-dwnRSPxO2TZ8,1035
+mxalign/cli.py,sha256=UpctNL68XOUwRIR9xRXaVD89LjovpUJ_l3COTr6DErU,4257
+mxalign/runner.py,sha256=0TyWsHieToUKi-JSe2evqagPcP5wp3sLNtzA1rY15po,6105
+mxalign/verification.py,sha256=jpRxCxfifSl5CQbSbP8sQbdChvyxmDNtLQKPpYSC184,1865
+mxalign/accessors/__init__.py,sha256=NWKgy0F54cvFAUYZGoJjlqH1b7sFRWaqkuNkH0Sjr2w,79
+mxalign/accessors/space.py,sha256=LF5L146ztvLI9V-t1oRsLhU3EDKuNyyGMP6Yr51LH2A,7469
+mxalign/accessors/time.py,sha256=gwgMBsr88uE8ObwGNGGcIUG6KAUfb3n6u85buGB1NpI,7137
+mxalign/align/__init__.py,sha256=cLlhuJYItabVtO73uaNcKmBa4-E1EWynwslzEDn824s,79
+mxalign/align/nans.py,sha256=8sQhAoRAIXI27-Zg4SpjslidHRfYJcJi6yiQD7rYkrA,2511
+mxalign/align/space.py,sha256=i4dt3D309xyqc1Pcbf5DbAJaysk73u-63X9m-c4mGVg,574
+mxalign/align/time.py,sha256=ARuaz2KFeAYO84bgJUNORRxup-waNJ9w6qCHc8VnoIM,2298
+mxalign/interpolations/__init__.py,sha256=Wgo_miRwfLn6moypehGkqCo1t_HhAP1ihAAnfAjcHUE,120
+mxalign/interpolations/base.py,sha256=CqC7NQKH-1_3TxyhhzcCM1pa86ausiQ3CfBeFKQGq_Y,868
+mxalign/interpolations/delaunay.py,sha256=KCkAtlqa7q-UwwOOIGcpWIx3KJItfm-Xg35owaO46c0,7925
+mxalign/interpolations/interpolate.py,sha256=ApZzglT5ZDCG9X9h6ocwOc36mBiPEUaC6cGHSTRMVBA,972
+mxalign/interpolations/registry.py,sha256=T3qez9s8SC86UvdErgv8DAXlCW-X4M3MrP_eEOGRxFw,333
+mxalign/interpolations/xarray.py,sha256=uQC90t9JleoOPMmq33GpybUrvehTjKzST3K3XJi2cYM,2034
+mxalign/loaders/__init__.py,sha256=QYZZPwpywvVNJhMYBMztS1prekJnHFK19xzUO-N5BoQ,203
+mxalign/loaders/anemoi_datasets.py,sha256=TB4k1RnfSBd4GrXbQXRR5XISToysfdJMXLyXWI2nTaI,2764
+mxalign/loaders/anemoi_inference.py,sha256=Siv-fHlDnEWwVE1ng5PvkyOKMFu8Fingc7_fdNYOBjw,2614
+mxalign/loaders/base.py,sha256=SSgwYheu54WdZWs1IkW2q6C1NWignWWcyIx2eohZFo4,2999
+mxalign/loaders/harp_obstable.py,sha256=rJFVf3tNSAZUnADlFN6jDVxlhaNZ_T96fX7oxgI23Sk,2290
+mxalign/loaders/loader.py,sha256=cK3s6T2ORB1VDVfTrAv4ePMEFD-wF3YQIh54RfMocvM,229
+mxalign/loaders/registry.py,sha256=yC32ta-35poHDzWNXbakcpgwRcPqx7VST2ZOvgCIt9A,282
+mxalign/properties/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mxalign/properties/properties.py,sha256=B87GRFsfd_2nNXDRGLpS1h0kRzkRvCYBPJ1vVIHdN90,456
+mxalign/properties/specs.py,sha256=OqmgwcuktrytJDwRx5r9jreMdKf_n8KoOnYXtuEGNLg,1601
+mxalign/properties/utils.py,sha256=FndoAJgcAi4kNdBpErF61ThgTSs6sRM_KAUVaEN4Ckw,1252
+mxalign/properties/validation.py,sha256=-b4FG-OuesN0H0dJ6Nrl9btkHNXF77qxy04LamwkWrI,1436
+mxalign/transformations/__init__.py,sha256=GPYFFS2H3rbmEaGWSrsRWaixr6DTQes15Yl-kCrLFDM,85
+mxalign/transformations/base.py,sha256=i9ZH9N2OHNoEJB_i8DIPAi-DSNt9dg5z-Su7Q4NvOTE,882
+mxalign/transformations/external.py,sha256=pBoUEr0Sp4xNIbwNLsX2DAxKwdqEXbqdgjl6AANA6ws,1053
+mxalign/transformations/registry.py,sha256=8IKlXJTR5o1Ql5i8eXUVvWW4VuiugLobeYwv7qV9GtQ,432
+mxalign/transformations/transform.py,sha256=v6dL0066ijinO4JmGaKbsV1zpr9hAUNHMa32XW3fddE,855
+mxalign/utils/config.py,sha256=MF0MA5rIlILYHkxwFmDtrv5DqTku6dv7iSd0xBxRf38,1719
+mxalign/utils/dates.py,sha256=HFp8RxzLwiPWfnjixgFmBkkJNckJarHqD-KXfLfeub0,2522
+mxalign/utils/projections.py,sha256=6Pa5KPIpSF40pYRHQvdvee8hh7zjY7GcDCZdqXPJfI8,2873
+mxalign/utils/save.py,sha256=N9Fryh4anLQ0TKWSxb7QqEV8cQ6T5Rnw26T-5CJ7fzc,2431
+mxalign-0.1.0.dist-info/METADATA,sha256=2Z50cQfZEfYGkdTizl98zE2ubl4EaL0-AYImb9ctBsc,5492
+mxalign-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+mxalign-0.1.0.dist-info/entry_points.txt,sha256=WDMMkJE_x_dc_01YiSNXHoodh4XZtAS0W44b8u6by_w,45
+mxalign-0.1.0.dist-info/licenses/LICENSE,sha256=ah0n-QlWlM2C19ceTpLEKA7h9SflIBXli6_wo8imRVg,1065
+mxalign-0.1.0.dist-info/RECORD,,

mxalign-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

mxalign-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mxalign = mxalign.cli:main