bckohan / enum-properties Goto Github PK

Base python library does not expose a public interface to decompose a Flag enumeration into its activated flags. Provide a property that does this - may wrap enum internal code that does this so long as CI tests are sufficient to catch breaking changes in future.

Support inheritance from a dataclass and EnumProperties.

https://docs.python.org/3.12/howto/enum.html#enum-dataclass-support

Documentation should include rationale for why the enum-properties approach is still most likely superior for many use cases.

/Users/bckohan/Development/enum-properties/enum_properties/init.py:370: DeprecationWarning: In 3.13 classes created inside an enum will not become a member. Use the member decorator to keep the current behavior.

Add necessary expansions to DecomposeMixin.

String coercion None <-> 'None' should be disabled. This behavior is confusing:

class EnumWithNones(EnumProperties, s('prop')):
    
    VALUE1 = 1, 'None'
    VALUE2 = 2, 'label'

EnumWithNones(None) == EnumWithNotes.VALUE1

i.e. override eq so that symmetric properties compare as equal.

There are some deficiencies in how properties are stored and accessed on the member values. This access should be changed to direct attribute access instead of going through a member to value dictionary lookup. Will have to find a way to assign properties with None values to unlisted flag values.

This library is lightweight enough, just move everything into init

Namely enum_properties -> properties.

This might be a breaking change, but enum_properties attribute was never documented, so this is going in 1.4

I.e. if and how exactly are strings normalized? NKCD?

https://tonsky.me/blog/unicode/

Since Flag enumerations accept iterables of flag values on init - should be able to do something like this: Perm([]) == Perm(0).

Python Enums are hash equivalent to their values, so you can do things like this:

from enum import IntEnum

class MyEnum(IntEnum):
    VAL1 = 1
    VAL2 = 2
    VAL3 = 3

assert {1: '1', 2: '2', 3: '3'}[MyEnum.VAL2] == '2'  # this passes

However when using enum properties this does not work:

from enum import IntEnumProperties

class MyEnum(IntEnumProperties):
    VAL1 = 1
    VAL2 = 2
    VAL3 = 3

assert {1: '1', 2: '2', 3: '3'}[MyEnum.VAL2] == '2'  # this fails

This declaration results in a TypeError:

        class Perm(FlagProperties, s('label')):

            R = auto(), 'read'
            W = auto(), 'write'
            RW = R | W, 'read/write'
            X = auto(), 'execute'
            RWX = R | W | X, 'all'

E TypeError: '>' not supported between instances of 'tuple' and 'int'

The typing in this package is extremely dynamic so its unclear if the current state of static type checking in python is worth the trouble - but once it is it should be added.

Print statement was accidentally released - remove it.

Override of eq and lack of hash override made SymmetricMixin objects unhashable.

LICENSE is installed into the wrong location.

E.g.:

class MyEnum(EnumProperties):

    V1 = None
    V2 = 5
    V3 = 'label'
    V4 = date(year=1970, month=1, day=1)

Symmetric fields that sometimes have none values should be able to switch off symmetrical mapping to None. Current behavior is to map the values if match on none, but a more reasonable default might be to turn off none mapping and require users to turn it back on.

For instance:

class MyEnum(EnumProperties, s('label', match_none=False)):
    
    VAL1 = 1, 'label'
    VAL2 = 2, None

MyEnum(None)  # raises value error

Should be able to do something like:

class MyEnum(EnumProperties):

    VAL1 = 1
    VAL2 = 2
    VAL3 = 3

   @specialize(VAL1, VAL2)
   def method(self):
        ...

This:

FlagEnum([FlagEnum.VAL1, FlagEnum.VAL2])

Should be equivalent to:

FlagEnum.VAL1 | FlagEnum.VAL2

For convenience.

This should work:

class StrictFlag(IntFlagProperties, p('label'), boundary=STRICT):
    RED = auto(), 'red'
    GREEN = auto(), 'green'
    BLUE = auto(), 'blue'

Adding a nested class to an enum that inherits from EnumProperties results in a ValueError when the declaration is interpreted.