Fix 3.10 incompatibility

Author: ldeluigi

backend/spellbook/variants/minimal_set_of_multisets.py

@@ -1,4 +1,4 @@
-from typing import Iterable, TypeVar, Generic, Self
+from typing import Iterable, TypeVar, Generic
 from .multiset import FrozenMultiset
 
 _T = TypeVar('_T')
@@ -83,14 +83,14 @@ def __eq__(self, other):
             return self.__sets == other.__sets
         return False
 
-    def __copy__(self) -> Self:
+    def __copy__(self):
         return self.__class__(_internal=self.__sets.copy())
 
-    def copy(self) -> Self:
+    def copy(self):
         "Returns a shallow copy of the collection."
         return self.__copy__()
 
-    def __or__(self, other: Self) -> Self:
+    def __or__(self, other: 'MinimalSetOfMultisets[_T]'):  # TODO: replace with Self from typing with pypy 3.11
         result = self.copy()
         result.extend(other)
         return result

backend/spellbook/variants/multiset.py

@@ -1,4 +1,4 @@
-from typing import MutableMapping, Self, Generic, TypeVar, Hashable, Mapping as MappingType, Union, Optional, Iterable as IterableType, \
+from typing import MutableMapping, Generic, TypeVar, Hashable, Mapping as MappingType, Union, Optional, Iterable as IterableType, \
     ItemsView, KeysView, ValuesView
 from collections import Counter
 from collections.abc import Mapping
@@ -51,19 +51,19 @@ def __len__(self) -> int:
     def isdisjoint(self, other: 'BaseMultiset[_T]') -> bool:
         return self._elements.keys().isdisjoint(other._elements.keys())
 
-    def difference(self, other: 'BaseMultiset[_T]') -> Self:
+    def difference(self, other: 'BaseMultiset[_T]'):
         return self.__class__(_internal=self._elements - other._elements)
 
-    def union(self, other: 'BaseMultiset[_T]') -> Self:
+    def union(self, other: 'BaseMultiset[_T]'):
         return self.__class__(_internal=self._elements | other._elements)
 
-    def combine(self, other: 'BaseMultiset[_T]') -> Self:
+    def combine(self, other: 'BaseMultiset[_T]'):
         return self.__class__(_internal=self._elements + other._elements)
 
-    def intersection(self, other: 'BaseMultiset[_T]') -> Self:
+    def intersection(self, other: 'BaseMultiset[_T]'):
         return self.__class__(_internal=self._elements & other._elements)
 
-    def times(self, factor: int) -> Self:
+    def times(self, factor: int):
         if factor == 0:
             return self.__class__()
         if factor < 0:
@@ -102,7 +102,7 @@ def __eq__(self, other: object) -> bool:
     def get(self, element: _T, default: int) -> int:
         return self._elements.get(element, default)
 
-    def copy(self) -> Self:
+    def copy(self):
         return self.__class__(_internal=self._elements.copy())
 
     __copy__ = copy
@@ -128,22 +128,22 @@ def __ge__(self, other: 'BaseMultiset[_T]') -> bool:
     def __gt__(self, other: 'BaseMultiset[_T]') -> bool:
         return self._total > other._total and self.issuperset(other)
 
-    def __add__(self, other: 'BaseMultiset[_T]') -> Self:
+    def __add__(self, other: 'BaseMultiset[_T]'):
         return self.combine(other)
 
-    def __sub__(self, other: 'BaseMultiset[_T]') -> Self:
+    def __sub__(self, other: 'BaseMultiset[_T]'):
         return self.difference(other)
 
-    def __mul__(self, factor: int) -> Self:
+    def __mul__(self, factor: int):
         return self.times(factor)
 
-    def __rmul__(self, factor: int) -> Self:
+    def __rmul__(self, factor: int):
         return self.times(factor)
 
-    def __or__(self, other: 'BaseMultiset[_T]') -> Self:
+    def __or__(self, other: 'BaseMultiset[_T]'):
         return self.union(other)
 
-    def __and__(self, other: 'BaseMultiset[_T]') -> Self:
+    def __and__(self, other: 'BaseMultiset[_T]'):
         return self.intersection(other)
 
     def __floordiv__(self, other: 'BaseMultiset[_T]') -> int:

backend/spellbook/variants/variant_set.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Callable, Self
+from typing import Iterable, Callable
 from itertools import product, chain
 from functools import reduce
 from dataclasses import dataclass, replace
@@ -61,7 +61,7 @@ def entry_to_ingredients(cls, entry: Entry) -> tuple[FrozenMultiset[cardid], Fro
     def entries(self) -> Iterable[Entry]:
         return self.sets
 
-    def filter(self, entry: Entry) -> Self:
+    def filter(self, entry: Entry):
         return self.__class__(parameters=replace(self.parameters, filter=entry), _internal=self.sets.subtree(entry))
 
     def __str__(self) -> str:
@@ -70,11 +70,11 @@ def __str__(self) -> str:
     def __len__(self) -> int:
         return len(self.sets)
 
-    def __or__(self, other: Self) -> Self:
+    def __or__(self, other: 'VariantSet'):  # TODO: replace with Self from typing with pypy 3.11
         assert self.parameters == other.parameters, "Cannot union VariantSets with different parameters"
         return self.__class__(parameters=self.parameters, _internal=self.sets | other.sets)
 
-    def __and__(self, other: Self):
+    def __and__(self, other: 'VariantSet'):  # TODO: replace with Self from typing with pypy 3.11
         assert self.parameters == other.parameters, "Cannot intersect VariantSets with different parameters"
         result = MinimalSetOfMultisets[int]()
         for left_entry, right_entry in product(self.entries(), other.entries()):
@@ -84,7 +84,7 @@ def __and__(self, other: Self):
             result.add(entry)
         return self.__class__(parameters=self.parameters, _internal=result)
 
-    def __add__(self, other: Self):
+    def __add__(self, other: 'VariantSet'):  # TODO: replace with Self from typing with pypy 3.11
         assert self.parameters == other.parameters, "Cannot sum VariantSets with different parameters"
         result = MinimalSetOfMultisets[int]()
         for left_key, right_key in product(self.entries(), other.entries()):
@@ -98,25 +98,25 @@ def variants(self) -> list[tuple[FrozenMultiset[cardid], FrozenMultiset[template
         return [self.entry_to_ingredients(e) for e in self.entries()]
 
     @classmethod
-    def or_sets(cls, sets: list[Self], parameters: VariantSetParameters | None = None) -> Self:
+    def or_sets(cls, sets: list['VariantSet'], parameters: VariantSetParameters | None = None):  # TODO: replace with Self from typing with pypy 3.11
         return cls.aggregate_sets(sets, strategy=lambda x, y: x | y, parameters=parameters)
 
     @classmethod
-    def and_sets(cls, sets: list[Self], parameters: VariantSetParameters | None = None) -> Self:
+    def and_sets(cls, sets: list['VariantSet'], parameters: VariantSetParameters | None = None):  # TODO: replace with Self from typing with pypy 3.11
         return cls.aggregate_sets(sets, strategy=lambda x, y: x & y, parameters=parameters)
 
     @classmethod
-    def sum_sets(cls, sets: list[Self], parameters: VariantSetParameters | None = None) -> Self:
+    def sum_sets(cls, sets: list['VariantSet'], parameters: VariantSetParameters | None = None):  # TODO: replace with Self from typing with pypy 3.11
         return cls.aggregate_sets(sets, strategy=lambda x, y: x + y, parameters=parameters)
 
     @classmethod
-    def aggregate_sets(cls, sets: list[Self], strategy: Callable[[Self, Self], Self], parameters: VariantSetParameters | None = None) -> Self:
+    def aggregate_sets(cls, sets: list['VariantSet'], strategy: Callable[['VariantSet', 'VariantSet'], 'VariantSet'], parameters: VariantSetParameters | None = None):  # TODO: replace with Self from typing with pypy 3.11
         match len(sets):
             case 0: return cls(parameters=parameters)
             case _: return reduce(strategy, sets)
 
     @classmethod
-    def product_sets(cls, sets: list[Self], parameters: VariantSetParameters | None = None) -> Self:
+    def product_sets(cls, sets: list['VariantSet'], parameters: VariantSetParameters | None = None):  # TODO: replace with Self from typing with pypy 3.11
         parameters = parameters if parameters is not None else VariantSetParameters()
         if parameters.allow_multiple_copies:
             return cls.sum_sets(sets, parameters=parameters)

docs/index.md

@@ -28,3 +28,5 @@ You need:
 - `flake8` for linting the code, which is mandatory for contributing otherwise the CI will fail
 - [Optional] VS Code with the Python extension, for development and debugging exploiting the `launch.json` configuration
     - `pytest` to run the unit tests in VS Code
+- [Optional] PyPy 3.10 or later for running long tasks faster
+  - Remember to install the dependencies using `pypy -m pip install -r requirements.txt` in the backend folder