Optimize usage of re. methods

Author: eumiro

src/pendulum/formatting/formatter.py

@@ -68,17 +68,13 @@ class Formatter:
 
     _FROM_FORMAT_RE: re.Pattern[str] = re.compile(r"(?<!\\\[)" + _TOKENS + r"(?!\\\])")
 
-    _LOCALIZABLE_TOKENS: ClassVar[
-        dict[str, str | Callable[[Locale], Sequence[str]] | None]
-    ] = {
+    _LOCALIZABLE_TOKENS: ClassVar[dict[str, str | Callable[[Locale], Sequence[str]] | None]] = {
         "Qo": None,
         "MMMM": "months.wide",
         "MMM": "months.abbreviated",
         "Mo": None,
         "DDDo": None,
-        "Do": lambda locale: tuple(
-            rf"\d+{o}" for o in locale.get("custom.ordinal").values()
-        ),
+        "Do": lambda locale: tuple(rf"\d+{o}" for o in locale.get("custom.ordinal").values()),
         "dddd": "days.wide",
         "ddd": "days.abbreviated",
         "dd": "days.short",
@@ -242,9 +238,7 @@ class Formatter:
         "z": str,
     }
 
-    def format(
-        self, dt: pendulum.DateTime, fmt: str, locale: str | Locale | None = None
-    ) -> str:
+    def format(self, dt: pendulum.DateTime, fmt: str, locale: str | Locale | None = None) -> str:
         """
         Formats a DateTime instance with a given format and locale.
 
@@ -303,9 +297,7 @@ def _format_token(self, dt: pendulum.DateTime, token: str, locale: Locale) -> st
 
         return token
 
-    def _format_localizable_token(
-        self, dt: pendulum.DateTime, token: str, locale: Locale
-    ) -> str:
+    def _format_localizable_token(self, dt: pendulum.DateTime, token: str, locale: Locale) -> str:
         """
         Formats a DateTime instance
         with a given localizable token and locale.
@@ -377,8 +369,7 @@ def parse(
         """
         escaped_fmt = re.escape(fmt)
 
-        tokens = self._FROM_FORMAT_RE.findall(escaped_fmt)
-        if not tokens:
+        if not self._FROM_FORMAT_RE.search(escaped_fmt):
             raise ValueError("The given time string does not match the given format")
 
         if not locale:
@@ -402,11 +393,9 @@ def parse(
             "timestamp": None,
         }
 
-        pattern = self._FROM_FORMAT_RE.sub(
-            lambda m: self._replace_tokens(m.group(0), loaded_locale), escaped_fmt
-        )
+        pattern = self._FROM_FORMAT_RE.sub(lambda m: self._replace_tokens(m.group(0), loaded_locale), escaped_fmt)
 
-        if not re.search("^" + pattern + "$", time):
+        if not re.fullmatch(pattern, time):
             raise ValueError(f"String does not match format {fmt}")
 
         def _get_parsed_values(m: Match[str]) -> Any:
@@ -416,9 +405,7 @@ def _get_parsed_values(m: Match[str]) -> Any:
 
         return self._check_parsed(parsed, now)
 
-    def _check_parsed(
-        self, parsed: dict[str, Any], now: pendulum.DateTime
-    ) -> dict[str, Any]:
+    def _check_parsed(self, parsed: dict[str, Any], now: pendulum.DateTime) -> dict[str, Any]:
         """
         Checks validity of parsed elements.
 
@@ -619,9 +606,7 @@ def _get_parsed_value(
 
             parsed["tz"] = pendulum.timezone(value)
 
-    def _get_parsed_locale_value(
-        self, token: str, value: str, parsed: dict[str, Any], locale: Locale
-    ) -> None:
+    def _get_parsed_locale_value(self, token: str, value: str, parsed: dict[str, Any], locale: Locale) -> None:
         if token == "MMMM":
             unit = "month"
             match = "months.wide"
@@ -680,11 +665,7 @@ def _replace_tokens(self, token: str, locale: Locale) -> str:
             if callable(values):
                 candidates = values(locale)
             else:
-                candidates = tuple(
-                    locale.translation(
-                        cast("str", self._LOCALIZABLE_TOKENS[token])
-                    ).values()
-                )
+                candidates = tuple(locale.translation(cast("str", self._LOCALIZABLE_TOKENS[token])).values())
         else:
             candidates = cast("Sequence[str]", self._REGEX_TOKENS[token])
 

src/pendulum/locales/locale.py

@@ -48,7 +48,7 @@ def load(cls, locale: str | Locale) -> Locale:
 
     @classmethod
     def normalize_locale(cls, locale: str) -> str:
-        m = re.match("([a-z]{2})[-_]([a-z]{2})", locale, re.I)
+        m = re.fullmatch("([a-z]{2})[-_]([a-z]{2})", locale, re.I)
         if m:
             return f"{m.group(1).lower()}_{m.group(2).lower()}"
         else:

src/pendulum/parsing/__init__.py

@@ -140,7 +140,7 @@ def _parse_common(text: str, **options: Any) -> datetime | date | time:
 
     :param text: The string to parse.
     """
-    m = COMMON.match(text)
+    m = COMMON.fullmatch(text)
     has_date = False
     year = 0
     month = 1

src/pendulum/parsing/iso8601.py

@@ -97,7 +97,7 @@ def parse_iso8601(
     if parsed is not None:
         return parsed
 
-    m = ISO8601_DT.match(text)
+    m = ISO8601_DT.fullmatch(text)
     if not m:
         raise ParserError("Invalid ISO 8601 string")
 
@@ -264,7 +264,7 @@ def parse_iso8601(
 
 
 def _parse_iso8601_duration(text: str, **options: str) -> Duration | None:
-    m = ISO8601_DURATION.match(text)
+    m = ISO8601_DURATION.fullmatch(text)
     if not m:
         return None