temparse 0.0.1__tar.gz → 0.0.3__tar.gz

{temparse-0.0.1 → temparse-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: temparse
-Version: 0.0.1
+Version: 0.0.3
 Summary: temparse is template + parse
 Author: jiang-zhexin
 Author-email: jiang-zhexin <162887873+jiang-zhexin@users.noreply.github.com>
@@ -52,18 +52,23 @@ The return type is `tuple[str, int]`.
 
 ## Supported Types
 
-| Interpolation                           | Example                  | Output               |
-| --------------------------------------- | ------------------------ | -------------------- |
-| `{str}`                                 | `"hello"`                | `"hello"`            |
-| `{int}`                                 | `"42"`                   | `42`                 |
-| `{int}`                                 | `"0xff"`                 | `255`                |
-| `{int:16}`                              | `"ff"`                   | `255`                |
-| `{float}`                               | `"3.14"`                 | `3.14`               |
-| `{complex}`                             | `"-1.23+4.5j"`           | `-1.23+4.5j`         |
-| `{json}`                                | `'[1,2,3]'`, `'{"a":1}'` | `[1,2,3]`, `{"a":1}` |
-| `{datetime.datetime:%d/%m/%y %H:%M:%S}` | `"31/01/22 23:59:59"`    | `datetime`           |
-| `{datetime.date:%Y-%m-%d}`              | `"2024-03-15"`           | `date`               |
-| `{datetime.time:%H:%M:%S}`              | `"13:23:27"`             | `time`               |
+| Interpolation                           | Example               | Output       |
+| --------------------------------------- | --------------------- | ------------ |
+| `{str}`                                 | `"hello"`             | `"hello"`    |
+| `{int}`                                 | `"42"`                | `42`         |
+| `{int}`                                 | `"0xff"`              | `255`        |
+| `{int:16}`                              | `"ff"`                | `255`        |
+| `{float}`                               | `"3.14"`              | `3.14`       |
+| `{complex}`                             | `"-1.23+4.5j"`        | `-1.23+4.5j` |
+| `{list}`                                | `'[1,2,3]'`           | `[1, 2, 3]`  |
+| `{dict}`                                | `'{"a":1}'`           | `{"a": 1}`   |
+| `{json}`                                | `'{"a":1}'`           | `{"a": 1}`   |
+| `{datetime.datetime:%d/%m/%y %H:%M:%S}` | `"31/01/22 23:59:59"` | `datetime`   |
+| `{datetime.date:%Y-%m-%d}`              | `"2024-03-15"`        | `date`       |
+| `{datetime.time:%H:%M:%S}`              | `"13:23:27"`          | `time`       |
+
+> [!IMPORTANT]
+> list and dict are just aliases for json.
 
 ## Custom Conversions
 
@@ -74,12 +79,12 @@ from temparse import Conversion, parse
 
 
 @Conversion
-def upper(s: str) -> str:
-    return s.upper()
+def percent(s: str) -> float:
+    return float(s.rstrip("%")) / 100
 
 
-(result,) = parse[str](t"{upper}", "hello")
-assert result == "HELLO"
+(result,) = parse[float](t"x = {percent}", "x = 30%")
+assert result == 0.3
 ```
 
 When your converter needs the format spec as well, use `FormatConversion`:

{temparse-0.0.1 → temparse-0.0.3}/README.md

@@ -36,18 +36,23 @@ The return type is `tuple[str, int]`.
 
 ## Supported Types
 
-| Interpolation                           | Example                  | Output               |
-| --------------------------------------- | ------------------------ | -------------------- |
-| `{str}`                                 | `"hello"`                | `"hello"`            |
-| `{int}`                                 | `"42"`                   | `42`                 |
-| `{int}`                                 | `"0xff"`                 | `255`                |
-| `{int:16}`                              | `"ff"`                   | `255`                |
-| `{float}`                               | `"3.14"`                 | `3.14`               |
-| `{complex}`                             | `"-1.23+4.5j"`           | `-1.23+4.5j`         |
-| `{json}`                                | `'[1,2,3]'`, `'{"a":1}'` | `[1,2,3]`, `{"a":1}` |
-| `{datetime.datetime:%d/%m/%y %H:%M:%S}` | `"31/01/22 23:59:59"`    | `datetime`           |
-| `{datetime.date:%Y-%m-%d}`              | `"2024-03-15"`           | `date`               |
-| `{datetime.time:%H:%M:%S}`              | `"13:23:27"`             | `time`               |
+| Interpolation                           | Example               | Output       |
+| --------------------------------------- | --------------------- | ------------ |
+| `{str}`                                 | `"hello"`             | `"hello"`    |
+| `{int}`                                 | `"42"`                | `42`         |
+| `{int}`                                 | `"0xff"`              | `255`        |
+| `{int:16}`                              | `"ff"`                | `255`        |
+| `{float}`                               | `"3.14"`              | `3.14`       |
+| `{complex}`                             | `"-1.23+4.5j"`        | `-1.23+4.5j` |
+| `{list}`                                | `'[1,2,3]'`           | `[1, 2, 3]`  |
+| `{dict}`                                | `'{"a":1}'`           | `{"a": 1}`   |
+| `{json}`                                | `'{"a":1}'`           | `{"a": 1}`   |
+| `{datetime.datetime:%d/%m/%y %H:%M:%S}` | `"31/01/22 23:59:59"` | `datetime`   |
+| `{datetime.date:%Y-%m-%d}`              | `"2024-03-15"`        | `date`       |
+| `{datetime.time:%H:%M:%S}`              | `"13:23:27"`          | `time`       |
+
+> [!IMPORTANT]
+> list and dict are just aliases for json.
 
 ## Custom Conversions
 
@@ -58,12 +63,12 @@ from temparse import Conversion, parse
 
 
 @Conversion
-def upper(s: str) -> str:
-    return s.upper()
+def percent(s: str) -> float:
+    return float(s.rstrip("%")) / 100
 
 
-(result,) = parse[str](t"{upper}", "hello")
-assert result == "HELLO"
+(result,) = parse[float](t"x = {percent}", "x = 30%")
+assert result == 0.3
 ```
 
 When your converter needs the format spec as well, use `FormatConversion`:

{temparse-0.0.1 → temparse-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "temparse"
-version = "0.0.1"
+version = "0.0.3"
 license = "MIT"
 requires-python = ">=3.14"
 readme = "README.md"

temparse-0.0.3/src/temparse/__init__.py

@@ -0,0 +1,167 @@
+import datetime
+import functools
+import json
+import logging
+import re
+from collections.abc import Callable
+from string.templatelib import Interpolation, Template
+from typing import Any, get_origin, is_typeddict
+
+__all__ = ["Conversion", "FormatConversion", "Parser", "parse"]
+
+log = logging.getLogger(__name__)
+
+
+class Parser[*T]:
+    """
+    A compiled template parser that can be reused to parse multiple strings.
+
+    example:
+    ```python
+    parser = Parser[str, int, float](t"{str} + {int} = {float}")
+
+    parser.parse("foo + 3 = 3.14")
+    ```
+    """
+
+    def __init__(self, template: Template, flags: re.RegexFlag = re.NOFLAG) -> None:
+        self._template = template
+        self._flags = flags
+        self._expression = "".join(
+            re.escape(item) if isinstance(item, str) else r"(.+?)" for item in template
+        )
+
+        log.debug(f"match expression: {self._expression!r}")
+
+    @functools.cached_property
+    def _match_re(self) -> re.Pattern[str]:
+        return re.compile(self._expression, self._flags)
+
+    def parse(self, s: str) -> tuple[*T]:
+        m = self._match_re.fullmatch(s)
+        if m is None:
+            raise ValueError(f"Invalid format: {s!r}")
+
+        return tuple(
+            _convert(text, interpolation)
+            for text, interpolation in zip(m.groups(), self._template.interpolations)
+        )
+
+
+class parse[*T]:
+    """
+    Parse string by template.
+
+    example:
+    ```python
+    city, year = parse[str, int](
+        t"I live in {str}, since {int}", "I live in Tokyo, since 2010"
+    )
+    assert city == "Tokyo"
+    assert year == 2010
+    ```
+    """
+
+    def __new__(cls, t: Template, s: str, flags: re.RegexFlag = re.NOFLAG) -> tuple[*T]:
+        """
+        Used to replace this function until [PEP 718](https://peps.python.org/pep-0718/) is accepted.
+
+        ```python
+        def parse[*T](t: Template, s: str, flags: re.RegexFlag = re.NOFLAG) -> tuple[*T]:
+            return Parser(t).parse(s)
+        ```
+        """
+        return Parser(t, flags).parse(s)
+
+
+class Conversion[T]:
+    """
+    Convert the string to your object.
+
+    example:
+    ```python
+    @Conversion
+    def percent(s: str) -> float:
+        return float(s.rstrip("%")) / 100
+
+
+    (result,) = parse[float](t"x = {percent}", "x = 30%")
+    assert result == 0.3
+    ```
+    """
+
+    __name__: str
+    __qualname__: str
+
+    def __init__(self, func: Callable[[str], T]) -> None:
+        self._convert = func
+        functools.update_wrapper(self, func)
+
+    def __call__(self, s: str) -> T:
+        return self._convert(s)
+
+
+class FormatConversion[T]:
+    """
+    Convert the string to your object with format.
+
+    example:
+    ```python
+    @FormatConversion
+    def between(s: str, spec: str) -> str:
+        lo, hi = spec.split(",")
+        return s[int(lo) : int(hi)]
+
+    (result,) = parse[str](t"{between:2,5}", "abcdefg")
+    assert result == "cde"
+    ```
+    """
+
+    __name__: str
+    __qualname__: str
+
+    def __init__(self, func: Callable[[str, str], T]) -> None:
+        self._convert = func
+        functools.update_wrapper(self, func)
+
+    def __call__(self, s: str, format: str) -> T:
+        return self._convert(s, format)
+
+
+def _convert(s: str, i: Interpolation[Any]) -> Any:
+    origin = get_origin(i.value) or i.value
+    match origin:
+        case Conversion():
+            return i.value(s)
+
+        case FormatConversion():
+            return i.value(s, i.format_spec)
+
+        case datetime.datetime:
+            return datetime.datetime.strptime(s, i.format_spec).astimezone(datetime.UTC)
+
+        case datetime.date:
+            return datetime.date.strptime(s, i.format_spec)
+
+        case datetime.time:
+            return datetime.time.strptime(s, i.format_spec)
+
+        case _ if origin is int:
+            return int(s, base=int(i.format_spec) if i.format_spec else 0)
+
+        case _ if origin is float:
+            return float(s)
+
+        case _ if origin is complex:
+            return complex(s)
+
+        case _ if origin is str:
+            return s
+
+        case _ if (
+            origin is list or origin is dict or origin is json or is_typeddict(origin)
+        ):
+            return json.loads(s)
+
+        case _:
+            raise TypeError(f"unkown object: {i.value}")

temparse-0.0.1/src/temparse/__init__.py

@@ -1,110 +0,0 @@
-import datetime
-import functools
-import json
-import logging
-import re
-from collections.abc import Callable
-from string.templatelib import Interpolation, Template
-from typing import Any
-
-__all__ = ["Conversion", "FormatConversion", "Parser", "parse"]
-
-log = logging.getLogger(__name__)
-
-
-class Parser[*T]:
-    def __init__(self, template: Template):
-        self.template = template
-        self.expression = f"^{
-            ''.join(
-                re.escape(item) if isinstance(item, str) else r'(.+?)'
-                for item in template
-            )
-        }$"
-        log.debug(f"match expression: {self.expression!r}")
-
-        self._match_re = re.compile(self.expression)
-
-    def parse(self, s: str) -> tuple[*T]:
-        m = self._match_re.match(s)
-        if m is None:
-            raise ValueError(f"Invalid format: {s!r}")
-
-        return tuple(
-            _convert(text, interpolation)
-            for text, interpolation in zip(m.groups(), self.template.interpolations)
-        )
-
-
-class parse[*T]:
-    """
-    Used to replace this function until [PEP 718](https://peps.python.org/pep-0718/) is accepted.
-
-    ```python
-    def parse[*T](t: Template, s: str) -> tuple[*T]:
-        return Parser(t).parse(s)
-    ```
-    """
-
-    def __new__(cls, t: Template, s: str) -> tuple[*T]:
-        return Parser(t).parse(s)
-
-
-class Conversion[T]:
-    __name__: str
-    __qualname__: str
-
-    def __init__(self, func: Callable[[str], T]) -> None:
-        self._convert = func
-        functools.update_wrapper(self, func)
-
-    def __call__(self, s: str) -> T:
-        return self._convert(s)
-
-
-class FormatConversion[T]:
-    __name__: str
-    __qualname__: str
-
-    def __init__(self, func: Callable[[str, str], T]) -> None:
-        self._convert = func
-        functools.update_wrapper(self, func)
-
-    def __call__(self, s: str, format: str) -> T:
-        return self._convert(s, format)
-
-
-def _convert(s: str, i: Interpolation[Any]) -> Any:
-    match i.value:
-        case Conversion():
-            return i.value(s)
-
-        case FormatConversion():
-            return i.value(s, i.format_spec)
-
-        case datetime.datetime:
-            return datetime.datetime.strptime(s, i.format_spec).astimezone(datetime.UTC)
-
-        case datetime.date:
-            return datetime.date.strptime(s, i.format_spec)
-
-        case datetime.time:
-            return datetime.time.strptime(s, i.format_spec)
-
-        case _ if i.value is int:
-            return int(s, base=int(i.format_spec) if i.format_spec else 0)
-
-        case _ if i.value is float:
-            return float(s)
-
-        case _ if i.value is complex:
-            return complex(s)
-
-        case _ if i.value is str:
-            return s
-
-        case _ if i.value is json:
-            return json.loads(s)
-
-        case _:
-            raise TypeError(f"unkown object: {i.value}")