paramflow 0.6__tar.gz → 0.6.2__tar.gz

{paramflow-0.6/paramflow.egg-info → paramflow-0.6.2}/PKG-INFO

@@ -1,23 +1,44 @@
 Metadata-Version: 2.4
 Name: paramflow
-Version: 0.6
+Version: 0.6.2
 Summary: A lightweight library for hyperparameter and configuration management
-Home-page: https://github.com/mduszyk/paramflow
+License: MIT License
+        
+        Copyright (c) 2025 mduszyk
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/mduszyk/paramflow
+Project-URL: Repository, https://github.com/mduszyk/paramflow
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyyaml
 Provides-Extra: dotenv
 Requires-Dist: python-dotenv; extra == "dotenv"
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 # paramflow
 ParamFlow is a lightweight library for layered configuration management, tailored for machine learning projects and any application that needs to merge parameters from multiple sources. It merges files, environment variables, and CLI arguments in a defined order, activates named profiles, and returns a read-only, attribute-accessible dictionary.

paramflow-0.6.2/examples/print_params.py

@@ -0,0 +1,13 @@
+import json
+import paramflow as pf
+
+# Example usages:
+# P_FILE=params.toml python print_params.py
+# P_FILE=params.yaml P_PROFILE=prod python print_params.py
+# python print_params.py --sources params.yaml --profile=prod
+# python print_params.py --sources params.toml
+# python print_params.py --sources dqn_train.toml --profile dqn-adam
+# python print_params.py --sources dqn_train.toml --profile dqn-adam --batch_size 64
+
+params = pf.load()
+print(json.dumps(params, indent=4))

paramflow-0.6.2/examples/usage/app.py

@@ -0,0 +1,3 @@
+import paramflow as pf
+params = pf.load('params.toml')
+print(params.learning_rate)

{paramflow-0.6 → paramflow-0.6.2}/paramflow/params.py

@@ -34,6 +34,14 @@ def load(*sources: str | dict,
     :return: read-only parameters as frozen dict
     """
 
+    for source in sources:
+        if not isinstance(source, (str, dict)):
+            raise TypeError(f"sources must be file paths or dicts, got {type(source).__name__}")
+    if not default_profile:
+        raise ValueError("default_profile must be a non-empty string")
+    if not profile_key:
+        raise ValueError("profile_key must be a non-empty string")
+
     logger.debug('Reading meta params layer %d, source: %s', 0, 'pf.load')
     meta = {
         'sources': sources,
@@ -106,6 +114,9 @@ def activate_profile(params: Dict[str, Any], default_profile: str, profile: str)
         profile_params['__source__'] = params['__source__']
     profile_params['__profile__'] = [default_profile]
     if profile is not None and profile != default_profile:
+        if profile not in params:
+            available = [k for k in params if not k.startswith('__') and k != default_profile]
+            raise ValueError(f"profile '{profile}' not found, available profiles: {available}")
         active_profile_params = params[profile]
         deep_merge(profile_params, active_profile_params)
         profile_params['__profile__'].append(profile)

{paramflow-0.6 → paramflow-0.6.2}/paramflow/parser.py

@@ -57,8 +57,9 @@ class YamlParser(Parser):
     def __call__(self, *args) -> Dict[str, Any]:
         with open(self.path, 'r') as fp:
             params = yaml.safe_load(fp)
-        if len(params) > 0:
-            params['__source__'] = [self.path]
+        if not params:
+            return {}
+        params['__source__'] = [self.path]
         return params
 
 
@@ -98,7 +99,13 @@ class DotEnvParser(Parser):
         self.target_profile = target_profile
 
     def __call__(self, params: Dict[str, Any]) -> Dict[str, Any]:
-        from dotenv import dotenv_values
+        try:
+            from dotenv import dotenv_values
+        except ImportError:
+            raise ImportError(
+                f"loading '{self.path}' requires dotenv support: "
+                "pip install 'paramflow[dotenv]'"
+            )
         if self.target_profile is None and self.default_profile in params:
             self.target_profile = self.default_profile
         params: Dict[str, Any] = params.get(self.default_profile, params)

{paramflow-0.6 → paramflow-0.6.2/paramflow.egg-info}/PKG-INFO

@@ -1,23 +1,44 @@
 Metadata-Version: 2.4
 Name: paramflow
-Version: 0.6
+Version: 0.6.2
 Summary: A lightweight library for hyperparameter and configuration management
-Home-page: https://github.com/mduszyk/paramflow
+License: MIT License
+        
+        Copyright (c) 2025 mduszyk
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/mduszyk/paramflow
+Project-URL: Repository, https://github.com/mduszyk/paramflow
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyyaml
 Provides-Extra: dotenv
 Requires-Dist: python-dotenv; extra == "dotenv"
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 # paramflow
 ParamFlow is a lightweight library for layered configuration management, tailored for machine learning projects and any application that needs to merge parameters from multiple sources. It merges files, environment variables, and CLI arguments in a defined order, activates named profiles, and returns a read-only, attribute-accessible dictionary.

{paramflow-0.6 → paramflow-0.6.2}/paramflow.egg-info/SOURCES.txt

@@ -1,8 +1,8 @@
 LICENSE
-MANIFEST.in
 README.md
 pyproject.toml
-setup.py
+examples/print_params.py
+examples/usage/app.py
 paramflow/__init__.py
 paramflow/convert.py
 paramflow/frozen.py
@@ -24,4 +24,7 @@ paramflow/__pycache__/params.cpython-312.pyc
 paramflow/__pycache__/params.cpython-313.pyc
 paramflow/__pycache__/params_test.cpython-312-pytest-8.3.4.pyc
 paramflow/__pycache__/parser.cpython-312.pyc
-paramflow/__pycache__/parser.cpython-313.pyc
+paramflow/__pycache__/parser.cpython-313.pyc
+tests/convert_test.py
+tests/frozen_test.py
+tests/params_test.py

paramflow-0.6.2/paramflow.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+build
+dist
+examples
+paramflow
+tests

paramflow-0.6.2/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "paramflow"
+version = "0.6.2"
+description = "A lightweight library for hyperparameter and configuration management"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"
+dependencies = ["pyyaml"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.optional-dependencies]
+dotenv = ["python-dotenv"]
+
+[project.urls]
+Homepage = "https://github.com/mduszyk/paramflow"
+Repository = "https://github.com/mduszyk/paramflow"
+
+[tool.setuptools.packages.find]
+where = ["."]

paramflow-0.6.2/tests/convert_test.py

@@ -0,0 +1,55 @@
+import pytest
+
+from paramflow.convert import convert_type, infer_type
+
+
+def test_convert_type():
+    assert type(convert_type(3, 10)) is int
+    assert convert_type(3, 10) == 10
+    assert convert_type(3, '10') == 10
+    assert type(convert_type(3.0, 10)) is float
+    assert convert_type(3.0, 10) == 10.0
+    assert convert_type(3.14, '2.73') == 2.73
+    assert convert_type(False, 'true') == True
+    assert convert_type({}, '{"a": 1, "b": 2}') == {'a': 1, 'b': 2}
+    assert convert_type([], '[1, 2, 3]') == [1, 2, 3]
+
+
+def test_failed_conversion():
+    with pytest.raises(TypeError):
+        convert_type({}, 5)
+
+
+def test_infer_type():
+    assert infer_type('42') == 42
+    assert type(infer_type('42')) is int
+    assert infer_type('3.14') == 3.14
+    assert type(infer_type('3.14')) is float
+    assert infer_type('hello') == 'hello'
+    assert type(infer_type('hello')) is str
+    assert infer_type('true') is True
+    assert infer_type('false') is False
+    assert infer_type('True') is True
+    assert infer_type('False') is False
+
+
+def test_convert_type_none_dst():
+    assert convert_type(None, 42) == 42
+    assert convert_type(None, 'hello') == 'hello'
+    assert convert_type(None, [1, 2, 3]) == [1, 2, 3]
+
+
+def test_convert_type_bool_false():
+    assert convert_type(False, 'false') == False
+    assert convert_type(True, 'false') == False
+
+
+def test_convert_type_str_to_tuple():
+    result = convert_type(('a',), 'hello')
+    assert result == ('hello',)
+    assert type(result) is tuple
+
+
+def test_convert_type_error_message_with_path():
+    with pytest.raises(TypeError, match='mykey'):
+        convert_type({}, 5, path='mykey')

paramflow-0.6.2/tests/frozen_test.py

@@ -0,0 +1,98 @@
+import pytest
+
+from paramflow.frozen import freeze, unfreeze, ParamsList, ParamsDict
+
+
+def test_freeze():
+    params = freeze({
+        'default': {
+            'name': 'test',
+            'lr': 1e-3,
+            'debug': True,
+            'list': [1, 2, 3],
+            'dict': {'foo': 1, 'bar': 2},
+        }
+    })
+    assert isinstance(params, ParamsDict)
+    assert params.default.name == 'test'
+    assert params.default.lr == 1e-3
+    assert params.default.debug
+    assert isinstance(params.default.list, ParamsList)
+    assert params.default.list[2] == 3
+    assert isinstance(params.default.dict, ParamsDict)
+    assert params.default.dict.foo == 1
+    assert params.default.dict.bar == 2
+
+def test_unfreeze():
+    params = freeze({
+        'default': {
+            'name': 'test',
+            'list': [1, 2, 3],
+        }
+    })
+    params2 = freeze(unfreeze(params))
+    assert params.default.name == params2.default.name
+    assert len(params.default.list) == len(params2.default.list)
+    assert params.default.list[0] == params2.default.list[0]
+    assert params.default.list[1] == params2.default.list[1]
+    assert params.default.list[2] == params2.default.list[2]
+
+
+def test_params_dict_immutability():
+    params = freeze({'x': 1, 'y': 2})
+    with pytest.raises(AttributeError):
+        params.x = 10
+    with pytest.raises(AttributeError):
+        del params.x
+    with pytest.raises(TypeError):
+        params['x'] = 10
+    with pytest.raises(TypeError):
+        del params['x']
+
+
+def test_params_dict_missing_key():
+    params = freeze({'x': 1})
+    with pytest.raises(AttributeError, match="has no param 'z'"):
+        _ = params.z
+
+
+def test_params_list_immutability():
+    pl = freeze([1, 2, 3])
+    with pytest.raises(TypeError):
+        pl[0] = 99
+    with pytest.raises(TypeError):
+        del pl[0]
+    with pytest.raises(TypeError):
+        pl.append(4)
+    with pytest.raises(TypeError):
+        pl.extend([4, 5])
+    with pytest.raises(TypeError):
+        pl.insert(0, 0)
+    with pytest.raises(TypeError):
+        pl.remove(1)
+    with pytest.raises(TypeError):
+        pl.pop()
+    with pytest.raises(TypeError):
+        pl.clear()
+    with pytest.raises(TypeError):
+        pl.__iadd__([4])
+    with pytest.raises(TypeError):
+        pl.__imul__(2)
+
+
+def test_freeze_list():
+    frozen = freeze([1, {'a': 2}, [3, 4]])
+    assert isinstance(frozen, ParamsList)
+    assert frozen[0] == 1
+    assert isinstance(frozen[1], ParamsDict)
+    assert frozen[1].a == 2
+    assert isinstance(frozen[2], ParamsList)
+
+
+def test_unfreeze_list():
+    frozen = freeze([1, {'a': 2}, [3, 4]])
+    unfrozen = unfreeze(frozen)
+    assert type(unfrozen) is list
+    assert unfrozen[0] == 1
+    assert type(unfrozen[1]) is dict
+    assert type(unfrozen[2]) is list

paramflow-0.6.2/tests/params_test.py

@@ -0,0 +1,471 @@
+import os
+import sys
+from functools import reduce
+from tempfile import NamedTemporaryFile
+
+import pytest
+
+import paramflow as pf
+from paramflow.params import activate_profile, deep_merge, build_parsers
+from paramflow.parser import EnvParser, DictParser, DotEnvParser, get_env_params
+
+
+@pytest.fixture
+def temp_file(request):
+    def create_temp_file(content, suffix):
+        tmp = NamedTemporaryFile(delete=False, mode='w+', suffix=suffix)
+        tmp.write(content)
+        tmp.close()
+        request.addfinalizer(lambda: os.remove(tmp.name))
+        return tmp.name
+    return create_temp_file
+
+
+def test_deep_merge():
+    dst = {
+        'default': {
+            'name': 'test',
+            'lr': 1e-3,
+            'debug': True,
+        }
+    }
+    src = {'default': {'name': 'test123'}}
+    deep_merge(dst, src)
+    assert dst['default']['name'] == 'test123'
+
+def test_deep_merge_list():
+    dst = {'default': {'tags': ['a', 'b', 'c']}}
+    src = {'default': {'tags': ['x', 'y', 'z']}}
+    deep_merge(dst, src)
+    assert dst['default']['tags'] == ['x', 'y', 'z']
+
+
+def test_deep_merge_empty_dict():
+    dst = {
+        'default': {
+            'kwargs': {
+                'lr': 1e-3,
+                'debug': True,
+            }
+        }
+    }
+    src = {'default': {'kwargs': {}}}
+    deep_merge(dst, src)
+    assert dst['default']['kwargs'] == {}
+
+
+def test_activate_profile():
+    params = {
+        'default': { 'debug': True },
+        'prod': { 'debug': False }
+    }
+    params = activate_profile(params, 'default', 'prod')
+    assert not params['debug']
+
+
+def test_merge_override_layers():
+    params = {'default': { 'name': 'test' }}
+    overrides = {'default': {'name': 'test123'}}
+    params = reduce(deep_merge, [params, overrides])
+    params = activate_profile(params, 'default', 'default')
+    assert params['name'] == 'test123'
+
+
+def test_merge_multiple_layers_and_activate():
+    layer1 = {'default': {'debug': True, 'name': 'Joe', 'age': 20}}
+    layer2 = {'prod': { 'debug': False }}
+    layer3 = {'prod': {'name': 'Jane'}}
+    layer4 = {'prod': {'age': 30}}
+    layers = [layer1, layer2, layer3, layer4]
+    params = reduce(deep_merge, layers)
+    params = activate_profile(params, 'default', 'prod')
+    assert not params['debug']
+    assert params['name'] == 'Jane'
+    assert params['age'] == 30
+
+
+def test_toml_no_profiles(temp_file, monkeypatch):
+    file_content = (
+        """
+        name = 'test'
+        lr = 1e-3
+        debug = true
+        """
+    )
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path)
+    assert params.name == 'test'
+    assert params.lr == 1e-3
+    assert params.debug
+
+
+def test_toml_default(temp_file, monkeypatch):
+    file_content = (
+        """
+        [default]
+        name = 'test'
+        lr = 1e-3
+        debug = true
+        """
+    )
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path)
+    assert params.name == 'test'
+    assert params.lr == 1e-3
+    assert params.debug
+
+
+def test_yaml_profile_env_args(temp_file, monkeypatch):
+    file_content = (
+        """
+        default:
+          name: 'dev'
+          lr: 0.001
+          debug: true
+        prod:
+          debug: false
+        """
+    )
+    file_path = temp_file(file_content, '.yaml')
+    monkeypatch.setenv('P_LR', '0.0001')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--profile', 'prod', '--name', 'production'])
+    params = pf.load(file_path)
+    assert params.name == 'production'
+    assert params.lr == 1e-4
+    assert not params.debug
+    assert params.__source__ == [file_path, 'env', 'args']
+
+
+def test_load_all_layers(temp_file, monkeypatch):
+    file1 = temp_file("default:\n  lr: 0.001", '.yaml')
+    file2 = temp_file("[default]\nname = 'dev'", '.ini')
+    file3 = temp_file('[default]\ndebug = true\nbatch_size=32', '.toml')
+    file4 = temp_file('{"prod": {"debug": false}}', '.json')
+    file5 = temp_file('P_NAME=production', '.env')
+    monkeypatch.setenv('P_LR', '0.0001')
+    monkeypatch.setenv('P_PROFILE', 'prod')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--batch_size', '64'])
+    params = pf.load(file1, file2, file3, file4, file5)
+    assert params.name == 'production'
+    assert params.lr == 0.0001
+    assert params.batch_size == 64
+    assert not params.debug
+    assert params.__source__ == [file1, file2, file3, file4, file5, 'env', 'args']
+    assert params.__profile__ == ['default', 'prod']
+
+
+def test_custom_merge_order(temp_file, monkeypatch):
+    file_toml = temp_file('[default]\nname = "local"\ndebug = true\nbatch_size=32', '.toml')
+    dot_env = temp_file('P_NAME=prod', '.env')
+    monkeypatch.setenv('P_NAME', 'dev')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--batch_size', '64'])
+    source = [file_toml, 'env', dot_env, 'args']
+    params = pf.load(*source)
+    assert params.name == 'prod'
+    assert params.batch_size == 64
+    assert params.debug
+    assert params.__source__ == source
+    assert params.__profile__ == ['default']
+
+
+def test_specify_file_via_cmd(temp_file, monkeypatch):
+    file_toml = temp_file('[default]\nname = "dev"\ndebug = true\nbatch_size=32', '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--sources', file_toml])
+    params = pf.load()
+    assert params.name == 'dev'
+    assert params.batch_size == 32
+    assert params.debug
+    assert params.__source__ == [file_toml]
+    assert params.__profile__ == ['default']
+
+
+def test_nested_configuration(temp_file):
+    file1_yaml = temp_file(
+        """
+        default:
+          level1:
+            name: 'abc'
+            value: 17
+            level2:
+                name: 'foo'
+                value: 0
+        """, '.yaml')
+    file2_yaml = temp_file(
+        """
+        default:
+          level1:
+            name: 'bar'
+            level2:
+                value: 42
+        """, '.yaml')
+    params = pf.load(file1_yaml, file2_yaml)
+    assert params.level1.name == 'bar'
+    assert params.level1.value == 17
+    assert params.level1.level2.name == 'foo'
+    assert params.level1.level2.value == 42
+
+
+def test_args_only_param(temp_file, monkeypatch):
+    file_content = (
+        """
+        [default]
+        lr = 1e-3
+        debug = true
+        """
+    )
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--batch_size', '64', '--name', 'test'])
+    params = pf.load(file_path)
+    assert params.lr == 1e-3
+    assert params.debug
+    assert params.batch_size == 64
+    assert params.name == 'test'
+
+
+def test_dict_params(temp_file, monkeypatch):
+    file_content = (
+        """
+        [default]
+        lr = 1e-3
+        debug = true
+        """
+    )
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path, {'name': 'test'})
+    assert params.lr == 1e-3
+    assert params.debug
+    assert params.name == 'test'
+
+
+def test_load_invalid_source_type(monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    with pytest.raises(TypeError, match='int'):
+        pf.load(42)
+
+
+def test_load_invalid_default_profile(temp_file, monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    with pytest.raises(ValueError, match='default_profile'):
+        pf.load(default_profile='')
+
+
+def test_load_invalid_profile_key(temp_file, monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    with pytest.raises(ValueError, match='profile_key'):
+        pf.load(profile_key='')
+
+
+def test_deep_merge_source_key():
+    dst = {'__source__': ['a']}
+    src = {'__source__': ['b', 'c']}
+    deep_merge(dst, src)
+    assert dst['__source__'] == ['a', 'b', 'c']
+
+
+def test_deep_merge_list_length_mismatch():
+    dst = {'default': {'tags': ['a', 'b']}}
+    src = {'default': {'tags': ['x', 'y', 'z']}}
+    deep_merge(dst, src)
+    assert dst['default']['tags'] == ['x', 'y', 'z']
+
+
+def test_deep_merge_list_of_dicts():
+    dst = {'items': [{'name': 'a', 'val': 1}, {'name': 'b', 'val': 2}]}
+    src = {'items': [{'val': 10}, {'name': 'B'}]}
+    deep_merge(dst, src)
+    assert dst['items'][0]['name'] == 'a'
+    assert dst['items'][0]['val'] == 10
+    assert dst['items'][1]['name'] == 'B'
+    assert dst['items'][1]['val'] == 2
+
+
+def test_activate_profile_missing():
+    params = {'default': {'x': 1}, 'prod': {'x': 2}}
+    with pytest.raises(ValueError, match="profile 'staging' not found"):
+        activate_profile(params, 'default', 'staging')
+
+
+def test_activate_profile_missing_lists_available():
+    params = {'default': {'x': 1}, 'prod': {'x': 2}, 'dev': {'x': 3}, '__source__': ['f.toml']}
+    with pytest.raises(ValueError) as exc:
+        activate_profile(params, 'default', 'staging')
+    msg = str(exc.value)
+    assert 'prod' in msg
+    assert 'dev' in msg
+    assert 'default' not in msg
+    assert '__source__' not in msg
+
+
+def test_activate_profile_none():
+    params = {'default': {'x': 1}, 'prod': {'x': 2}}
+    result = activate_profile(params, 'default', None)
+    assert result['x'] == 1
+    assert result['__profile__'] == ['default']
+
+
+def test_activate_profile_same_as_default():
+    params = {'default': {'x': 1}}
+    result = activate_profile(params, 'default', 'default')
+    assert result['x'] == 1
+    assert result['__profile__'] == ['default']
+
+
+def test_activate_profile_no_profile_key():
+    params = {'x': 1, 'y': 2}
+    result = activate_profile(params, 'default', None)
+    assert result['x'] == 1
+    assert result['__profile__'] == ['default']
+
+
+def test_activate_profile_source_propagation():
+    params = {
+        'default': {'x': 1},
+        '__source__': ['file.toml'],
+    }
+    result = activate_profile(params, 'default', None)
+    assert result['__source__'] == ['file.toml']
+
+
+def test_load_with_profile_kwarg(temp_file, monkeypatch):
+    file_content = """
+    [default]
+    debug = true
+    [prod]
+    debug = false
+    """
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path, profile='prod')
+    assert not params.debug
+
+
+def test_get_env_params_direct():
+    env = {'P_NAME': 'alice', 'P_LR': '0.01', 'OTHER': 'ignored'}
+    ref_params = {'name': 'bob', 'lr': 0.001}
+    result = get_env_params(env, 'P_', ref_params)
+    assert result == {'name': 'alice', 'lr': '0.01'}
+
+
+def test_env_parser_no_match():
+    parser = EnvParser('ZZZNOMATCH_', 'default')
+    result = parser({'default': {'name': 'test', 'lr': 0.001}})
+    assert result == {}
+
+
+def test_dict_parser_direct():
+    data = {'name': 'test', 'lr': 0.001}
+    parser = DictParser(data)
+    result = parser()
+    assert result['default'] == data
+    assert result['__source__'] == [data]
+    assert result['default'] is not data
+
+
+def test_build_parsers_unknown_extension():
+    meta = pf.freeze({
+        'env_prefix': 'P_',
+        'args_prefix': '',
+        'default_profile': 'default',
+        'profile': None,
+    })
+    with pytest.raises(ValueError, match=r"unsupported file format '\.xyz'"):
+        build_parsers(['config.xyz'], meta)
+
+
+def test_yaml_empty_file(temp_file, monkeypatch):
+    file_path = temp_file('', '.yaml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path)
+    assert params.__profile__ == ['default']
+
+
+def test_yaml_comments_only(temp_file, monkeypatch):
+    file_path = temp_file('# just a comment\n', '.yaml')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(file_path)
+    assert params.__profile__ == ['default']
+
+
+def test_dotenv_parser_missing_dependency(temp_file, monkeypatch):
+    dot_env = temp_file('P_NAME=alice', '.env')
+    monkeypatch.setitem(sys.modules, 'dotenv', None)
+    parser = DotEnvParser(dot_env, 'P_', 'default')
+    with pytest.raises(ImportError, match="pip install 'paramflow\\[dotenv\\]'"):
+        parser({'default': {'name': 'bob'}})
+
+
+def test_dotenv_parser_basic(temp_file):
+    dot_env = temp_file('P_NAME=alice\nP_LR=0.01\nOTHER=ignored', '.env')
+    parser = DotEnvParser(dot_env, 'P_', 'default')
+    result = parser({'default': {'name': 'bob', 'lr': 0.001}})
+    assert result['default']['name'] == 'alice'
+    assert result['default']['lr'] == '0.01'
+    assert result['__source__'] == [dot_env]
+
+
+def test_dotenv_parser_prefix_filter(temp_file):
+    dot_env = temp_file('P_NAME=alice\nOTHER_NAME=bob', '.env')
+    parser = DotEnvParser(dot_env, 'P_', 'default')
+    result = parser({'default': {'name': 'default_name'}})
+    assert result['default']['name'] == 'alice'
+
+
+def test_dotenv_parser_key_filter(temp_file):
+    dot_env = temp_file('P_NAME=alice\nP_UNKNOWN=xyz', '.env')
+    parser = DotEnvParser(dot_env, 'P_', 'default')
+    result = parser({'default': {'name': 'bob'}})
+    assert result['default'] == {'name': 'alice'}
+
+
+def test_dotenv_parser_no_match(temp_file):
+    dot_env = temp_file('OTHER=value', '.env')
+    parser = DotEnvParser(dot_env, 'P_', 'default')
+    result = parser({'default': {'name': 'bob'}})
+    assert result == {}
+
+
+def test_dotenv_parser_target_profile(temp_file):
+    dot_env = temp_file('P_NAME=alice', '.env')
+    parser = DotEnvParser(dot_env, 'P_', 'default', target_profile='prod')
+    result = parser({'default': {'name': 'bob'}})
+    assert result['prod']['name'] == 'alice'
+    assert result['__source__'] == [dot_env]
+
+
+def test_load_dotenv_overrides(temp_file, monkeypatch):
+    toml = temp_file('[default]\nname = "dev"\nlr = 0.001', '.toml')
+    dot_env = temp_file('P_NAME=production\nP_LR=0.0001', '.env')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(toml, dot_env)
+    assert params.name == 'production'
+    assert params.lr == 0.0001
+    assert dot_env in params.__source__
+
+
+def test_load_dotenv_type_conversion(temp_file, monkeypatch):
+    toml = temp_file('[default]\ndebug = true\nbatch_size = 32', '.toml')
+    dot_env = temp_file('P_DEBUG=false\nP_BATCH_SIZE=64', '.env')
+    monkeypatch.setattr(sys, 'argv', ['test.py'])
+    params = pf.load(toml, dot_env)
+    assert params.debug == False
+    assert params.batch_size == 64
+
+
+def test_help(temp_file, monkeypatch, capsys):
+    file_content = (
+        """
+        [default]
+        lr = 1e-3
+        debug = true
+        """
+    )
+    file_path = temp_file(file_content, '.toml')
+    monkeypatch.setattr(sys, 'argv', ['test.py', '--help'])
+    with pytest.raises(SystemExit) as exc:
+        pf.load(file_path)
+    captured = capsys.readouterr()
+    assert 'Meta-parameters' in captured.out
+    assert 'Parameters' in captured.out

paramflow-0.6/MANIFEST.in

@@ -1,3 +0,0 @@
-include README.md
-include LICENSE
-recursive-include paramflow *

paramflow-0.6/paramflow.egg-info/top_level.txt

@@ -1 +0,0 @@
-paramflow

paramflow-0.6/pyproject.toml

@@ -1,3 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"

paramflow-0.6/setup.py

@@ -1,22 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='paramflow',
-    version='0.6',
-    description='A lightweight library for hyperparameter and configuration management', 
-    packages=find_packages(),
-    install_requires=[
-        "pyyaml",
-    ],
-    extras_require={
-        "dotenv": ["python-dotenv"],
-    },
-    entry_points={},
-    long_description=open('README.md').read(),
-    long_description_content_type='text/markdown',
-    url='https://github.com/mduszyk/paramflow',
-    classifiers=[
-        'Programming Language :: Python :: 3',
-        'License :: OSI Approved :: MIT License',
-    ],
-)