lagom.experimental.integrations.click

Complexity

Total Complexity

7

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

91.43%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	ClickIntegration.__init__()	0	8	1
A	ClickIO.echo()	0	3	1
A	ClickIO.__getattr__()	0	4	1
A	ClickIntegration.command()	0	20	1
A	ClickIntegration.__getattr__()	0	5	1
A	ClickIntegration.argument()	0	9	1
A	ClickIntegration.option()	0	9	1

"""
Integration layer for Click https://click.palletsprojects.com/
"""

from typing import Optional, List, Type, Callable

from click import utils, decorators
from click.core import BaseCommand

from lagom.interfaces import ExtendableContainer, WriteableContainer


class DecoratedCommand(BaseCommand):
    """
    Virtual class which is returned by the lagom wrapped click command
    decorator
    """

    plain_function: Callable


class ClickIO:
    """
    Provides an injectable hint for click IO if needed.
    """

    @staticmethod
    def echo(message=None, file=None, nl=True, err=False, color=None):
        utils.echo(message, file, nl, err, color)

    def __getattr__(self, item):
        import click

        return getattr(click, item)


class ClickIntegration:
    """
    Integration between a container and click. The ClickIntegration
    instance provides all the same decorators and functions as click.
    """

    _container: WriteableContainer

    def __init__(
        self,
        container: ExtendableContainer,
        execution_singletons: Optional[List[Type]] = None,
    ):
        self._container = container.clone()
        self._container[ClickIO] = ClickIO()

The variable ClickIO does not seem to be defined.

        self._execution_singletons = execution_singletons or []

    def command(
        self, name=None, cls=None, **attrs
    ) -> Callable[[Callable], DecoratedCommand]:
        """
        Proxies click.command but binds the function to lagom
        so that any arguments with lagom.injectable as a default will
        be injected by the container
        :param name:
        :param cls:
        :param attrs:
        :return:
        """

        def _decorator(f):
            bound_f = self._container.partial(f, shared=self._execution_singletons)
            command = decorators.command(name, cls, **attrs)(bound_f)
            setattr(command, "plain_function", bound_f)
            return command

        return _decorator

    @staticmethod
    def option(*param_decls, **attrs):
        """
        Proxies click.option
        :param param_decls:
        :param attrs:
        :return:
        """
        return decorators.option(*param_decls, **attrs)

    @staticmethod
    def argument(*param_decls, **attrs):
        """
        Proxies click.argument
        :param param_decls:
        :param attrs:
        :return:
        """
        return decorators.argument(*param_decls, **attrs)

    def __getattr__(self, item):
        # Any method not explicitly code just gets passed to click
        import click

        return getattr(click, item)