junifer 0.0.7.dev84__py3-none-any.whl → 0.0.7.dev93__py3-none-any.whl

junifer/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.7.dev84'
-__version_tuple__ = version_tuple = (0, 0, 7, 'dev84')
+__version__ = version = '0.0.7.dev93'
+__version_tuple__ = version_tuple = (0, 0, 7, 'dev93')

junifer/datagrabber/__init__.pyi

@@ -10,7 +10,11 @@ __all__ = [
     "DataladHCP1200",
     "MultipleDataGrabber",
     "DMCC13Benchmark",
+    "DataTypeManager",
+    "DataTypeSchema",
+    "OptionalTypeSchema",
     "PatternValidationMixin",
+    "register_data_type",
 ]
 
 # These 4 need to be in this order, otherwise it is a circular import
@@ -24,4 +28,10 @@ from .hcp1200 import HCP1200, DataladHCP1200
 from .multiple import MultipleDataGrabber
 from .dmcc13_benchmark import DMCC13Benchmark
 
-from .pattern_validation_mixin import PatternValidationMixin
+from .pattern_validation_mixin import (
+    DataTypeManager,
+    DataTypeSchema,
+    OptionalTypeSchema,
+    PatternValidationMixin,
+    register_data_type,
+)

junifer/datagrabber/pattern_validation_mixin.py

@@ -3,71 +3,199 @@
 # Authors: Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+from collections.abc import Iterator, MutableMapping
+from typing import TypedDict
+
 from ..typing import DataGrabberPatterns
 from ..utils import logger, raise_error, warn_with_log
 
 
-__all__ = ["PatternValidationMixin"]
-
-
-# Define schema for pattern-based datagrabber's patterns
-PATTERNS_SCHEMA = {
-    "T1w": {
-        "mandatory": ["pattern", "space"],
-        "optional": {
-            "mask": {"mandatory": ["pattern", "space"], "optional": []},
-        },
-    },
-    "T2w": {
-        "mandatory": ["pattern", "space"],
-        "optional": {
-            "mask": {"mandatory": ["pattern", "space"], "optional": []},
-        },
-    },
-    "BOLD": {
-        "mandatory": ["pattern", "space"],
-        "optional": {
-            "mask": {"mandatory": ["pattern", "space"], "optional": []},
-            "confounds": {
-                "mandatory": ["pattern", "format"],
-                "optional": ["mappings"],
-            },
-            "reference": {"mandatory": ["pattern"], "optional": []},
-            "prewarp_space": {"mandatory": [], "optional": []},
-        },
-    },
-    "Warp": {
-        "mandatory": ["pattern", "src", "dst", "warper"],
-        "optional": {},
-    },
-    "VBM_GM": {
-        "mandatory": ["pattern", "space"],
-        "optional": {},
-    },
-    "VBM_WM": {
-        "mandatory": ["pattern", "space"],
-        "optional": {},
-    },
-    "VBM_CSF": {
-        "mandatory": ["pattern", "space"],
-        "optional": {},
-    },
-    "DWI": {
-        "mandatory": ["pattern"],
-        "optional": {},
-    },
-    "FreeSurfer": {
-        "mandatory": ["pattern"],
-        "optional": {
-            "aseg": {"mandatory": ["pattern"], "optional": []},
-            "norm": {"mandatory": ["pattern"], "optional": []},
-            "lh_white": {"mandatory": ["pattern"], "optional": []},
-            "rh_white": {"mandatory": ["pattern"], "optional": []},
-            "lh_pial": {"mandatory": ["pattern"], "optional": []},
-            "rh_pial": {"mandatory": ["pattern"], "optional": []},
-        },
-    },
-}
+__all__ = [
+    "DataTypeManager",
+    "DataTypeSchema",
+    "OptionalTypeSchema",
+    "PatternValidationMixin",
+    "register_data_type",
+]
+
+
+class OptionalTypeSchema(TypedDict):
+    """Optional type schema."""
+
+    mandatory: list[str]
+    optional: list[str]
+
+
+class DataTypeSchema(TypedDict):
+    """Data type schema."""
+
+    mandatory: list[str]
+    optional: dict[str, OptionalTypeSchema]
+
+
+class DataTypeManager(MutableMapping):
+    """Class for managing data types."""
+
+    _instance = None
+
+    def __new__(cls):
+        """Overridden to make the class singleton."""
+        # Make class singleton
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            # Set global schema
+            cls._global: dict[str, DataTypeSchema] = {}
+            cls._builtin: dict[str, DataTypeSchema] = {}
+            cls._external: dict[str, DataTypeSchema] = {}
+            cls._builtin.update(
+                {
+                    "T1w": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {
+                            "mask": {
+                                "mandatory": ["pattern", "space"],
+                                "optional": [],
+                            },
+                        },
+                    },
+                    "T2w": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {
+                            "mask": {
+                                "mandatory": ["pattern", "space"],
+                                "optional": [],
+                            },
+                        },
+                    },
+                    "BOLD": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {
+                            "mask": {
+                                "mandatory": ["pattern", "space"],
+                                "optional": [],
+                            },
+                            "confounds": {
+                                "mandatory": ["pattern", "format"],
+                                "optional": ["mappings"],
+                            },
+                            "reference": {
+                                "mandatory": ["pattern"],
+                                "optional": [],
+                            },
+                            "prewarp_space": {"mandatory": [], "optional": []},
+                        },
+                    },
+                    "Warp": {
+                        "mandatory": ["pattern", "src", "dst", "warper"],
+                        "optional": {},
+                    },
+                    "VBM_GM": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {},
+                    },
+                    "VBM_WM": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {},
+                    },
+                    "VBM_CSF": {
+                        "mandatory": ["pattern", "space"],
+                        "optional": {},
+                    },
+                    "DWI": {
+                        "mandatory": ["pattern"],
+                        "optional": {},
+                    },
+                    "FreeSurfer": {
+                        "mandatory": ["pattern"],
+                        "optional": {
+                            "aseg": {"mandatory": ["pattern"], "optional": []},
+                            "norm": {"mandatory": ["pattern"], "optional": []},
+                            "lh_white": {
+                                "mandatory": ["pattern"],
+                                "optional": [],
+                            },
+                            "rh_white": {
+                                "mandatory": ["pattern"],
+                                "optional": [],
+                            },
+                            "lh_pial": {
+                                "mandatory": ["pattern"],
+                                "optional": [],
+                            },
+                            "rh_pial": {
+                                "mandatory": ["pattern"],
+                                "optional": [],
+                            },
+                        },
+                    },
+                }
+            )
+            cls._global.update(cls._builtin)
+        return cls._instance
+
+    def __getitem__(self, key: str) -> DataTypeSchema:
+        """Retrieve schema for ``key``."""
+        return self._global[key]
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over data types."""
+        return iter(self._global)
+
+    def __len__(self) -> int:
+        """Get data type count."""
+        return len(self._global)
+
+    def __delitem__(self, key: str) -> None:
+        """Remove schema for ``key``."""
+        # Internal check
+        if key in self._builtin:
+            raise_error(f"Cannot delete in-built key: {key}")
+        # Non-existing key
+        if key not in self._external:
+            raise_error(klass=KeyError, msg=key)
+        # Update external
+        _ = self._external.pop(key)
+        # Update global
+        _ = self._global.pop(key)
+
+    def __setitem__(self, key: str, value: DataTypeSchema) -> None:
+        """Update ``key`` with ``value``."""
+        # Internal check
+        if key in self._builtin:
+            raise_error(f"Cannot set value for in-built key: {key}")
+        # Value type check
+        if not isinstance(value, dict):
+            raise_error(f"Invalid value type: {type(value)}")
+        # Update external
+        self._external[key] = value
+        # Update global
+        self._global[key] = value
+
+    def popitem():
+        """Not implemented."""
+        pass
+
+    def clear(self):
+        """Not implemented."""
+        pass
+
+    def setdefault(self, key: str, value=None):
+        """Not implemented."""
+        pass
+
+
+def register_data_type(name: str, schema: DataTypeSchema) -> None:
+    """Register custom data type.
+
+    Parameters
+    ----------
+    name : str
+        The data type name.
+    schema : DataTypeSchema
+        The data type schema.
+
+    """
+    DataTypeManager()[name] = schema
 
 
 class PatternValidationMixin:
@@ -311,12 +439,13 @@ class PatternValidationMixin:
                 msg="`patterns` must contain all `types`", klass=ValueError
             )
         # Check against schema
+        dtype_mgr = DataTypeManager()
         for dtype_key, dtype_val in patterns.items():
             # Check if valid data type is provided
-            if dtype_key not in PATTERNS_SCHEMA:
+            if dtype_key not in dtype_mgr:
                 raise_error(
                     f"Unknown data type: {dtype_key}, "
-                    f"should be one of: {list(PATTERNS_SCHEMA.keys())}"
+                    f"should be one of: {list(dtype_mgr.keys())}"
                 )
             # Conditional for list dtype vals like Warp
             if isinstance(dtype_val, list):
@@ -324,14 +453,14 @@ class PatternValidationMixin:
                     # Check mandatory keys for data type
                     self._validate_mandatory_keys(
                         keys=list(entry),
-                        schema=PATTERNS_SCHEMA[dtype_key]["mandatory"],
+                        schema=dtype_mgr[dtype_key]["mandatory"],
                         data_type=f"{dtype_key}.{idx}",
                         partial_pattern_ok=partial_pattern_ok,
                     )
                     # Check optional keys for data type
-                    for optional_key, optional_val in PATTERNS_SCHEMA[
-                        dtype_key
-                    ]["optional"].items():
+                    for optional_key, optional_val in dtype_mgr[dtype_key][
+                        "optional"
+                    ].items():
                         if optional_key not in entry:
                             logger.debug(
                                 f"Optional key: `{optional_key}` missing for "
@@ -344,12 +473,12 @@ class PatternValidationMixin:
                             )
                             # Set nested type name for easier access
                             nested_dtype = f"{dtype_key}.{idx}.{optional_key}"
-                            nested_mandatory_keys_schema = PATTERNS_SCHEMA[
+                            nested_mandatory_keys_schema = dtype_mgr[
                                 dtype_key
                             ]["optional"][optional_key]["mandatory"]
-                            nested_optional_keys_schema = PATTERNS_SCHEMA[
-                                dtype_key
-                            ]["optional"][optional_key]["optional"]
+                            nested_optional_keys_schema = dtype_mgr[dtype_key][
+                                "optional"
+                            ][optional_key]["optional"]
                             # Check mandatory keys for nested type
                             self._validate_mandatory_keys(
                                 keys=list(optional_val["mandatory"]),
@@ -392,10 +521,8 @@ class PatternValidationMixin:
                     self._identify_stray_keys(
                         keys=list(entry.keys()),
                         schema=(
-                            PATTERNS_SCHEMA[dtype_key]["mandatory"]
-                            + list(
-                                PATTERNS_SCHEMA[dtype_key]["optional"].keys()
-                            )
+                            dtype_mgr[dtype_key]["mandatory"]
+                            + list(dtype_mgr[dtype_key]["optional"].keys())
                         ),
                         data_type=dtype_key,
                     )
@@ -412,12 +539,12 @@ class PatternValidationMixin:
                 # Check mandatory keys for data type
                 self._validate_mandatory_keys(
                     keys=list(dtype_val),
-                    schema=PATTERNS_SCHEMA[dtype_key]["mandatory"],
+                    schema=dtype_mgr[dtype_key]["mandatory"],
                     data_type=dtype_key,
                     partial_pattern_ok=partial_pattern_ok,
                 )
                 # Check optional keys for data type
-                for optional_key, optional_val in PATTERNS_SCHEMA[dtype_key][
+                for optional_key, optional_val in dtype_mgr[dtype_key][
                     "optional"
                 ].items():
                     if optional_key not in dtype_val:
@@ -432,12 +559,12 @@ class PatternValidationMixin:
                         )
                         # Set nested type name for easier access
                         nested_dtype = f"{dtype_key}.{optional_key}"
-                        nested_mandatory_keys_schema = PATTERNS_SCHEMA[
-                            dtype_key
-                        ]["optional"][optional_key]["mandatory"]
-                        nested_optional_keys_schema = PATTERNS_SCHEMA[
-                            dtype_key
-                        ]["optional"][optional_key]["optional"]
+                        nested_mandatory_keys_schema = dtype_mgr[dtype_key][
+                            "optional"
+                        ][optional_key]["mandatory"]
+                        nested_optional_keys_schema = dtype_mgr[dtype_key][
+                            "optional"
+                        ][optional_key]["optional"]
                         # Check mandatory keys for nested type
                         self._validate_mandatory_keys(
                             keys=list(optional_val["mandatory"]),
@@ -476,8 +603,8 @@ class PatternValidationMixin:
                 self._identify_stray_keys(
                     keys=list(dtype_val.keys()),
                     schema=(
-                        PATTERNS_SCHEMA[dtype_key]["mandatory"]
-                        + list(PATTERNS_SCHEMA[dtype_key]["optional"].keys())
+                        dtype_mgr[dtype_key]["mandatory"]
+                        + list(dtype_mgr[dtype_key]["optional"].keys())
                     ),
                     data_type=dtype_key,
                 )

junifer/datagrabber/tests/test_pattern_validation_mixin.py

@@ -9,7 +9,110 @@ from typing import Union
 
 import pytest
 
-from junifer.datagrabber.pattern_validation_mixin import PatternValidationMixin
+from junifer.datagrabber.pattern_validation_mixin import (
+    DataTypeManager,
+    DataTypeSchema,
+    PatternValidationMixin,
+    register_data_type,
+)
+
+
+def test_dtype_mgr_addition_errors() -> None:
+    """Test data type manager addition errors."""
+    with pytest.raises(ValueError, match="Cannot set"):
+        dtype_schema: DataTypeSchema = {
+            "mandatory": ["pattern"],
+            "optional": {},
+        }
+        DataTypeManager()["T1w"] = dtype_schema
+
+    with pytest.raises(ValueError, match="Invalid"):
+        DataTypeManager()["DType"] = ""
+
+
+def test_dtype_mgr_removal_errors() -> None:
+    """Test data type manager removal errors."""
+    with pytest.raises(ValueError, match="Cannot delete"):
+        _ = DataTypeManager().pop("T1w")
+
+    with pytest.raises(KeyError, match="DType"):
+        del DataTypeManager()["DType"]
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        {
+            "mandatory": ["pattern"],
+            "optional": {},
+        },
+        {
+            "mandatory": ["pattern"],
+            "optional": {
+                "subtype": {
+                    "mandatory": [],
+                    "optional": [],
+                }
+            },
+        },
+        {
+            "mandatory": ["pattern"],
+            "optional": {
+                "subtype": {
+                    "mandatory": ["pattern"],
+                    "optional": [],
+                }
+            },
+        },
+        {
+            "mandatory": ["pattern"],
+            "optional": {
+                "subtype": {
+                    "mandatory": ["pattern"],
+                    "optional": ["pattern"],
+                }
+            },
+        },
+    ],
+)
+def test_dtype_mgr(dtype: DataTypeSchema) -> None:
+    """Test data type manager addition and removal.
+
+    Parameters
+    ----------
+    dtype : DataTypeSchema
+        The parametrized schema.
+
+    """
+
+    DataTypeManager().update({"DType": dtype})
+    assert "DType" in DataTypeManager()
+
+    _ = DataTypeManager().pop("DType")
+    assert "DType" not in DataTypeManager()
+
+
+def test_register_data_type() -> None:
+    """Test data type registration."""
+
+    dtype_schema: DataTypeSchema = {
+        "mandatory": ["pattern"],
+        "optional": {
+            "mask": {
+                "mandatory": ["pattern"],
+                "optional": [],
+            },
+        },
+    }
+
+    register_data_type(
+        name="dtype",
+        schema=dtype_schema,
+    )
+
+    assert "dtype" in DataTypeManager()
+    _ = DataTypeManager().pop("dtype")
+    assert "dumb" not in DataTypeManager()
 
 
 @pytest.mark.parametrize(

junifer/typing/_typing.py

@@ -64,7 +64,7 @@ ConditionalDependencies = Sequence[
 ExternalDependencies = Sequence[MutableMapping[str, Union[str, Sequence[str]]]]
 MarkerInOutMappings = MutableMapping[str, MutableMapping[str, str]]
 DataGrabberPatterns = dict[
-    str, Union[dict[str, str], Sequence[dict[str, str]]]
+    str, Union[dict[str, str], list[dict[str, str]]]
 ]
 ConfigVal = Union[bool, int, float, str]
 Element = Union[str, tuple[str, ...]]

{junifer-0.0.7.dev84.dist-info → junifer-0.0.7.dev93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.7.dev84
+Version: 0.0.7.dev93
 Summary: JUelich NeuroImaging FEature extractoR
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>
 Maintainer-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>

{junifer-0.0.7.dev84.dist-info → junifer-0.0.7.dev93.dist-info}/RECORD

@@ -1,6 +1,6 @@
 junifer/__init__.py,sha256=2McgH1yNue6Z1V26-uN_mfMjbTcx4CLhym-DMBl5xA4,266
 junifer/__init__.pyi,sha256=SsTvgq2Dod6UqJN96GH1lCphH6hJQQurEJHGNhHjGUI,508
-junifer/_version.py,sha256=iWMjU9D90ZxnUKQO-oz8AsSNuBYLAhkb9NigQNnxQE0,526
+junifer/_version.py,sha256=vFYsjG-TWfjglJG7fH8rtbhQ3pjvXxlnFjXQw4toOfM,526
 junifer/conftest.py,sha256=PWYkkRDU8ly2lYwv7VBKMHje4et6HX7Yey3Md_I2KbA,613
 junifer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 junifer/stats.py,sha256=e9aaagMGtgpRfW3Wdpz9ocpnYld1IWylCDcjFUgX9Mk,6225
@@ -100,14 +100,14 @@ junifer/data/tests/test_data_utils.py,sha256=6-UQ7HDZ7_zA7iQalzk29KJBdftQMVyqKsQ
 junifer/data/tests/test_dispatch.py,sha256=bm4R0E8gs_XpJ6B5lfWFXjle7PmDjaX7Wu0L6mEU33w,2315
 junifer/data/tests/test_template_spaces.py,sha256=ZEicEcLqOJ-NpuBZ5SYh4yZ0xZRkhYHnYXiC_YSxjrY,3219
 junifer/datagrabber/__init__.py,sha256=EHIK-lbjuvkt0V8ypFvLSt85OAAXSkaxBmVlCbNNz8M,323
-junifer/datagrabber/__init__.pyi,sha256=zOQE4TaCKXBTHnNqgmECtsszWIOHYiQ1CUEeXXFU9F4,832
+junifer/datagrabber/__init__.pyi,sha256=4Eydc8RO4TN8TLRDq68cdbJPQMxGEynQwU2bmmWStLg,1027
 junifer/datagrabber/base.py,sha256=Llr5bHyHovkySI-bzxoQ1TklEF6WOaNRN9D_srqQvYM,6661
 junifer/datagrabber/datalad_base.py,sha256=52T2DbqDGOxiKSESBESzElrVJ3WihLWrrGlQewSvYOs,12616
 junifer/datagrabber/dmcc13_benchmark.py,sha256=VMyiwvkr4qSvzBICSksPPKOI2w_WVo06H89Url-hrNs,12819
 junifer/datagrabber/multiple.py,sha256=4tCOzojs3hoG7daHJJ7HUsx15atWR5nTmyP0S0__aig,6666
 junifer/datagrabber/pattern.py,sha256=hZxXc59qFGiH710aZkcVgt-JcvVjuR-EMmQ1_QFAoHM,18724
 junifer/datagrabber/pattern_datalad.py,sha256=7jY-0Xw0G-mKG0BgXNTQPuS-KPnpFhvqfVOZtD6Yfcc,4567
-junifer/datagrabber/pattern_validation_mixin.py,sha256=3MwpeUePm8eGgbe-J2kTWs9x5bk1SR3nhojHwN95SXM,19368
+junifer/datagrabber/pattern_validation_mixin.py,sha256=UpeSy9jNtJ_5OL5IqlLIFPOMg0SFTHcOTpW3DlepE9g,23696
 junifer/datagrabber/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 junifer/datagrabber/aomic/__init__.py,sha256=ATxzXq9NBPmWowTMuL77zqrmIbbnk0Wd1iXtXCP3XDg,266
 junifer/datagrabber/aomic/__init__.pyi,sha256=Rp6C075fZDdKY8VIq508_g4NhVj8bWzR6zb9yln761Q,189
@@ -130,7 +130,7 @@ junifer/datagrabber/tests/test_dmcc13_benchmark.py,sha256=h5zLrcP7BbSCeGLt2VfCsi
 junifer/datagrabber/tests/test_multiple.py,sha256=tZBQhlEiSE1PeQ5E3TtuVgsHENquna9t39p54AJ-O5w,9963
 junifer/datagrabber/tests/test_pattern.py,sha256=H55jYRPfT3rMsoIQOAnWJgw3nGrkU7m2xFa3-ed6NQE,9527
 junifer/datagrabber/tests/test_pattern_datalad.py,sha256=HJ3dQ3XSlMZ3UT1w2b2xpdPqvfmNxRWmla9zhRejWYI,6483
-junifer/datagrabber/tests/test_pattern_validation_mixin.py,sha256=KU3xha3Mo7IX_5Tp4RL5awvEzZrX43OmrRFjeqMYVgk,7498
+junifer/datagrabber/tests/test_pattern_validation_mixin.py,sha256=yzUBRB4it_2BCNcp8syh5n3WejRRI6YfMg5T-p4_IkM,9982
 junifer/datareader/__init__.py,sha256=CDWjL4PQthskxWX5d0ASro6YIfTT1Tb7ZmyDllWWZso,318
 junifer/datareader/__init__.pyi,sha256=VOqhh-C3-eqapHVR7-F9Ulc_6iyHTb35XLoGb2DCRaA,72
 junifer/datareader/default.py,sha256=q8aXHlBzLtRtgM2z3JWIsB-daSZncr33mliZlV5RzdM,6733
@@ -308,7 +308,7 @@ junifer/tests/test_main.py,sha256=GMff7jlisGM9_FsiUwWDte43j-KQJGFRYZpwRRqTkd8,37
 junifer/tests/test_stats.py,sha256=NljoGFu2JOPADbi9W0WeUHwpf8nZSdOkcCgCv-Z1fY4,4149
 junifer/typing/__init__.py,sha256=e0UbuxozXUIxz8h8pLokMOxZV629Q1lnA7vvgm95WF0,215
 junifer/typing/__init__.pyi,sha256=5jzVAkras38Eou5abUvdP1AXhbpCSnPAllLx88YuPB8,640
-junifer/typing/_typing.py,sha256=vPUuES-PO5tNkrxm-3ghq5A3lE2f0IuCgBIgswrR07M,1787
+junifer/typing/_typing.py,sha256=JogiI9wCZWHuqgTaZarjk89aA5pR0yTvFx2JfheLT_Y,1783
 junifer/utils/__init__.py,sha256=I3tYaePAD_ZEU-36-TJ_OYeqW_aMmi5MZ3jmqie6RfU,260
 junifer/utils/__init__.pyi,sha256=CMb4rq1VcQ00IRuiBFfAWu07Vb-vA4qtVLAoY0ll-bA,422
 junifer/utils/_config.py,sha256=cfxyv1bfklID2atQseu6y3J7mZrCXPwnGEfBSImG9CM,3054
@@ -322,10 +322,10 @@ junifer/utils/tests/test_config.py,sha256=7ltIXuwb_W4Mv_1dxQWyiyM10XgUAfsWKV6D_i
 junifer/utils/tests/test_fs.py,sha256=WQS7cKlKEZ742CIuiOYYpueeAhY9PqlastfDVpVVtvE,923
 junifer/utils/tests/test_helpers.py,sha256=k5qqfxK8dFyuewTJyR1Qn6-nFaYNuVr0ysc18bfPjyU,929
 junifer/utils/tests/test_logging.py,sha256=W4tFKmaf8_CxnWZ-o_-XxM7DQbhGG18RsLZJk8bZelI,8163
-junifer-0.0.7.dev84.dist-info/licenses/AUTHORS.rst,sha256=rmULKpchpSol4ExWFdm-qu4fkpSZPYqIESVJBZtGb6E,163
-junifer-0.0.7.dev84.dist-info/licenses/LICENSE.md,sha256=MqCnOBu8uXsEOzRZWh9EBVfVz-kE9NkXcLCrtGXo2yU,34354
-junifer-0.0.7.dev84.dist-info/METADATA,sha256=GpP1-4C59Ci4SZQ9MNzH_l_Qi0JVs0cuk3mjHGMp4SY,8387
-junifer-0.0.7.dev84.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-junifer-0.0.7.dev84.dist-info/entry_points.txt,sha256=6O8ru0BP-SP7YMUZiizFNoaZ2HvJpadO2G7nKk4PwjI,48
-junifer-0.0.7.dev84.dist-info/top_level.txt,sha256=4bAq1R2QFQ4b3hohjys2JBvxrl0GKk5LNFzYvz9VGcA,8
-junifer-0.0.7.dev84.dist-info/RECORD,,
+junifer-0.0.7.dev93.dist-info/licenses/AUTHORS.rst,sha256=rmULKpchpSol4ExWFdm-qu4fkpSZPYqIESVJBZtGb6E,163
+junifer-0.0.7.dev93.dist-info/licenses/LICENSE.md,sha256=MqCnOBu8uXsEOzRZWh9EBVfVz-kE9NkXcLCrtGXo2yU,34354
+junifer-0.0.7.dev93.dist-info/METADATA,sha256=XJDtsS1aolWYxCr-iCbrso20QFIP8bciZm9-BxskKWk,8387
+junifer-0.0.7.dev93.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+junifer-0.0.7.dev93.dist-info/entry_points.txt,sha256=6O8ru0BP-SP7YMUZiizFNoaZ2HvJpadO2G7nKk4PwjI,48
+junifer-0.0.7.dev93.dist-info/top_level.txt,sha256=4bAq1R2QFQ4b3hohjys2JBvxrl0GKk5LNFzYvz9VGcA,8
+junifer-0.0.7.dev93.dist-info/RECORD,,