support use with mixin classes

* require Python 3.12
* use explicit generic classes syntax
* use get_original_bases() and get_origin() to find base class among
  potentially multiple bases

Author: cd-eho

pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Typing :: Typed"
 ]
 dynamic = ["version"]
-requires-python = ">=3.8"
+requires-python = ">=3.12"
 dependencies = []
 
 [project.urls]
@@ -65,7 +65,7 @@ explicit_package_bases = true
 [tool.ruff]
 extend-exclude = ["src/multiprocessing_intenum/_version.py"]
 line-length = 119
-target-version = "py311"
+target-version = "py312"
 
 #[tool.ruff.format]
 

src/multiprocessing_intenum/__init__.py

@@ -3,23 +3,31 @@
 import multiprocessing
 from enum import IntEnum
 from multiprocessing.synchronize import Lock, RLock
-from typing import Any, Generic, TypeVar, get_args
+from types import get_original_bases
+from typing import Any, get_args, get_origin
 
 from ._version import version as __version__  # noqa: F401
 
-T = TypeVar("T", bound=IntEnum)
 
-
-class IntEnumValue(Generic[T]):
+class IntEnumValue[T: IntEnum]:
     """A multiprocessing safe shared object for `IntEnum` enum values."""
 
     # Pre-initialize type here to avoid numerous type ignores elsewhere
     EnumType: type[T | IntEnum] = IntEnum
 
     @classmethod
     def __init_subclass__(cls) -> None:  # noqa: D105
+        # find our base class among potentially multiple bases
+        orig_base = None
+        for base in get_original_bases(cls):
+            origin = get_origin(base)
+            if origin is not None and issubclass(origin, IntEnumValue):
+                orig_base = base
+        if orig_base is None:
+            message = "Can not determine base class!"
+            raise RuntimeError(message)
+
         # set EnumType to the specific type specified by subclass
-        orig_base = cls.__orig_bases__[0]  # type: ignore[attr-defined]
         cls.EnumType = get_args(orig_base)[0]
 
     def __init__(self, value: T | str, lock: None | Lock | RLock = None) -> None:

tests/test_intenum.py

@@ -2,6 +2,7 @@
 import multiprocessing
 from enum import IntEnum
 from unittest import TestCase
+from unittest.mock import Mock, patch
 
 from multiprocessing_intenum import IntEnumValue
 
@@ -24,11 +25,32 @@ class Bar(IntEnumValue[BarEnum]):
     pass
 
 
+class TestMixin:
+    pass
+
+
+class MixedFoo(TestMixin, IntEnumValue[FooEnum]):
+    pass
+
+
 class IntEnumValueTestCase(TestCase):
     def test_init(self) -> None:
         foo = Foo(FooEnum.FOO)
         self.assertEqual(foo, FooEnum.FOO)
 
+    def test_init_mixin(self) -> None:
+        foo = MixedFoo(FooEnum.FOO)
+        self.assertEqual(foo, FooEnum.FOO)
+
+    @patch("multiprocessing_intenum.get_original_bases", return_value=[])
+    def test_init_mixin_nobase(self, original_bases_mock: Mock) -> None:
+        with self.assertRaises(RuntimeError):
+
+            class MixedBar(TestMixin, IntEnumValue[BarEnum]):
+                pass
+
+        original_bases_mock.assert_called_once()
+
     def test_init_name(self) -> None:
         foo = Foo(FooEnum.FOO.name)
         self.assertEqual(foo, FooEnum.FOO)