How can I create a FractionEnum in Python without a metaclass conflict?

Question

I am trying to create a FractionEnum similar to StrEnum or IntEnum. My first attempt resulted in a metaclass conflict:

class FractionEnum(fractions.Fraction, Enum):
    VALUE_1 = 1, 1
    VALUE_2 = 8, 9

TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

I followed the suggestion from this answer Multiple inheritance metaclass conflict involving Enum and created a new metaclass:

class FractionEnumMeta(type(Enum), type(fractions.Fraction)):
    pass

class FractionEnum(fractions.Fraction, Enum, metaclass=FractionEnumMeta):
    VALUE_1 = 1, 1
    VALUE_2 = 8, 9

This solved the above error but now I get:

  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/enum.py", line 289, in __new__
    enum_member = __new__(enum_class, *args)
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/fractions.py", line 93, in __new__
    self = super(Fraction, cls).__new__(cls)

TypeError: Enum.__new__() missing 1 required positional argument: 'value'

The issue seems to be that the __new__ call inside Fraction is trying to create an enum, from the call inside the EnumMeta metaclass:

            else:
                enum_member = __new__(enum_class, *args)

I'm misunderstanding how the metaclasses can work together to create an object that is both a fraction and an Enum - it seems to work out of the box with int or str or classes that don't define a metaclass.

Update:

I was able to use the code below to have the enumeration replace the Fraction's new method, but I am getting an error if I try deepcopy a class that has the enum as a member:

/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/enum.py:497: in _create_
    _, first_enum = cls._get_mixins_(cls, bases)

in the Enum code:

        # ensure final parent class is an Enum derivative, find any concrete
        # data type, and check that Enum has no members
        first_enum = bases[-1]
        if not issubclass(first_enum, Enum):
            raise TypeError("new enumerations should be created as "
                    "`EnumName([mixin_type, ...] [data_type,] enum_type)`")
        member_type = _find_data_type(bases) or object
        if first_enum._member_names_:
>           raise TypeError("Cannot extend enumerations")
E           TypeError: Cannot extend enumerations

Sample to reproduce:

class TestFractionEnum(FractionEnum):
    VALUE_1 = 1, 1
    VALUE_2 = 8, 9

class C:
    def __init__(self):
        self.fraction_enum = TestFractionEnum.VALUE_1

c = C()
print(c)
print(c.fraction_enum)
d = copy.copy(c)
print(d)
e = copy.deepcopy(c)
print(e)

Update 2:

Overriding deepcopy on the enum seems to work:

def __deepcopy__(self, memo):
        if type(self) == Fraction:
            return self
        for item in self.__class__:
            if self == item:
                return item
        assert f'Invalid enum: {self}'

Answer 1

As @jsbueno said, you have to write your own __new__:

from enum import EnumType, Enum
from fractions import Fraction
import math

class FractionEnumMeta(type(Fraction), EnumType):
    pass

class FractionEnum(Fraction, Enum, metaclass=FractionEnumMeta):
    def __new__(cls, numerator=0, denominator=None):
        #
        # this is the only line different from Fraction.__new__
        self = object.__new__(cls)
        #
        #
        if denominator is None:
            if type(numerator) is int:
                self._numerator = numerator
                self._denominator = 1
                return self
            elif isinstance(numerator, numbers.Rational):
                self._numerator = numerator.numerator
                self._denominator = numerator.denominator
                return self
            elif isinstance(numerator, (float, Decimal)):
                # Exact conversion
                self._numerator, self._denominator = numerator.as_integer_ratio()
                return self
            elif isinstance(numerator, str):
                # Handle construction from strings.
                m = _RATIONAL_FORMAT.match(numerator)
                if m is None:
                    raise ValueError('Invalid literal for Fraction: %r' %
                                     numerator)
                numerator = int(m.group('num') or '0')
                denom = m.group('denom')
                if denom:
                    denominator = int(denom)
                else:
                    denominator = 1
                    decimal = m.group('decimal')
                    if decimal:
                        decimal = decimal.replace('_', '')
                        scale = 10**len(decimal)
                        numerator = numerator * scale + int(decimal)
                        denominator *= scale
                    exp = m.group('exp')
                    if exp:
                        exp = int(exp)
                        if exp >= 0:
                            numerator *= 10**exp
                        else:
                            denominator *= 10**-exp
                if m.group('sign') == '-':
                    numerator = -numerator
            else:
                raise TypeError("argument should be a string "
                                "or a Rational instance")
        elif type(numerator) is int is type(denominator):
            pass # *very* normal case
        elif (isinstance(numerator, numbers.Rational) and
            isinstance(denominator, numbers.Rational)):
            numerator, denominator = (
                numerator.numerator * denominator.denominator,
                denominator.numerator * numerator.denominator
                )
        else:
            raise TypeError("both arguments should be "
                            "Rational instances")
        if denominator == 0:
            raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
        g = math.gcd(numerator, denominator)
        if denominator < 0:
            g = -g
        numerator //= g
        denominator //= g
        self._numerator = numerator
        self._denominator = denominator
        return self
    

class TestFractionEnum(FractionEnum):
    VALUE_1 = 1, 1
    VALUE_2 = 8, 9

In this case, we just reuse Fraction.__new__, but remove the super() call and create the new fraction instance directly.

---

Disclosure: I am the author of the Python stdlib Enum, the enum34 backport, and the Advanced Enumeration (aenum) library.