Enumeración basada en cadenas en Python

Para encapsular una lista de estados que estoy usando enum módulo:

from enum import Enum

class MyEnum(Enum):
    state1='state1'
    state2 = 'state2'

state = MyEnum.state1
MyEnum['state1'] == state  # here it works
'state1' == state  # here it does not throw but returns False (fail!)

Sin embargo, el problema es que necesito usar sin problemas los valores como cadenas en muchos contextos en mi secuencia de comandos, como:

select_query1 = select(...).where(Process.status == str(MyEnum.state1))  # works but ugly

select_query2 = select(...).where(Process.status == MyEnum.state1)  # throws exeption

Cómo hacerlo evitando llamar a conversión de tipo adicional (str(state) arriba) o el valor subyacente (state.value)?

Parece que basta con heredar de str clase al mismo tiempo que Enum:

from enum import Enum

class MyEnum(str, Enum):
    state1 = 'state1'
    state2 = 'state2'

La parte complicada es que el orden de clases en la cadena de herencia es importante como esto:

class MyEnum(Enum, str):
    state1 = 'state1'
    state2 = 'state2'

lanza:

TypeError: new enumerations should be created as `EnumName([mixin_type, ...] [data_type,] enum_type)`

Con la clase correcta las siguientes operaciones en MyEnum estan bien:

print('This is the state value: ' + state)

Como nota al margen, parece que el truco de herencia especial no es necesario para cadenas formateadas que funcionan incluso para Enum solo herencia:

msg = f'This is the state value: {state}'  # works without inheriting from str

Al leer la documentación (es decir, no lo probé porque uso una versión anterior de Python, pero confío en los documentos), ya que Pitón 3.11 puedes hacer lo siguiente:

from enum import StrEnum

class Directions(StrEnum):
    NORTH = 'north',    # notice the trailing comma
    SOUTH = 'south'

print(Directions.NORTH)
>>> north

por favor refiérase a documentos y el discusión de diseño para una mayor comprensión.

si estas corriendo pitón 3.6+ejecutar pip install StrEnumy luego puedes hacer lo siguiente (confirmado por mí):

from strenum import StrEnum

class URLs(StrEnum):
    GOOGLE = 'www.google.com'
    STACKOVERFLOW = 'www.stackoverflow.com'

print(URLs.STACKOVERFLOW)

>>> www.stackoverflow.com

Puedes leer más al respecto aquí.

Además, esto se mencionó en los documentos: cómo crear sus propias enumeraciones basadas en otras clases:

Si bien IntEnum es parte del módulo enum, sería muy simple de implementar de forma independiente:

class IntEnum(int, Enum): pass Esto demuestra cómo se pueden definir enumeraciones derivadas similares; por ejemplo, un StrEnum que se mezcla en str en lugar de int.

Algunas reglas:

Al subclasificar Enum, los tipos de combinación deben aparecer antes que Enum en la secuencia de bases, como en el ejemplo anterior de IntEnum.

Si bien Enum puede tener miembros de cualquier tipo, una vez que mezcle un tipo adicional, todos los miembros deben tener valores de ese tipo, por ejemplo, int arriba. Esta restricción no se aplica a los complementos que solo agregan métodos y no especifican otro tipo.

Cuando se mezcla otro tipo de datos, el atributo de valor no es el mismo que el propio miembro de la enumeración, aunque es equivalente y se comparará igual.

Formato de estilo %: %s y %r llaman a la clase Enum calle() y
repetir() respectivamente; otros códigos (como %i o %h para IntEnum) tratan el miembro de enumeración como su tipo mixto.

Los literales de cadena formateados, str.format() y format() utilizarán los tipos combinados formato() a no ser que calle() o formato() se anula en la subclase, en cuyo caso se utilizarán los métodos anulados o los métodos Enum. Use los códigos de formato !s y !r para forzar el uso de la clase Enum calle() y repetir() métodos.

Fuente: https://docs.python.org/3/library/enum.html#others

Mientras que una clase mixin entre str y Enum puede resolver este problema, siempre debe pensar también en obtener el herramienta adecuada para el trabajo.

Y, a veces, la herramienta adecuada podría ser simplemente un MODULE_CONSTANT con un valor de cadena. Por ejemplo, logging tiene algunas constantes como DEBUG, INFO, etc. con valores significativos, incluso si son ints en este caso.

Las enumeraciones son una buena herramienta y las uso a menudo. Sin embargo, están destinados a compararse principalmente con otros miembros del mismo Enum, razón por la cual compararlos, por ejemplo, con cadenas requiere que salte a través de un aro adicional.

Si los valores de cadena asociados son nombres de Python válidos, puede obtener los nombres de los miembros de la enumeración usando .name propiedad como esta:

from enum import Enum
class MyEnum(Enum):
    state1=0
    state2=1

print (MyEnum.state1.name)  # 'state1'

a = MyEnum.state1
print(a.name)  # 'state1'

Si los valores de cadena asociados son cadenas arbitrarias, puede hacer esto:

class ModelNames(str, Enum):
    gpt2 = 'gpt2'
    distilgpt2 = 'distilgpt2'
    gpt2_xl="gpt2-XL"
    gpt2_large="gpt2-large"

print(ModelNames.gpt2) # 'ModelNames.gpt2'
print(ModelNames.gpt2 is str) # False
print(ModelNames.gpt2_xl.name) # 'gpt2_xl'
print(ModelNames.gpt2_xl.value) # 'gpt2-XL'

Prueba esto en línea: https://repl.it/@sytelus/enumstrtest

Si desea trabajar con cadenas directamente, podría considerar usar

MyEnum = collections.namedtuple(
    "MyEnum", ["state1", "state2"]
)(
    state1="state1", 
    state2="state2"
)

en lugar de enumerar en absoluto. Iterando sobre esto o haciendo MyEnum.state1 dará los valores de cadena directamente. Crear la tupla con nombre dentro de la misma declaración significa que solo puede haber una.

Obviamente, hay ventajas y desventajas por no usar Enum, por lo que depende de lo que valore más.

¿Qué hay de malo en usar el valor?

En mi humilde opinión, a menos que use Python versión 3.11 con StrEnum, simplemente anulo el __str__(self) método en la clase Enum adecuada:

class MyStrEnum(str, Enum):

    OK     = 'OK'
    FAILED = 'FAILED'

    def __str__(self) -> str:
        return self.value

Mejor

Simplemente use .value :

MyEnum.state1.value == 'state1'
# True