paramflow 0.1__tar.gz

paramflow-0.1/LICENSE

@@ -0,0 +1,21 @@
+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.

paramflow-0.1/MANIFEST.in

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

paramflow-0.1/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.2
+Name: paramflow
+Version: 0.1
+Home-page: https://github.com/mduszyk/paramflow
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+
+# paramflow
+A parameter and configuration management library motivated by training machine learning models
+and managing configuration for applications that require profiles and layered parameters.
+```paramflow``` is designed for flexibility and ease of use, enabling seamless parameter merging
+from multiple sources. It also auto-generates a command-line argument parser and allows for
+easy parameter overrides.
+
+## Features
+- **Layered configuration**: Merge parameters from files, environment variables, and command-line arguments.
+- **Immutable dictionary**: Provides a read-only dictionary with attribute-style access.
+- **Profile support**: Manage multiple sets of parameters. Layer the chosen profile on top of the default profile.
+- **Layered metaparameters**: ```paramflow``` loads its own configuration using layered approach.
+- **Convert types**: Convert types during merging using target parameters as a reference for type conversions.
+- **Generate argument parser**: Use parameters defined in files as a reference for generating ```argparse``` parser.
+
+## Usage
+
+```python
+import paramflow as pf
+params = pf.load(source='dqn_params.toml')
+print(params.lr)
+```
+
+## Metaparameter Layering
+Metaparameter layering controls how ```paramflow.load``` reads its own configuration.
+
+Layering order:
+1. ```paramflow.load``` arguments.
+2. Environment variables (default prefix 'P_').
+3. Command-line arguments (via ```argparse```).
+
+Activate profile using command-line arguments:
+```bash
+python print_params.py --profile dqn-adam
+```
+Activate profile using environment variable:
+```bash
+P_PROFILE=dqn-adam python print_params.py
+```
+
+## Parameter Layering
+Parameter layering merges parameters from multiple sources.
+
+Layering order:
+1. Configuration files (```.toml```, ```.yaml```, ```.ini```, ```.json```).
+2. ```.env``` file.
+3. Environment variables (default prefix 'P_').
+4. Command-line arguments (via ```argparse```).
+
+Layering order can be customized via ```source``` argument to ```param.flow```.
+```python
+params = pf.load(source=['params.toml', 'env', '.env', 'args'])
+```
+ 
+Overwrite parameter value:
+```bash
+python print_params.py --profile dqn-adam --lr 0.0002
+```
+
+## ML hyper-parameters profiles
+```params.toml```
+```toml
+[default]
+learning_rate = 0.00025
+batch_size = 32
+optimizer_class = 'torch.optim.RMSprop'
+optimizer_kwargs = { momentum = 0.95 }
+random_seed = 13
+
+[adam]
+learning_rate = 1e-4
+optimizer_class = 'torch.optim.Adam'
+optimizer_kwargs = {}
+```
+Activating adam profile
+```bash
+python app.py --profile adam
+```
+will result in overwriting default learning rate with ```1e-4```, default optimizer class with ```'torch.optim.Adam'```
+and default optimizer arguments with and empty dict.
+
+## Devalopment stages profiles
+Profiles can be used to manage software development stages.
+```params.toml```:
+```toml
+[default]
+debug = true
+database_url = "mysql://user:pass@localhost:3306/myapp"
+
+[dev]
+database_url = "mysql://user:pass@dev.app.example.com:3306/myapp"
+
+[prod]
+debug = false
+database_url = "mysql://user:pass@app.example.com:3306/myapp"
+```
+Activate prod profile:
+```bash
+export P_PROFILE=dev
+python app.py
+```

paramflow-0.1/README.md

@@ -0,0 +1,101 @@
+# paramflow
+A parameter and configuration management library motivated by training machine learning models
+and managing configuration for applications that require profiles and layered parameters.
+```paramflow``` is designed for flexibility and ease of use, enabling seamless parameter merging
+from multiple sources. It also auto-generates a command-line argument parser and allows for
+easy parameter overrides.
+
+## Features
+- **Layered configuration**: Merge parameters from files, environment variables, and command-line arguments.
+- **Immutable dictionary**: Provides a read-only dictionary with attribute-style access.
+- **Profile support**: Manage multiple sets of parameters. Layer the chosen profile on top of the default profile.
+- **Layered metaparameters**: ```paramflow``` loads its own configuration using layered approach.
+- **Convert types**: Convert types during merging using target parameters as a reference for type conversions.
+- **Generate argument parser**: Use parameters defined in files as a reference for generating ```argparse``` parser.
+
+## Usage
+
+```python
+import paramflow as pf
+params = pf.load(source='dqn_params.toml')
+print(params.lr)
+```
+
+## Metaparameter Layering
+Metaparameter layering controls how ```paramflow.load``` reads its own configuration.
+
+Layering order:
+1. ```paramflow.load``` arguments.
+2. Environment variables (default prefix 'P_').
+3. Command-line arguments (via ```argparse```).
+
+Activate profile using command-line arguments:
+```bash
+python print_params.py --profile dqn-adam
+```
+Activate profile using environment variable:
+```bash
+P_PROFILE=dqn-adam python print_params.py
+```
+
+## Parameter Layering
+Parameter layering merges parameters from multiple sources.
+
+Layering order:
+1. Configuration files (```.toml```, ```.yaml```, ```.ini```, ```.json```).
+2. ```.env``` file.
+3. Environment variables (default prefix 'P_').
+4. Command-line arguments (via ```argparse```).
+
+Layering order can be customized via ```source``` argument to ```param.flow```.
+```python
+params = pf.load(source=['params.toml', 'env', '.env', 'args'])
+```
+ 
+Overwrite parameter value:
+```bash
+python print_params.py --profile dqn-adam --lr 0.0002
+```
+
+## ML hyper-parameters profiles
+```params.toml```
+```toml
+[default]
+learning_rate = 0.00025
+batch_size = 32
+optimizer_class = 'torch.optim.RMSprop'
+optimizer_kwargs = { momentum = 0.95 }
+random_seed = 13
+
+[adam]
+learning_rate = 1e-4
+optimizer_class = 'torch.optim.Adam'
+optimizer_kwargs = {}
+```
+Activating adam profile
+```bash
+python app.py --profile adam
+```
+will result in overwriting default learning rate with ```1e-4```, default optimizer class with ```'torch.optim.Adam'```
+and default optimizer arguments with and empty dict.
+
+## Devalopment stages profiles
+Profiles can be used to manage software development stages.
+```params.toml```:
+```toml
+[default]
+debug = true
+database_url = "mysql://user:pass@localhost:3306/myapp"
+
+[dev]
+database_url = "mysql://user:pass@dev.app.example.com:3306/myapp"
+
+[prod]
+debug = false
+database_url = "mysql://user:pass@app.example.com:3306/myapp"
+```
+Activate prod profile:
+```bash
+export P_PROFILE=dev
+python app.py
+```

paramflow-0.1/paramflow/__init__.py

@@ -0,0 +1,2 @@
+from paramflow.frozen import freeze
+from paramflow.params import load

paramflow-0.1/paramflow/convert.py

@@ -0,0 +1,35 @@
+import json
+
+
+CONVERSION_MAP = {
+    int: {
+        float: float,
+        str: str,
+    },
+    float: {
+        str: str,
+    },
+    bool: {
+        str: str,
+    },
+    str: {
+        bool: lambda s: s.lower() == 'true',
+        int: int,
+        float: float,
+        dict: json.loads,
+        list: json.loads,
+    }
+}
+
+def convert_type(dst_value, src_value, path=''):
+    dst_type = type(dst_value)
+    src_type = type(src_value)
+    if dst_type is src_type or dst_value is None:
+        return src_value
+    try:
+        convert = CONVERSION_MAP[src_type][dst_type]
+        return convert(src_value)
+    except Exception as e:
+        if path != '':
+            path += ' '
+        raise TypeError(f'unable to convert {path}{src_type} to {dst_type}') from e

paramflow-0.1/paramflow/frozen.py

@@ -0,0 +1,72 @@
+from typing import Union, List, Dict
+
+
+class FrozenAttrDict(dict):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        object.__setattr__(self, '__dict__', self)
+
+    def __setattr__(self, key, value):
+        raise AttributeError('FrozenAttrDict is immutable')
+
+    def __delattr__(self, key):
+        raise AttributeError('FrozenAttrDict is immutable')
+
+    def __setitem__(self, key, value):
+        raise TypeError('FrozenAttrDict is immutable')
+
+    def __delitem__(self, key):
+        raise TypeError('FrozenAttrDict is immutable')
+
+
+class FrozenList(list):
+
+    def __setitem__(self, index, value):
+        raise TypeError('FrozenList is immutable')
+
+    def __delitem__(self, index):
+        raise TypeError('FrozenList is immutable')
+
+    def append(self, value):
+        raise TypeError('FrozenList is immutable')
+
+    def extend(self, iterable):
+        raise TypeError('FrozenList is immutable')
+
+    def insert(self, index, value):
+        raise TypeError('FrozenList is immutable')
+
+    def remove(self, value):
+        raise TypeError('FrozenList is immutable')
+
+    def pop(self, index=-1):
+        raise TypeError('FrozenList is immutable')
+
+    def clear(self):
+        raise TypeError('FrozenList is immutable')
+
+    def __iadd__(self, other):
+        raise TypeError('FrozenList is immutable')
+
+    def __imul__(self, other):
+        raise TypeError('FrozenList is immutable')
+
+
+def freeze(params: Union[List[any], Dict[str, any]]) -> Union[FrozenList[any], FrozenAttrDict[str, any]]:
+    """
+    Recursively freeze dictionaries and list making them read-only. Frozen dict profides attribute-style access.
+    :param params: parameters as python dict and list tree
+    :return: frozen parameters
+    """
+    if isinstance(params, dict):
+        for key, value in params.items():
+            if isinstance(value, dict) or isinstance(value, list):
+                params[key] = freeze(value)
+        return FrozenAttrDict(params)
+    elif isinstance(params, list):
+        for i in range(len(params)):
+            value = params[i]
+            if isinstance(value, dict) or isinstance(value, list):
+                params[i] = freeze(value)
+        return FrozenList(params)

paramflow-0.1/paramflow/params.py

@@ -0,0 +1,122 @@
+import argparse
+import os
+import sys
+from functools import reduce
+from typing import List, Dict, Optional, Union, Final, Type
+
+from paramflow.convert import convert_type
+from paramflow.frozen import freeze, FrozenAttrDict
+from paramflow.parser import PARSER_MAP, EnvParser, ArgsParser, DotEnvParser, Parser
+
+# defaults
+ENV_PREFIX: Final[str] = 'P_'
+ARGS_PREFIX: Final[str] = ''
+DEFAULT_PROFILE: Final[str] = 'default'
+PROFILE_KEY: Final[str] = 'profile'
+ENV_SOURCE: Final[str] = 'env'
+ARGS_SOURCE: Final[str] = 'args'
+
+
+def load(source: Optional[Union[str, List[str]]] = None,
+         env_prefix: str = ENV_PREFIX,
+         args_prefix: str = ARGS_PREFIX,
+         profile_key: str = PROFILE_KEY,
+         default_profile: str = DEFAULT_PROFILE,
+         profile: Optional[str] = None) -> FrozenAttrDict[str, any]:
+    """
+    Load parameters form multiple sources, layer them on top of each other and activate profile.
+    Activation of profile means learying it on top of the default profile.
+    :param source: file or multiple files to load parameters from
+    :param env_prefix: prefix for env vars that are used to overwrite params, if None disable auto adding env source
+    :param args_prefix: prefix for command-line arguments, if None disable auto adding args source
+    :param profile_key: parameter name for the profile
+    :param default_profile: default profile
+    :param profile: profile to activate
+    :return: read-only parameters as frozen dict
+    """
+
+    meta = {
+        'source': source,
+        'env_prefix': env_prefix,
+        'args_prefix': args_prefix,
+        'profile_key': profile_key,
+        'default_profile': default_profile,
+        profile_key: profile,
+    }
+    meta_env_parser = EnvParser(ENV_PREFIX, DEFAULT_PROFILE)
+    meta_args_parser = ArgsParser(ARGS_PREFIX, DEFAULT_PROFILE)
+    meta = deep_merge(meta, meta_env_parser(meta))
+    meta = deep_merge(meta, meta_args_parser(meta))
+    meta = freeze(meta)
+
+    if meta.source is None:
+        sys.exit('file meta param is missing')
+
+    sources = list(meta.source) if isinstance(meta.source, list) else [meta.source]
+    if ENV_SOURCE not in sources and meta.env_prefix is not None:
+        sources.append(ENV_SOURCE)
+    if ARGS_SOURCE not in sources and meta.args_prefix is not None:
+        sources.append(ARGS_SOURCE)
+    parsers = build_parsers(sources, meta)
+
+    return parse(parsers, meta.default_profile, meta.profile)
+
+
+def parse(parsers: List[Parser], default_profile: str, target_profile: str):
+    params = {}
+    for parser in parsers:
+        params = deep_merge(params, parser(params))
+    params = activate_profile(params, default_profile, target_profile)
+    return freeze(params)
+
+
+def build_parsers(sources: List[str], meta: Dict[str, any]):
+    parsers = []
+    for source in sources:
+        if source == ARGS_SOURCE:
+            parser = ArgsParser(meta.args_prefix, meta.default_profile, meta.profile)
+        elif source == ENV_SOURCE:
+            parser = EnvParser(meta.env_prefix, meta.default_profile, meta.profile)
+        elif source.endswith('.env'):
+            parser = DotEnvParser(source, meta.env_prefix, meta.default_profile, meta.profile)
+        else:
+            ext = source.split('.')[-1]
+            parser_class = PARSER_MAP[ext]
+            parser = parser_class(source)
+        parsers.append(parser)
+    return parsers
+
+
+def activate_profile(params: Dict[str, any], default_profile: str, profile: str) -> Dict[str, any]:
+    profile_params = params.get(default_profile)
+    if profile_params is None:
+        profile_params = params  # profiles disabled
+    if '__source__' in params:
+        profile_params['__source__'] = params['__source__']
+    profile_params['__profile__'] = [default_profile]
+    if profile is not None and profile != default_profile:
+        active_profile_params = params[profile]
+        deep_merge(profile_params, active_profile_params)
+        profile_params['__profile__'].append(profile)
+    return profile_params
+
+
+def deep_merge(dst: dict, src: dict, path: str = '') -> dict:
+    for src_key, src_value in src.items():
+        if src_key == '__source__':
+            if not src_key in dst:
+                dst[src_key] = []
+            dst[src_key].extend(src_value)
+        elif isinstance(src_value, dict) and isinstance(dst.get(src_key), dict):
+            deep_merge(dst[src_key], src_value, f'{path}.{src_key}')
+        elif isinstance(src_value, list) and isinstance(dst.get(src_key), list) and len(src_value) == len(dst[src_key]):
+            for i in range(len(src_value)):
+                dst_item = dst[i]
+                current_path = f'{path}[{i}]'
+                if isinstance(src_value[i], dict) and isinstance(dst_item[i], dict):
+                    deep_merge(dst_item[i], src_value[i], current_path)
+                else:
+                    dst_item[i] = convert_type(dst_item[i], src_value[i], current_path)
+        else:
+            dst[src_key] = convert_type(dst.get(src_key), src_value, f'{path}.{src_key}')
+    return dst

paramflow-0.1/paramflow/parser.py

@@ -0,0 +1,159 @@
+import argparse
+import configparser
+import json
+import os
+import tomllib
+from typing import Dict, Final, Type
+from abc import ABC, abstractmethod
+
+import yaml
+from dotenv import dotenv_values
+
+
+class Parser(ABC):
+    @abstractmethod
+    def __call__(self, *args) -> Dict[str, any]:
+        pass
+
+
+class TomlParser(Parser):
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def __call__(self, *args) -> Dict[str, any]:
+        with open(self.path, 'rb') as fp:
+            params = tomllib.load(fp)
+        if len(params) > 0:
+            params['__source__'] = [self.path]
+        return params
+
+
+class YamlParser(Parser):
+
+    def __init__(self, path: str):
+        self.path = path
+
+    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]
+        return params
+
+
+class JsonParser(Parser):
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def __call__(self, *args) -> Dict[str, any]:
+        with open(self.path, 'r') as fp:
+            params = json.load(fp)
+        if len(params) > 0:
+            params['__source__'] = [self.path]
+        return params
+
+
+class IniParser(Parser):
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def __call__(self, *args) -> Dict[str, any]:
+        config = configparser.ConfigParser()
+        config.read(self.path)
+        params = {section: dict(config.items(section)) for section in config.sections()}
+        if len(params) > 0:
+            params['__source__'] = [self.path]
+        return params
+
+
+class DotEnvParser(Parser):
+
+    def __init__(self, path: str, prefix: str, default_profile: str, target_profile: str = None):
+        self.path = path
+        self.prefix = prefix
+        self.default_profile = default_profile
+        self.target_profile = target_profile
+
+    def __call__(self, params: Dict[str, any]) -> Dict[str, any]:
+        if self.target_profile is None and self.default_profile in params:
+            self.target_profile = self.default_profile
+        params = params.get(self.default_profile, params)
+        env = dotenv_values(self.path)
+        params = get_env_params(env, self.prefix, params)
+        if self.target_profile is not None:
+            params = {self.target_profile: params}
+        if len(params) > 0:
+            params['__source__'] = [self.path]
+        return params
+
+
+def get_env_params(env: Dict[str, any], prefix: str, ref_params: Dict[str, any]) -> Dict[str, any]:
+    params = {}
+    for env_key, env_value in env.items():
+        if env_key.startswith(prefix):
+            key = env_key.replace(prefix, '').lower()
+            if key in ref_params:
+                params[key] = env_value
+    return params
+
+
+class EnvParser(Parser):
+
+    def __init__(self, prefix: str, default_profile: str, target_profile: str = None):
+        self.prefix = prefix
+        self.default_profile = default_profile
+        self.target_profile = target_profile
+
+    def __call__(self, params: Dict[str, any]) -> Dict[str, any]:
+        if self.target_profile is None and self.default_profile in params:
+            self.target_profile = self.default_profile
+        params = params.get(self.default_profile, params)
+        env_params = get_env_params(os.environ, self.prefix, params)
+        result = env_params
+        if self.target_profile is not None:
+            result = {self.target_profile: env_params}
+        if len(env_params) > 0:
+            result['__source__'] = ['env']
+        return result
+
+
+class ArgsParser(Parser):
+
+    def __init__(self, prefix: str, default_profile: str, target_profile: str = None):
+        self.prefix = prefix
+        self.default_profile = default_profile
+        self.target_profile = target_profile
+
+    def __call__(self, params: Dict[str, any]) -> Dict[str, any]:
+        if self.target_profile is None and self.default_profile in params:
+            self.target_profile = self.default_profile
+        params = params.get(self.default_profile, params)
+        parser = argparse.ArgumentParser()
+        for key, value in params.items():
+            typ = type(value)
+            if typ is dict or typ is list or typ is bool or value is None:
+                typ = str
+            parser.add_argument(f'--{self.prefix}{key}', type=typ, default=None, help=f'{key} = {value}')
+        args, _ = parser.parse_known_args()
+        args_params = {}
+        for arg_key, arg_value in args.__dict__.items():
+            if arg_value is not None:
+                key = arg_key.replace(self.prefix, '')
+                args_params[key] = arg_value
+        result = args_params
+        if self.target_profile is not None:
+            result = {self.target_profile: args_params}
+        if len(args_params) > 0:
+            result['__source__'] = ['args']
+        return result
+
+
+PARSER_MAP: Final[Dict[str, Type[Parser]]] = {
+    'toml': TomlParser,
+    'yaml': YamlParser,
+    'json': JsonParser,
+    'ini': IniParser,
+}

paramflow-0.1/paramflow.egg-info/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.2
+Name: paramflow
+Version: 0.1
+Home-page: https://github.com/mduszyk/paramflow
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+
+# paramflow
+A parameter and configuration management library motivated by training machine learning models
+and managing configuration for applications that require profiles and layered parameters.
+```paramflow``` is designed for flexibility and ease of use, enabling seamless parameter merging
+from multiple sources. It also auto-generates a command-line argument parser and allows for
+easy parameter overrides.
+
+## Features
+- **Layered configuration**: Merge parameters from files, environment variables, and command-line arguments.
+- **Immutable dictionary**: Provides a read-only dictionary with attribute-style access.
+- **Profile support**: Manage multiple sets of parameters. Layer the chosen profile on top of the default profile.
+- **Layered metaparameters**: ```paramflow``` loads its own configuration using layered approach.
+- **Convert types**: Convert types during merging using target parameters as a reference for type conversions.
+- **Generate argument parser**: Use parameters defined in files as a reference for generating ```argparse``` parser.
+
+## Usage
+
+```python
+import paramflow as pf
+params = pf.load(source='dqn_params.toml')
+print(params.lr)
+```
+
+## Metaparameter Layering
+Metaparameter layering controls how ```paramflow.load``` reads its own configuration.
+
+Layering order:
+1. ```paramflow.load``` arguments.
+2. Environment variables (default prefix 'P_').
+3. Command-line arguments (via ```argparse```).
+
+Activate profile using command-line arguments:
+```bash
+python print_params.py --profile dqn-adam
+```
+Activate profile using environment variable:
+```bash
+P_PROFILE=dqn-adam python print_params.py
+```
+
+## Parameter Layering
+Parameter layering merges parameters from multiple sources.
+
+Layering order:
+1. Configuration files (```.toml```, ```.yaml```, ```.ini```, ```.json```).
+2. ```.env``` file.
+3. Environment variables (default prefix 'P_').
+4. Command-line arguments (via ```argparse```).
+
+Layering order can be customized via ```source``` argument to ```param.flow```.
+```python
+params = pf.load(source=['params.toml', 'env', '.env', 'args'])
+```
+ 
+Overwrite parameter value:
+```bash
+python print_params.py --profile dqn-adam --lr 0.0002
+```
+
+## ML hyper-parameters profiles
+```params.toml```
+```toml
+[default]
+learning_rate = 0.00025
+batch_size = 32
+optimizer_class = 'torch.optim.RMSprop'
+optimizer_kwargs = { momentum = 0.95 }
+random_seed = 13
+
+[adam]
+learning_rate = 1e-4
+optimizer_class = 'torch.optim.Adam'
+optimizer_kwargs = {}
+```
+Activating adam profile
+```bash
+python app.py --profile adam
+```
+will result in overwriting default learning rate with ```1e-4```, default optimizer class with ```'torch.optim.Adam'```
+and default optimizer arguments with and empty dict.
+
+## Devalopment stages profiles
+Profiles can be used to manage software development stages.
+```params.toml```:
+```toml
+[default]
+debug = true
+database_url = "mysql://user:pass@localhost:3306/myapp"
+
+[dev]
+database_url = "mysql://user:pass@dev.app.example.com:3306/myapp"
+
+[prod]
+debug = false
+database_url = "mysql://user:pass@app.example.com:3306/myapp"
+```
+Activate prod profile:
+```bash
+export P_PROFILE=dev
+python app.py
+```

paramflow-0.1/paramflow.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+paramflow/__init__.py
+paramflow/convert.py
+paramflow/frozen.py
+paramflow/params.py
+paramflow/parser.py
+paramflow.egg-info/PKG-INFO
+paramflow.egg-info/SOURCES.txt
+paramflow.egg-info/dependency_links.txt
+paramflow.egg-info/top_level.txt
+paramflow/__pycache__/__init__.cpython-312.pyc
+paramflow/__pycache__/convert.cpython-312.pyc
+paramflow/__pycache__/frozen.cpython-312.pyc
+paramflow/__pycache__/frozen_test.cpython-312-pytest-8.3.4.pyc
+paramflow/__pycache__/params.cpython-312.pyc
+paramflow/__pycache__/params_test.cpython-312-pytest-8.3.4.pyc
+paramflow/__pycache__/parser.cpython-312.pyc

paramflow-0.1/paramflow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

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

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

paramflow-0.1/pyproject.toml

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

paramflow-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

paramflow-0.1/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='paramflow',
+    version='0.1',
+    packages=find_packages(),
+    install_requires=[],
+    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',
+    ],
+)