inex-launcher 2.2.13__tar.gz

inex-launcher-2.2.13/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Speech Technology Center
+
+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.

inex-launcher-2.2.13/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt inex/version.txt

inex-launcher-2.2.13/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: inex-launcher
+Version: 2.2.13
+Summary: InEx is a lightweight highly configurable Python launcher based on microkernel architecture
+Home-page: https://github.com/speechpro/inex
+Author: Yuri Khokhlov
+Author-email: khokhlov@speechpro.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/speechpro/inex/issues
+Keywords: speechpro inex command-line configuration yaml
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# InEx
+## Lightweight highly configurable Python launcher based on microkernel architecture

inex-launcher-2.2.13/README.md

@@ -0,0 +1,2 @@
+# InEx
+## Lightweight highly configurable Python launcher based on microkernel architecture

inex-launcher-2.2.13/inex/__init__.py

@@ -0,0 +1,12 @@
+import os
+
+
+try:
+    from .version import __version__
+except ImportError:
+    path = os.path.join(os.path.dirname(__file__), 'version.txt')
+    if os.path.isfile(path):
+        with open(path) as stream:
+            __version__ = stream.readline().strip()
+    else:
+        __version__ = 'failed-to-get-version'

inex-launcher-2.2.13/inex/engine.py

@@ -0,0 +1,20 @@
+import logging
+from inex.utils.configure import create_plugin
+
+
+def execute(config, state, stop_after=None):
+    logging.debug('Creating plugins')
+    if 'plugins' in config:
+        plugins = config['plugins']
+        assert isinstance(plugins, list), f'Wrong type of "plugins" {type(plugins)} (must be list)'
+        for plugin in plugins:
+            create_plugin(plugin, config, state)
+            if (stop_after is not None) and (plugin == stop_after):
+                logging.info(f'Execution stopped because specified plugin "{plugin}" was initialized')
+                return
+    logging.debug('Looking for execution options')
+    if 'execute' in config:
+        logging.debug('Loading execution options')
+        create_plugin('execute', config, state)
+    else:
+        logging.debug(f'Execution section does not exist in config\n{config}')

inex-launcher-2.2.13/inex/helpers.py

@@ -0,0 +1,134 @@
+import os
+import logging
+from pathlib import Path
+from omegaconf import OmegaConf
+from inex.utils.configure import load_config, create_plugin, bind_plugins
+
+
+def none():
+    return None
+
+
+def zero():
+    return 0
+
+
+def one():
+    return 1
+
+
+def true():
+    return True
+
+
+def false():
+    return False
+
+
+def assign(value):
+    return value
+
+
+def read_text(path):
+    path = Path(path)
+    assert path.is_file(), f'File {path} does not exist'
+    return path.read_text()
+
+
+def evaluate(
+        expression,
+        a=None, b=None, c=None, d=None,
+        x=None, y=None, z=None, w=None,
+        i=None, j=None, k=None,
+        m=None, n=None,
+):
+    return eval(expression)
+
+
+def attribute(modname, attname):
+    logging.debug(f'Loading module {modname}')
+    module = __import__(modname, fromlist=[''])
+    assert hasattr(module, attname), f'Module {modname} does not have attribute {attname}'
+    return getattr(module, attname)
+
+
+def posit_args(modname, attname, arguments):
+    if isinstance(modname, str):
+        logging.debug(f'Loading module {modname}')
+        module = __import__(modname, fromlist=[''])
+    else:
+        module = modname
+    assert hasattr(module, attname), f'Module {modname} does not have attribute {attname}'
+    return getattr(module, attname)(*arguments)
+
+
+_cache_ = dict()
+
+
+def _import_(plugin, config, depends=None, ignore=None, **kwargs):
+    path = os.path.abspath(config)
+    assert os.path.isfile(path), f'File {path} does not exist'
+    plugin = plugin.strip()
+    assert len(plugin) > 0, 'Empty plugin or attribute name'
+    parts = plugin.split('.')
+    if len(parts) == 1:
+        normal_name = plugin
+        cache_name = 'plugins.' + plugin
+    else:
+        assert len(parts) == 2, f'Wrong plugin or attribute name: "{plugin}"'
+        if parts[0] == 'plugins':
+            normal_name = parts[1]
+            cache_name = plugin
+        else:
+            normal_name = parts[0]
+            cache_name = plugin
+    if path in _cache_:
+        logging.debug('Getting state dictionary from cache')
+        state = _cache_[path]
+    else:
+        logging.debug('Creating new cache entry for state dictionary')
+        state = dict()
+        _cache_[path] = state
+    if cache_name in state:
+        return state[cache_name]
+    logging.debug(f'Loading config from {path}')
+    config = load_config(path)
+    logging.debug(f'Merging config with options\n{kwargs}')
+    config = OmegaConf.merge(config, kwargs)
+    logging.debug(f'Resolving config\n{config}')
+    config = OmegaConf.to_container(config, resolve=True, throw_on_missing=True)
+    logging.debug(f'Building plugin dependencies in config\n{config}')
+    bind_plugins(config)
+    logging.debug(f'Final config:\n{config}')
+    assert 'plugins' in config, f'Failed to find "plugins" list in config\n{config}'
+    plugins = config['plugins']
+    assert isinstance(plugins, list), f'Wrong type of "plugins" {type(plugins)} (must be list)'
+    assert normal_name in plugins, f'Failed to find plugin "{normal_name}" in the list of plugins in config\n{config}'
+    assert normal_name in config, f'Failed to find plugin "{normal_name}" in config\n{config}'
+    options = config[normal_name]
+    depends = {normal_name} if depends is None else set(depends) | {normal_name}
+    if 'depends' in options:
+        depends |= set(options['depends'])
+    if ignore is not None:
+        ignore = set(ignore)
+    value = None
+    for name in plugins:
+        if name not in depends:
+            continue
+        elif (ignore is not None) and (name in ignore):
+            continue
+        cname = f'plugins.{name}'
+        if cname in state:
+            value = state[cname]
+        else:
+            create_plugin(name, config, state)
+        if name == normal_name:
+            assert cache_name in state, f'Failed to find created plugin {name} in the state dictionary'
+            value = state[cache_name]
+            break
+    return value
+
+
+def show(**kwargs):
+    for key, value in kwargs.items():
+        print(f'\n{key}\n  type: {type(value)}\n  value: {value}')

inex-launcher-2.2.13/inex/inex.py

@@ -0,0 +1,109 @@
+import re
+import sys
+import logging
+import argparse
+from pathlib import Path
+from omegaconf import OmegaConf
+from datetime import datetime, timedelta
+from inex.utils.configure import configure_logging, load_config, bind_plugins
+from inex.version import __version__
+from inex.engine import execute
+
+
+def start(log_level, log_path, sys_paths, merge, update, config_path, stop_after=None, final_path=None):
+    begin_time = datetime.now()
+
+    configure_logging(log_level=log_level, log_path=log_path)
+
+    if (sys_paths is not None) and (len(sys_paths) > 0):
+        paths = re.split(r'[:;,|]', sys_paths)
+        for path in paths:
+            if path not in sys.path:
+                logging.debug(f'Adding {path} to sys.path')
+                sys.path.append(path)
+
+    logging.debug('Reading configuration')
+    config = load_config(config_path)
+    if merge is not None:
+        logging.debug(f'Merging configs {merge}')
+        configs = [config]
+        for path in merge:
+            configs.append(load_config(path))
+        config = OmegaConf.merge(*configs)
+    dot_list = list()
+    if update is not None:
+        dot_list += update
+    if len(dot_list) > 0:
+        logging.debug(f'Applying updates {dot_list}')
+        options = OmegaConf.from_dotlist(dot_list)
+        config = OmegaConf.merge(config, options)
+    logging.debug(f'Resolving config\n{config}')
+    config = OmegaConf.to_container(config, resolve=True, throw_on_missing=True)
+    logging.debug(f'Building plugin dependencies in config\n{config}')
+    bind_plugins(config)
+    logging.debug(f'Final config:\n{OmegaConf.to_yaml(OmegaConf.create(config))}')
+
+    if final_path is not None:
+        logging.debug(f'Writing final config to {final_path}')
+        final_path = Path(final_path)
+        parent = final_path.parent
+        if not parent.exists():
+            logging.debug(f'Creating directory {parent}')
+            parent.mkdir(parents=True, exist_ok=True)
+        with final_path.open('wt', encoding='utf-8') as stream:
+            print(OmegaConf.to_yaml(config), file=stream)
+
+    state = dict()
+    state['command_line'] = ' '.join(sys.argv)
+    logging.debug(state['command_line'])
+    state['config_path'] = config_path
+
+    logging.debug('Starting InEx execution')
+    execute(config=config, state=state, stop_after=stop_after)
+
+    end_time = datetime.now()
+    duration = timedelta(seconds=round((end_time - begin_time).total_seconds()))
+    print(f'\n# Started at {begin_time.date()} {begin_time.strftime("%H:%M:%S")}', file=sys.stderr)
+    print(f'# Finished at {end_time.date()} {end_time.strftime("%H:%M:%S")}', file=sys.stderr)
+    print(f'# Total time {duration} ({duration.total_seconds():.0f} sec)', file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='InEx: Initialize & Execute')
+    parser.add_argument('--version', '-v', action='version', version='%(prog)s {version}'.format(version=__version__))
+    parser.add_argument('--log-level', '-l', type=str, default='WARNING', help='set the root logger level')
+    parser.add_argument('--log-path', '-g', type=str, help='path to the log-file')
+    parser.add_argument('--sys-paths', '-s', type=str, help='paths to add to the list of system paths (sys.path)')
+    parser.add_argument(
+        '--merge', '-m',
+        type=str,
+        action='append',
+        help='path to the configuration file to be merged with the main config'
+    )
+    parser.add_argument(
+        '--update', '-u',
+        type=str,
+        action='append',
+        help='update or set value for some parameter (use "dot" notation: "key1.key2=value")')
+    parser.add_argument('--stop-after', '-a', type=str, help='stop execution after the specified plugin is initialized')
+    parser.add_argument('--final-path', '-f', type=str, help='write final config to the specified file')
+    parser.add_argument(
+        'config_path',
+        type=str,
+        help='path to the configuration file (in YAML or JSON) or string with configuration in YAML'
+    )
+    args = parser.parse_args()
+    start(
+        log_level=args.log_level,
+        log_path=args.log_path,
+        sys_paths=args.sys_paths,
+        merge=args.merge,
+        update=args.update,
+        config_path=args.config_path,
+        stop_after=args.stop_after,
+        final_path=args.final_path,
+    )
+
+
+if __name__ == '__main__':
+    main()

inex-launcher-2.2.13/inex/utils/configure.py

@@ -0,0 +1,238 @@
+import os
+import re
+import sys
+import logging
+import logging.config
+import networkx as nx
+from omegaconf import OmegaConf
+
+
+def configure_logging(log_level, log_path=None):
+    handlers = {
+        "inex_out": {
+            "class": "logging.StreamHandler",
+            "formatter": "inex_basic",
+            "stream": "ext://sys.stderr",
+        }
+    }
+    if log_path is not None:
+        handlers['inex_file'] = {
+            "class": "logging.FileHandler",
+            "formatter": "inex_basic",
+            "filename": log_path,
+            "mode": "w",
+            "encoding": "utf-8"
+        }
+    CONFIG = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {"inex_basic": {"format": '%(asctime)s %(name)s %(pathname)s:%(lineno)d - %(levelname)s - %(message)s'}},
+        "handlers": handlers,
+        "loggers": {"inex": {"handlers": handlers.keys(), "level": log_level}},
+        "root": {"handlers": handlers.keys(), "level": log_level}
+    }
+    logging.config.dictConfig(CONFIG)
+
+
+def get_inex_logger():
+    return logging.getLogger('inex')
+
+
+def load_config(conf_path):
+    assert conf_path is not None, 'Failed to load config: config path is None'
+    if isinstance(conf_path, dict):
+        config = OmegaConf.create(conf_path)
+    elif conf_path == '-':
+        config = OmegaConf.create(sys.stdin.read())
+    else:
+        assert len(conf_path) > 0, 'Failed to load config: config path is empty string'
+        if os.path.isfile(conf_path):
+            config = OmegaConf.load(conf_path)
+        else:
+            config = OmegaConf.create(conf_path)
+    return config
+
+
+def add_depends(graph, plugin, module, plugins):
+    if isinstance(module, str):
+        module = module.split('^')[0]
+        parts = module.split('.')
+        if len(parts) == 2:
+            if parts[0] == 'plugins':
+                if parts[1] in plugins:
+                    graph.add_edge(plugin, parts[1])
+            else:
+                if parts[0] in plugins:
+                    graph.add_edge(plugin, parts[0])
+    elif isinstance(module, list):
+        for item in module:
+            add_depends(graph=graph, plugin=plugin, module=item, plugins=plugins)
+    elif isinstance(module, dict):
+        for item in module.values():
+            add_depends(graph=graph, plugin=plugin, module=item, plugins=plugins)
+
+
+def bind_plugins(config):
+    if 'plugins' in config:
+        plugins = set(config['plugins'])
+        if 'execute' in config:
+            plugins.add('execute')
+    else:
+        plugins = set()
+        for key, opts in config.items():
+            if isinstance(opts, dict) and (('module' in opts) or ('method' in opts)):
+                plugins.add(key)
+    graph = nx.DiGraph()
+    for plugin in plugins:
+        graph.add_node(plugin)
+    for plugin in plugins:
+        opts = config[plugin]
+        module = opts['module'] if 'module' in opts else opts['method']
+        if module.startswith('plugins.'):
+            module = module.split('/')[0]
+            module = module.split('^')[0]
+            parts = module.split('.')
+            assert len(parts) == 2, f'Wrong plugin reference format {module} (must be in the form plugins.<name>)'
+            graph.add_edge(plugin, parts[1])
+        if 'imports' in opts:
+            imports = opts['imports']
+            for module in imports.values():
+                add_depends(graph=graph, plugin=plugin, module=module, plugins=plugins)
+        if 'depends' in opts:
+            deps = opts['depends']
+            assert isinstance(deps, list), f'Wrong plugin dependencies type {type(deps)} (must be a list)'
+            for item in deps:
+                graph.add_edge(plugin, item)
+    for plugin in plugins:
+        nodes = nx.descendants(graph, plugin)
+        if len(nodes) > 0:
+            opts = config[plugin]
+            deps = set(opts['depends']) if 'depends' in opts else set()
+            deps.update(nodes)
+            opts['depends'] = list(deps)
+
+
+def optional_int(value):
+    return value if re.match(r'^-?\d+$', value) is None else int(value)
+
+
+def resolve_option(option, state):
+    if isinstance(option, list):
+        for i, value in enumerate(option):
+            if isinstance(value, list) or isinstance(value, dict):
+                option[i] = resolve_option(value, state)
+            elif isinstance(value, str) and (value in state):
+                option[i] = state[value]
+    elif isinstance(option, dict):
+        for key, value in option.items():
+            if isinstance(value, list) or isinstance(value, dict):
+                option[key] = resolve_option(value, state)
+            elif isinstance(value, str) and (value in state):
+                option[key] = state[value]
+    elif isinstance(option, str) and (option in state):
+        option = state[option]
+    return option
+
+
+def create_plugin(name, config, state):
+    assert name in config, f'Failed find module {name} in config\n{config}'
+    params = config[name]
+    if name == 'execute':
+        assert 'method' in params, f'Failed to find "method" in execute section\n{params}'
+        modname = params['method']
+    else:
+        assert 'module' in params, f'Failed find "module" for plugin {name} in section\n{params}'
+        modname = params['module']
+    parts = modname.split('^')
+    if len(parts) == 1:
+        index = None
+    else:
+        assert len(parts) == 2, f'Wrong module index format ({parts=}) for plugin {name} in config\n{config}'
+        modname = parts[0]
+        index = parts[1]
+    parts = modname.split('/')
+    if len(parts) > 1:
+        assert len(parts) == 2, f'Wrong module name format ({parts=}) for plugin {name} in config\n{config}'
+        modname = parts[0]
+        classname = parts[1]
+    else:
+        classname = None
+    options = params['options'] if 'options' in params else dict()
+    if 'imports' in params:
+        imports = params['imports']
+        for key, value in imports.items():
+            if key == '__kwargs__':
+                options.update(resolve_option(value, state))
+            elif isinstance(value, str):
+                parts = value.split('^')
+                if len(parts) == 1:
+                    idx = None
+                else:
+                    assert len(parts) == 2, \
+                        f'Wrong importing value index format ({parts=}) for plugin {name} in config\n{config}'
+                    value = parts[0]
+                    idx = parts[1]
+                assert value in state, f'Failed to resolve importing value {value} for plugin {name} in config\n{config}'
+                value = state[value]
+                if idx is not None:
+                    assert hasattr(value, '__getitem__'), \
+                        f'Imported class {type(value)} does not have attribute ' \
+                        f'__getitem__ for plugin {name} in config\n{config}'
+                    value = value[optional_int(idx)]
+                options[key] = value
+            else:
+                options[key] = resolve_option(value, state)
+    if (
+            ('__mute__' in config)
+            and ((name in config['__mute__']) or ('__all__' in config['__mute__']))
+            and (('__unmute__' not in config) or (name not in config['__unmute__']))
+    ):
+        logging.debug(f'Creating plugin {name}')
+    else:
+        logging.debug(f'Creating plugin {name} from config\n{options}')
+    if modname.startswith('plugins.') and (modname in state):
+        plugin = state[modname]
+        if classname is None:
+            plugin = plugin(**options)
+        else:
+            assert hasattr(plugin, classname), \
+                f'Plugin {modname} does not have attribute {classname} for plugin {name} in config\n{config}'
+            method = getattr(plugin, classname)
+            plugin = method(**options)
+    else:
+        logging.debug(f'Loading module {modname}')
+        module = __import__(modname, fromlist=[''])
+        if classname is None:
+            logging.debug(f'Creating plugin {name} using class factory create() from module {modname}')
+            plugin = module.create(options)
+        else:
+            logging.debug(f'Creating plugin {name} with class name {classname} from module {modname}')
+            parts = classname.split('.')
+            if len(parts) == 1:
+                assert hasattr(module, classname), \
+                    f'Module {modname} does not have class {classname} for plugin {name} in config\n{config}'
+                classtype = getattr(module, classname)
+                plugin = classtype(**options)
+            else:
+                classname = parts[0]
+                attribute = parts[1]
+                assert hasattr(module, classname), \
+                    f'Module {modname} does not have class {classname} for plugin {name} in config\n{config}'
+                classtype = getattr(module, classname)
+                assert hasattr(classtype, attribute), \
+                    f'Class {classname} does not have attribute {attribute} for plugin {name} in config\n{config}'
+                method = getattr(classtype, attribute)
+                plugin = method(**options)
+    if index is not None:
+        assert hasattr(plugin, '__getitem__'), \
+            f'Class {type(plugin)} does not have attribute __getitem__ for plugin {name} in config\n{config}'
+        plugin = plugin[optional_int(index)]
+    if 'exports' in params:
+        for attr in params['exports']:
+            if hasattr(plugin, 'export'):
+                state[f'{name}.{attr}'] = plugin.export(attr)
+            elif hasattr(plugin, attr):
+                state[f'{name}.{attr}'] = getattr(plugin, attr)
+            else:
+                assert False, f'Plugin {type(plugin)} does not have attribute {attr} for plugin {name} in config\n{config}'
+    state[f'plugins.{name}'] = plugin

inex-launcher-2.2.13/inex/version.py

@@ -0,0 +1 @@
+__version__ = '2.2.13.8903b'

inex-launcher-2.2.13/inex/version.txt

@@ -0,0 +1 @@
+2.2.13

inex-launcher-2.2.13/inex_launcher.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: inex-launcher
+Version: 2.2.13
+Summary: InEx is a lightweight highly configurable Python launcher based on microkernel architecture
+Home-page: https://github.com/speechpro/inex
+Author: Yuri Khokhlov
+Author-email: khokhlov@speechpro.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/speechpro/inex/issues
+Keywords: speechpro inex command-line configuration yaml
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# InEx
+## Lightweight highly configurable Python launcher based on microkernel architecture

inex-launcher-2.2.13/inex_launcher.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+inex/__init__.py
+inex/engine.py
+inex/helpers.py
+inex/inex.py
+inex/version.py
+inex/version.txt
+inex/utils/__init__.py
+inex/utils/configure.py
+inex_launcher.egg-info/PKG-INFO
+inex_launcher.egg-info/SOURCES.txt
+inex_launcher.egg-info/dependency_links.txt
+inex_launcher.egg-info/entry_points.txt
+inex_launcher.egg-info/requires.txt
+inex_launcher.egg-info/top_level.txt
+tests/test_engine.py

inex-launcher-2.2.13/inex_launcher.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

inex-launcher-2.2.13/inex_launcher.egg-info/entry_points.txt

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

inex-launcher-2.2.13/inex_launcher.egg-info/requires.txt

@@ -0,0 +1,4 @@
+omegaconf
+networkx
+pytest
+tox

inex-launcher-2.2.13/inex_launcher.egg-info/top_level.txt

@@ -0,0 +1 @@
+inex

inex-launcher-2.2.13/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]

inex-launcher-2.2.13/requirements.txt

@@ -0,0 +1,4 @@
+omegaconf
+networkx
+pytest
+tox

inex-launcher-2.2.13/setup.cfg

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

inex-launcher-2.2.13/setup.py

@@ -0,0 +1,70 @@
+import os
+import subprocess
+from setuptools import find_packages, setup
+
+
+def get_version():
+    path = os.path.abspath(os.path.join('inex', 'version.txt'))
+    assert os.path.isfile(path), f'File {path} does not exist'
+    with open(path) as stream:
+        version = stream.read().strip()
+    return version
+
+
+def get_version_sha():
+    try:
+        sha = subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode('ascii').strip()
+        sha = sha[:5]
+    except Exception:
+        sha = 'failed-to-get-sha'
+    return f'{get_version()}.{sha}'
+
+
+path = os.path.join('inex', 'version.py')
+with open(path, 'wt') as stream:
+    print(f"__version__ = '{get_version_sha()}'", file=stream)
+
+
+with open('README.md', encoding='utf-8') as stream:
+    long_description = stream.read()
+
+
+setup(
+    name='inex-launcher',
+    version=get_version(),
+    python_requires='>=3.6',
+    author='Yuri Khokhlov',
+    author_email='khokhlov@speechpro.com',
+    description='InEx is a lightweight highly configurable Python launcher based on microkernel architecture',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    license='MIT',
+    url='https://github.com/speechpro/inex',
+    project_urls={
+        'Bug Tracker': 'https://github.com/speechpro/inex/issues',
+    },
+    classifiers=[
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Operating System :: POSIX :: Linux',
+        'Operating System :: MacOS',
+        'Operating System :: Microsoft :: Windows',
+    ],
+    install_requires=[
+        'omegaconf',
+        'networkx',
+        'pytest',
+        'tox',
+    ],
+    packages=find_packages(exclude=['tests']),
+    include_package_data=True,
+    keywords='speechpro inex command-line configuration yaml',
+    entry_points={
+        'console_scripts': [
+            'inex = inex.inex:main',
+        ]
+    },
+)

inex-launcher-2.2.13/tests/test_engine.py

@@ -0,0 +1,10 @@
+import unittest
+
+
+class InexEngine(unittest.TestCase):
+    def test_base(self):
+        pass
+
+
+if __name__ == '__main__':
+    unittest.main()