dycw-utilities 0.129.10__py3-none-any.whl → 0.175.17__py3-none-any.whl

utilities/random.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from random import Random, SystemRandom
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
+
+from utilities.functools import cache
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
@@ -9,7 +11,6 @@ if TYPE_CHECKING:
     from utilities.types import Seed
 
 
-_T = TypeVar("_T")
 SYSTEM_RANDOM = SystemRandom()
 
 
@@ -18,16 +19,16 @@ SYSTEM_RANDOM = SystemRandom()
 
 def bernoulli(*, true: float = 0.5, seed: Seed | None = None) -> bool:
     """Return a Bernoulli random variate."""
-    seed = get_state(seed=seed)
-    return bool(seed.binomialvariate(p=true))
+    state = get_state(seed)
+    return bool(state.binomialvariate(p=true))
 
 
 ##
 
 
-def get_docker_name(*, seed: Seed | None = None) -> str:
+def get_docker_name(seed: Seed | None = None, /) -> str:
     """Get a docker name."""
-    state = get_state(seed=seed)
+    state = get_state(seed)
     prefix = state.choice(_DOCKER_PREFIXES)
     suffix = state.choice(_DOCKER_SUFFIXES)
     digit = state.randint(0, 9)
@@ -48,16 +49,19 @@ _DOCKER_SUFFIXES = [
 ##
 
 
-def get_state(*, seed: Seed | None = None) -> Random:
+@cache
+def get_state(seed: Seed | None = None, /) -> Random:
     """Get a random state."""
     return seed if isinstance(seed, Random) else Random(x=seed)
 
 
 ##
-def shuffle(iterable: Iterable[_T], /, *, seed: Seed | None = None) -> list[_T]:
+
+
+def shuffle[T](iterable: Iterable[T], /, *, seed: Seed | None = None) -> list[T]:
     """Shuffle an iterable."""
     copy = list(iterable).copy()
-    state = get_state(seed=seed)
+    state = get_state(seed)
     state.shuffle(copy)
     return copy
 

utilities/re.py

@@ -2,37 +2,58 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from typing import override
+from re import Pattern
+from typing import TYPE_CHECKING, assert_never, override
 
-from utilities.iterables import OneEmptyError, OneNonUniqueError, one
+if TYPE_CHECKING:
+    from utilities.types import PatternLike
 
 
-def extract_group(pattern: str, text: str, /, *, flags: int = 0) -> str:
+def ensure_pattern(pattern: PatternLike, /, *, flags: int = 0) -> Pattern[str]:
+    """Ensure a pattern is returned."""
+    match pattern:
+        case Pattern():
+            return pattern
+        case str():
+            return re.compile(pattern, flags=flags)
+        case never:
+            assert_never(never)
+
+
+##
+
+
+def extract_group(pattern: PatternLike, text: str, /, *, flags: int = 0) -> str:
     """Extract a group.
 
     The regex must have 1 capture group, and this must match exactly once.
     """
-    compiled = re.compile(pattern, flags=flags)
-    match compiled.groups:
+    pattern_use = ensure_pattern(pattern, flags=flags)
+    match pattern_use.groups:
         case 0:
-            raise _ExtractGroupNoCaptureGroupsError(pattern=pattern, text=text)
+            raise _ExtractGroupNoCaptureGroupsError(pattern=pattern_use, text=text)
         case 1:
-            matches: list[str] = compiled.findall(text)
-            try:
-                return one(matches)
-            except OneEmptyError:
-                raise _ExtractGroupNoMatchesError(pattern=pattern, text=text) from None
-            except OneNonUniqueError:
-                raise _ExtractGroupMultipleMatchesError(
-                    pattern=pattern, text=text, matches=matches
-                ) from None
+            matches: list[str] = pattern_use.findall(text)
+            match len(matches):
+                case 0:
+                    raise _ExtractGroupNoMatchesError(
+                        pattern=pattern_use, text=text
+                    ) from None
+                case 1:
+                    return matches[0]
+                case _:
+                    raise _ExtractGroupMultipleMatchesError(
+                        pattern=pattern_use, text=text, matches=matches
+                    ) from None
         case _:
-            raise _ExtractGroupMultipleCaptureGroupsError(pattern=pattern, text=text)
+            raise _ExtractGroupMultipleCaptureGroupsError(
+                pattern=pattern_use, text=text
+            )
 
 
 @dataclass(kw_only=True, slots=True)
 class ExtractGroupError(Exception):
-    pattern: str
+    pattern: Pattern[str]
     text: str
 
 
@@ -68,32 +89,35 @@ class _ExtractGroupNoMatchesError(ExtractGroupError):
         return f"Pattern {self.pattern} must match against {self.text}"
 
 
-def extract_groups(pattern: str, text: str, /, *, flags: int = 0) -> list[str]:
+##
+
+
+def extract_groups(pattern: PatternLike, text: str, /, *, flags: int = 0) -> list[str]:
     """Extract multiple groups.
 
     The regex may have any number of capture groups, and they must collectively
     match exactly once.
     """
-    compiled = re.compile(pattern, flags=flags)
-    if (n_groups := compiled.groups) == 0:
-        raise _ExtractGroupsNoCaptureGroupsError(pattern=pattern, text=text)
-    matches: list[str] = compiled.findall(text)
+    pattern_use = ensure_pattern(pattern, flags=flags)
+    if (n_groups := pattern_use.groups) == 0:
+        raise _ExtractGroupsNoCaptureGroupsError(pattern=pattern_use, text=text)
+    matches: list[str] = pattern_use.findall(text)
     match len(matches), n_groups:
         case 0, _:
-            raise _ExtractGroupsNoMatchesError(pattern=pattern, text=text)
+            raise _ExtractGroupsNoMatchesError(pattern=pattern_use, text=text)
         case 1, 1:
             return matches
         case 1, _:
-            return list(one(matches))
+            return list(matches[0])
         case _:
             raise _ExtractGroupsMultipleMatchesError(
-                pattern=pattern, text=text, matches=matches
+                pattern=pattern_use, text=text, matches=matches
             )
 
 
 @dataclass(kw_only=True, slots=True)
 class ExtractGroupsError(Exception):
-    pattern: str
+    pattern: Pattern[str]
     text: str
 
 
@@ -108,7 +132,7 @@ class _ExtractGroupsMultipleMatchesError(ExtractGroupsError):
 
 @dataclass(kw_only=True, slots=True)
 class _ExtractGroupsNoCaptureGroupsError(ExtractGroupsError):
-    pattern: str
+    pattern: Pattern[str]
     text: str
 
     @override
@@ -123,4 +147,10 @@ class _ExtractGroupsNoMatchesError(ExtractGroupsError):
         return f"Pattern {self.pattern} must match against {self.text}"
 
 
-__all__ = ["ExtractGroupError", "ExtractGroupsError", "extract_group", "extract_groups"]
+__all__ = [
+    "ExtractGroupError",
+    "ExtractGroupsError",
+    "ensure_pattern",
+    "extract_group",
+    "extract_groups",
+]