uwsgiconf 2.0.0__py3-none-any.whl

uwsgiconf/__init__.py

@@ -0,0 +1 @@
+VERSION = '2.0.0'

uwsgiconf/base.py

@@ -0,0 +1,298 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Union
+
+from .utils import listify
+
+if TYPE_CHECKING:
+    from .config import Section
+
+
+class Options:
+    """Options descriptor. Allows option."""
+
+    def __init__(self, opt_type: type['OptionsGroup']):
+        """
+        :param opt_type:
+
+        """
+        self.opt_type = opt_type
+
+    def __get__(self, section: 'Section', section_cls: type['Section']) -> Union['OptionsGroup', type['OptionsGroup']]:
+        """
+
+        :param section:
+        :param section_cls:
+
+        """
+        key = self.opt_type.__name__
+
+        try:
+            options_obj = section._options_objects.get(key)
+
+        except AttributeError:
+            # Allow easy access to option group static params:
+            # Section.networking.socket_types.DEFAULT
+            return self.opt_type
+
+        if not options_obj:
+            options_obj = self.opt_type(_section=section)
+
+        section._options_objects[key] = options_obj
+
+        return options_obj
+
+
+class OptionKey:
+
+    __slots__ = ['key']
+
+    def __init__(self, key: str):
+        self.key = key
+
+    def swap(self, new_key: Any):
+
+        if new_key:
+            self.key = f'{new_key}'
+
+    def __str__(self):
+        return self.key
+
+    def __eq__(self, obj):
+        return self.key == obj
+
+    def __hash__(self):
+        return hash(self.key)
+
+
+class OptionsGroup:
+    """Introduces group of options.
+
+    Basic group parameters may be passed to initializer
+    or `set_basic_params` method.
+
+    Usually methods setting parameters are named `set_***_params`.
+
+    Methods ending with `_params` return section object and may be chained.
+
+    """
+    _section: 'Section' = None
+    """Section this option group belongs to."""
+
+    plugin: bool | str = False
+    """Indication this option group belongs to a plugin."""
+
+    name: str = ''
+    """Name to represent the group."""
+
+    def __init__(self, *args, **kwargs):
+        if self._section is None:
+            self._section = kwargs.pop('_section', None)
+
+        self.set_basic_params(*args, **kwargs)
+
+    def _get_name(self, *args, **kwargs) -> str:
+        return self.name
+
+    def __str__(self):
+        return self._get_name()
+
+    def __call__(self, *args, **kwargs) -> 'Section':
+        """The call is translated into ``set_basic_params``` call.
+
+        This approach is much more convenient yet IDE most probably won't
+        give you a hint on what arguments are accepted.
+
+        :param args:
+        :param kwargs:
+
+        """
+        return self.set_basic_params(*args, **kwargs)
+
+    def __eq__(self, obj):
+        return f'{self}' == obj
+
+    def __hash__(self):
+        return hash(f'{self}')
+
+    def set_basic_params(self, *args, **kwargs) -> 'Section':
+        return self._section
+
+    def _set(
+            self,
+            key: str,
+            value: Any,
+            *,
+            condition: bool | str | None = True,
+            cast: Callable | None = None,
+            multi: bool = False,
+            plugin: str | None = None,
+            priority: int | None = None
+    ):
+        """
+
+        :param key: Option name
+
+        :param value: Option value. Can be a lis if ``multi``.
+
+        :param condition: Condition to test whether this option should be added to section.
+            * True - test value is not None.
+
+        :param cast: Value type caster.
+            * bool - treat value as a flag
+
+        :param multi: Indicate that many options can use the same name.
+
+        :param plugin: Plugin this option exposed by. Activated automatically.
+
+        :param priority: Option priority indicator. Options with lower numbers will come first.
+
+        """
+        key = OptionKey(key)
+
+        def set_plugin(plugin):
+            self._section.set_plugins_params(plugins=plugin)
+
+        def handle_priority(value, *, use_list=False):
+
+            if priority is not None:
+                # Restructure options.
+                opts_copy = opts.copy()
+                opts.clear()
+
+                existing_value = opts_copy.pop(key, [])
+
+                if use_list:
+                    existing_value.extend(value)
+                    value = existing_value
+
+                for pos, (item_key, item_val) in enumerate(opts_copy.items()):
+
+                    if priority == pos:
+                        opts[key] = value
+
+                    opts[item_key] = item_val
+
+                return True
+
+        def handle_plugin_required(val):
+
+            if isinstance(val, ParametrizedValue):
+                key.swap(val.opt_key or key)  # todo
+
+                if val.plugin:
+                    # Automatic plugin activation.
+                    set_plugin(val.plugin)
+
+                if val._opts:
+                    opts.update(val._opts)
+
+        if condition is True:
+            condition = value is not None
+
+        if condition is None or condition:
+
+            opts = self._section._opts
+
+            if cast is bool:
+                if value:
+                    value = 'true'
+
+                else:
+                    try:
+                        del opts[key]
+                    except KeyError:
+                        pass
+
+                    return
+
+            if self.plugin is True:
+                # Automatic plugin activation when option from it is used.
+                set_plugin(self)
+
+            if plugin:
+                set_plugin(plugin)
+
+            if isinstance(value, tuple):  # Tuple - expect ParametrizedValue.
+                list(map(handle_plugin_required, value))
+                value = ' '.join(map(str, value))
+
+            if multi:
+                values = []
+
+                # First activate plugin if required.
+                for value_ in listify(value):
+                    handle_plugin_required(value_)
+                    values.append(value_)
+
+                # Second: list in new option.
+                if not handle_priority(values, use_list=True):
+                    opts.setdefault(key, []).extend(values)
+
+            else:
+                handle_plugin_required(value)
+
+                if not handle_priority(value):
+                    opts[key] = value
+
+    def _make_section_like(self):
+        self._section = type('SectionLike', (object,), {'_opts': {}})
+
+    def _contribute_to_opts(self, target):
+        target_section = target._section
+        target_section._opts.update(self._section._opts)
+
+
+class ParametrizedValue(OptionsGroup):
+    """Represents parametrized option value."""
+
+    alias: str = ''
+    """Alias to address this value."""
+
+    args_joiner: str = ' '
+    """Symbol to join arguments with."""
+
+    name_separator: str = ':'
+    """Separator to add after name portion."""
+
+    name_separator_strip: bool = False
+    """Strip leading and trailing name separator from the result."""
+
+    opt_key: str | None = None
+    """Allows swapping default option key with custom value."""
+
+    def __init__(self, *args):
+        self.args = list(args)
+        self._opts = {}
+        super().__init__(_section=self)
+
+    def __str__(self):
+        args = [f'{arg}' for arg in self.args if arg is not None]
+
+        result = ''
+
+        if self.opt_key is None:
+            result += self._get_name() + self.name_separator
+
+        result += self.args_joiner.join(args)
+
+        if self.alias:
+            result = f'{self.alias} {result}'
+
+        result = result.strip()
+
+        if self.name_separator_strip:
+            result = result.strip(self.name_separator)
+
+        return result
+
+
+class TemplatedValue(ParametrizedValue):
+
+    tpl: str = '%s'
+
+    def __init__(self, name: str):
+        self._name = name
+        super().__init__()
+
+    def __str__(self):
+        return self.tpl % self._name

uwsgiconf/cli.py

@@ -0,0 +1,105 @@
+import sys
+from contextlib import contextmanager
+
+import click
+
+from uwsgiconf import VERSION
+from uwsgiconf.exceptions import ConfigurationError
+from uwsgiconf.sysinit import TYPE_SYSTEMD, TYPES, get_config
+from uwsgiconf.utils import ConfModule, UwsgiRunner
+
+
+@contextmanager
+def errorprint():
+    """Print out descriptions from ConfigurationError."""
+    try:
+        yield
+
+    except ConfigurationError as e:
+        click.secho(f'{e}', err=True, fg='red')
+        sys.exit(1)
+
+
+@click.group()
+@click.version_option(version='.'.join(map(str, VERSION)))
+def base():
+    """uwsgiconf command line utility.
+
+    Tools to facilitate uWSGI configuration.
+
+    """
+
+arg_conf = click.argument(
+    'conf', type=click.Path(exists=True, dir_okay=False), default=ConfModule.default_name)
+
+
+@base.command()
+@arg_conf
+@click.option('--only', help='Configuration alias from module to run uWSGI with.')
+def run(conf, only):
+    """Runs uWSGI passing to it using the default or another `uwsgiconf` configuration module.
+
+    """
+    with errorprint():
+        config = ConfModule(conf)
+        spawned = config.spawn_uwsgi(only=only)
+
+        for alias, pid in spawned:
+            click.secho(f"Spawned uWSGI for configuration aliased '{alias}'. PID {pid}", fg='green')
+
+
+@base.command()
+@arg_conf
+def compile(conf):
+    """Compiles classic uWSGI configuration file using the default
+    or given `uwsgiconf` configuration module.
+
+    """
+    with errorprint():
+        config = ConfModule(conf)
+        for conf in config.configurations:
+            conf.format(do_print=True)
+
+
+@base.command()
+@click.argument('systype', type=click.Choice(TYPES), default=TYPE_SYSTEMD)
+@arg_conf
+@click.option('--project', help='Project name to use as service name.')
+def sysinit(systype, conf, project):
+    """Outputs configuration for system initialization subsystem."""
+
+    click.secho(get_config(
+        systype,
+        conf=ConfModule(conf).configurations[0],
+        conf_path=conf,
+        project_name=project,
+    ))
+
+
+@base.command()
+def probe_plugins():
+    """Runs uWSGI to determine what plugins are available and prints them out.
+
+    Generic plugins come first then after blank line follow request plugins.
+
+    """
+    plugins = UwsgiRunner().get_plugins()
+
+    for plugin in sorted(plugins.generic):
+        click.secho(plugin)
+
+    click.secho('')
+
+    for plugin in sorted(plugins.request):
+        click.secho(plugin)
+
+
+def main():
+    """
+    CLI entry point
+    """
+    base(obj={})
+
+
+if __name__ == '__main__':
+    main()