ordered-str-enum 0.1.2

Enums which are ordered, by int value, and can be compared with both integers and strings.

A simple extension of IntEnum used to create ordered StrEnums.

What is an OrderedStrEnum?

Simply, OrderdStrEnums are like StrEnum but have an integer value and their string "value" is equal to their name. This means that OrderedStrEnum are ordered (by their integer values) and can be compared with both integers and strings.

For example, if we have an OrderedStrEnum Foo and we want it to contain the strings 'One', 'Two', and 'Three' in order, we can achieve this as follows:

from ordered_str_enum import OrderedStrEnum

class Foo(OrderedStrEnum):
  One = 1
  Two = 2
  Three = 3

This now gives us the power to compare however we wish, even without case sensitivity

>>> Foo.One == 1
True
>>> Foo.One < 'three'
True
>>> Foo.One <= 'Two'
True
>>> Foo.One > 2
False

We can also get the Enum using the int value or string name

>>> Foo(1)
<Foo.One: 1>
>>> Foo('one')
<Foo.One: 1>
>>> Foo('ONE')
<Foo.One: 1>

It's that simple.

Installation

pip install ordered-str-enum

Then import

from ordered_str_enum import OrderedStrEnum

Check out the source code.

Intersecting OrderedStrEnum

What happens when two different inheritors of OrderedStrEnum intersect (share common entries)?

OrderedStrEnum inherits from IntEnum so they would be compared by their integer values. Though, considering this class intends to add string comparisons to the mix it could lead to confusion. For example if Foo.A is 1 but Bar.A is -1 the result may not be inherently obvious when comparing Foo.A with Bar.A. It would not be unlikely to expect Foo.A == Bar.A to return True since they both can be considered equivalent with the strings 'A' and 'a', but his is not the case as 1 != -1 and so you'd actually get False. This is the result when comparing the Enums as children of IntEnum.

To prevent this confusion, comparison between different children of OrderedStrEnum is disabled by default. Each inheriting class has an internal flag marking them as "strict". Comparison between different inheritors will raise a TypeError unless both have this flag set to False:

class Foo(OrderedStrEnum):
  A = 1

class Bar(OrderedStrEnum):
  A = 1

Foo.strict()
# True
Bar.strict()
# True

Foo.A == Bar.A
# raises TypeError

Both need to set strict to False

class Foo(OrderedStrEnum, strict=False):
  A = 1

class Bar(OrderedStrEnum, strict=False):
  A = 1

Foo.strict()
# False
Bar.strict()
# False
Foo.A == Bar.A
# True

Why does OrderedStrEnum exist?

I decided to make this reusable when creating Enums for the days of a week in another project. See the days of the week implementation: coming soon...