PythonRequirement

Complexity

Total Complexity

6

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	10	1
B	multiple()	0	25	5

from coalib.bears.requirements.PackageRequirement import PackageRequirement


class PythonRequirement(PackageRequirement):

    """
    This class is a subclass of ``PackageRequirement``, and helps specifying
    more requirements from ``pip``, without writing the name of the class
    multiple times.

    Alternatively, you should use the ``multiple`` method if you have more
    requirements from the same manager. This can receive both tuples of strings,
    in case you want a specific version, or a simple string, in case you want
    the latest version to be installed.

    This is the case where you would provide strings only, to install the
    latest version automatically:

    >>> REQUIREMENTS = PythonRequirement.multiple(
    ...                                         'coala_decorators','setuptools')

    And if you choose to mix them, specifying version for some and for some not:

    >>> REQUIREMENTS = PythonRequirement.multiple(
    ...                             'coala_decorators',('setuptools', '19.2'))

    In case you provide too many arguments into the tuple, an error will be
    raised:

    >>> REQUIREMENTS = PythonRequirement.multiple(
    ...                 'coala_decorators',('setuptools', '19.2', 'colorama'))
    Traceback (most recent call last):
    ...
    TypeError: The tuple must have 2 elements.

    The same would happen in case you provide something different than a string
    or a tuple:

    >>> x = [1, 2, 3, 4]
    >>> REQUIREMENTS = PythonRequirement.multiple(x)
    Traceback (most recent call last):
    ...
    TypeError: The arguments need to be tuples or strings.
    """

    def __init__(self, package, version=""):
        """
        Constructs a new PythonRequirement, using the PackageRequirement
        constructor.

        :param package: A string with the name of the package to be installed.
        :param version: A number that contains the version. Leave empty to
                        install latest.
        """
        PackageRequirement.__init__(self, 'pip', package, version)

    @classmethod
    def multiple(cls, *args):
        """
        Creates a tuple of multiple ``pip`` requirements, consisting of
        either tuples or strings.

        :param args: Either strings if the latest version is wanted, or tuples
                     of strings, where the strings consist of the package and
                     the version number (which is also a string).
        :return:     A tuple containing tuples (package names and versions) and
                     strings (package names only).
        """
        reqs = ()
        for requirement in args:
            if isinstance(requirement, str):
                reqs += (requirement,)
            elif isinstance(requirement, tuple):
                try:
                    name, version = requirement
                    reqs += (name, version)
                except ValueError:
                    raise TypeError('The tuple must have 2 elements.')
            else:
                raise TypeError('The arguments need to be tuples or strings.')
        return reqs