--- a/cargo2rpm/semver.py       2023-03-06 05:26:17.000000000 -0800
+++ b/cargo2rpm/semver.py       2023-04-23 18:00:11.731932963 -0700
@@ -41,8 +41,8 @@
     Pre-release part of a Version.
     """
 
-    def __init__(self, parts: list[str | int]):
-        self.parts: list[str | int] = parts
+    def __init__(self, parts: list["str | int"]):
+        self.parts: list[str] = parts
 
     @staticmethod
     def parse(prerelease: str) -> "PreRelease":
@@ -71,20 +71,24 @@
             return False  # pragma nocover
 
         for lpart, rpart in itertools.zip_longest(self.parts, other.parts):
-            match lpart, rpart:
+#            match lpart, rpart:
                 # all previous parts were equal and the left pre-release has more parts
-                case l, None:
+#                case l, None:
+               if lpart=="l" and rpart==None:
                     return False
 
                 # all previous parts were equal and the right pre-release has more parts
-                case None, r:
+#                case None, r:
+               elif lpart==None and rpart=="r":
                     return True
 
                 # compare nonempty parts depending on value type
-                case l, r:
-                    match isinstance(l, int), isinstance(r, int):
+#                case l, r:
+               elif lpart=="l" and rpart=="r":
+#                    match isinstance(l, int), isinstance(r, int):
                         # both parts are numbers: compare numerically
-                        case True, True:
+#                        case True, True:
+                       if isinstance(l, int)==True and  isinstance(r, int)==True:
                             if l < r:
                                 return True
                             elif l == r:
@@ -93,7 +97,8 @@
                                 return False
 
                         # both parts are strings: compare lexicographically
-                        case False, False:
+#                        case False, False:
+                       elif isinstance(l, int)==False and  isinstance(r, int)==False:
                             if l < r:
                                 return True
                             elif l == r:
@@ -102,17 +107,19 @@
                                 return False
 
                         # number and string: string takes precedence
-                        case True, False:
+#                        case True, False:
+                       elif isinstance(l, int)==True and  isinstance(r, int)==False:
                             return True
 
                         # string and number: string takes precedence
-                        case False, True:
+#                        case False, True:
+                       elif isinstance(l, int)==False and  isinstance(r, int)==True:
                             return False
 
-                        case _:  # pragma nocover
+                       else:  # pragma nocover
                             raise RuntimeError("Unreachable: This should never happen.")
 
-                case _:  # pragma nocover
+               else:  # pragma nocover
                     raise RuntimeError("Unreachable: This should never happen.")
 
         # both pre-releases have equal numbers of parts and all pairs of parts are equal
@@ -207,16 +214,20 @@
         if self.patch < other.patch:
             return True
 
-        match self.pre, other.pre:
-            case None, None:
+#        match self.pre, other.pre:
+#            case None, None:
+            if self.pre==None and other.pre==None:
                 return False
-            case spre, None:
+#            case spre, None:
+            elif self.pre=="spre" and other.pre==None:
                 return True
-            case None, opre:
+#            case None, opre:
+            elif self.pre==None and other.pre=="opre":
                 return False
-            case spre, opre:
+#            case spre, opre:
+            elif self.pre=="spre" and other.pre=="opre":
                 return PreRelease.parse(spre) < PreRelease.parse(opre)
-            case _:  # pragma nocover
+            else:  # pragma nocover
                 raise RuntimeError("Unreachable: This should never happen.")
 
     def __le__(self, other):