pocketutils.core.enums

Complexity

Total Complexity

27

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	CleverEnum.of()	0	10	3
A	FlagEnum.or_none()	0	10	2
A	FlagEnum._fix_lookup()	0	3	1
A	TrueFalseUnknown._fix_lookup()	0	4	1
A	DisjointEnum.__new__()	0	5	1
A	DisjointEnum.__str__()	0	2	1
A	FlagEnum._create_pseudo_member_()	0	6	1
A	CleverEnum._fix_lookup()	0	3	1
A	FlagEnum.__new__()	0	8	2
A	DisjointEnum.or_none()	0	10	2
A	DisjointEnum._fix_lookup()	0	3	1
A	CleverEnum._unmatched_type()	0	3	1
A	FlagEnum.of()	0	13	4
A	DisjointEnum.of()	0	8	2
A	DisjointEnum.__repr__()	0	2	1
A	FlagEnum.__str__()	0	2	1
A	FlagEnum.__repr__()	0	2	1
A	TrueFalseUnknown._unmatched_type()	0	3	1

import enum

Missing module docstring

import logging
from typing import AbstractSet, Optional, Union

from pocketutils.core.exceptions import XValueError

logger = logging.getLogger("pocketutils")


class DisjointEnum(enum.Enum):
    """
    An enum that does not have combinations.
    """

    @classmethod
    def _fix_lookup(cls, s: str) -> str:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return s

    @classmethod
    def or_none(cls, s: Union[str, __qualname__]) -> Optional[__qualname__]:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        """
        Returns a choice by name (or returns ``s`` itself).
        Returns ``None`` if the choice is not found.
        """
        try:
            return cls.of(s)
        except KeyError:
            return None

    @classmethod
    def of(cls, s: Union[str, __qualname__]) -> __qualname__:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Method name "of" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        """
        Returns a choice by name (or returns ``s`` itself).
        """
        if isinstance(s, cls):
            return s
        return cls[cls._fix_lookup(s)]

    def __new__(cls, *args, **kwargs):

The argument args seems to be unused.

The argument kwargs seems to be unused.

        value = len(cls.__members__) + 1
        obj = object.__new__(cls)
        obj._value_ = value
        return obj

    def __repr__(self):

__repr__ does not return str

        return self.name

    def __str__(self):

__str__ does not return str

        return self.name


class FlagEnum(enum.Flag):
    """
    A bit flag that behaves as a set, has a null set, and auto-sets values and names.

    Example:
        .. code-block::

            class Flavor(FlagEnum):
                none = ()
                bitter = ()
                sweet = ()
                sour = ()
                umami = ()
            bittersweet = Flavor.bitter | Flavor.sweet
            print(bittersweet.value)  # 1 + 2 == 3
            print(bittersweet.name)   # "bitter|sweet"

    .. important::
        The *first element* must always be the null set ("no flags")
        and should be named something like 'none', 'empty', or 'zero'
    """

    @classmethod
    def _fix_lookup(cls, s: str) -> str:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return s

    def __new__(cls, *args, **kwargs):

The argument args seems to be unused.

The argument kwargs seems to be unused.

        if len(cls.__members__) == 0:
            value = 0
        else:
            value = 2 ** (len(cls.__members__) - 1)
        obj = object.__new__(cls)
        obj._value_ = value
        return obj

    @classmethod
    def _create_pseudo_member_(cls, value):
        value = super()._create_pseudo_member_(value)
        members, _ = enum._decompose(cls, value)

It seems like _decompose was declared protected and should not be accessed from this context.

        value._name_ = "|".join([m.name for m in members])

It seems like _name_ was declared protected and should not be accessed from this context.

        return value

    @classmethod
    def or_none(cls, s: Union[str, __qualname__]) -> Optional[__qualname__]:

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        """
        Returns a choice by name (or returns ``s`` itself).
        Returns ``None`` if the choice is not found.
        """
        try:
            return cls.of(s)
        except KeyError:
            return None

    @classmethod
    def of(cls, s: Union[str, __qualname__, AbstractSet[Union[str, __qualname__]]]) -> __qualname__:

Method name "of" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Argument name "s" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        """
        Returns a choice by name (or ``s`` itself), or a set of those.
        """
        if isinstance(s, cls):
            return s
        if isinstance(s, str):
            return cls[cls._fix_lookup_(s)]

Class 'FlagEnum' has no '_fix_lookup_' member; maybe '_fix_lookup'?

        z = cls[0]

Variable name "z" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        for m in s:

Variable name "m" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            z |= cls.of(m)

Variable name "z" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        return z

    def __repr__(self):

__repr__ does not return str

        return self.name

    def __str__(self):

__str__ does not return str

        return self.name


class TrueFalseUnknown(DisjointEnum):
    """
    A :class:`pocketutils.core.enums.DisjointEnum` of true, false, or unknown.
    """

    true = ()
    false = ()
    unknown = ()

    @classmethod
    def _unmatched_type(cls) -> Optional[__qualname__]:
        return cls.unknown

    @classmethod
    def _fix_lookup(cls, s: str) -> str:
        s = s.lower().strip()
        return dict(t="true", false="false").get(s, s)


class MultiTruth(FlagEnum):
    """
    A :class:`pocketutils.core.enums.FlagEnum` for true, false, true+false, and neither.
    """

    false = ()
    true = ()


class CleverEnum(DisjointEnum):
    """
    An enum with a ``.of`` method that finds values with limited string/value fixing.
    Replaces ``" "``, ``"-"``, and ``"."`` with ``_`` and ignores case in :meth:`of`.
    May support an "unmatched" type -- a fallback value when there is no match.
    This is similar to the simpler :class:`pocketutils.core.SmartEnum`.
    """

    @classmethod
    def of(cls, s: Union[str, __qualname__]) -> __qualname__:
        try:
            return super().of(s)
        except KeyError:
            unknown = cls._unmatched_type()
            logger.error(f"Value {s} not found. Using {unknown}")

Use lazy % formatting in logging functions

            if unknown is None:
                raise XValueError(f"Value {s} not found and unmatched_type is None")
            return unknown

    @classmethod
    def _unmatched_type(cls) -> Optional[__qualname__]:
        return None

    @classmethod
    def _fix_lookup(cls, s: str) -> str:
        return s.strip().replace(" ", "_").replace(".", "_").replace("-", "_").lower()


__all__ = ["TrueFalseUnknown", "DisjointEnum", "FlagEnum", "CleverEnum"]