temparse 0.0.1__py3-none-any.whl

temparse/__init__.py

@@ -0,0 +1,110 @@
+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}")

temparse-0.0.1.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: temparse
+Version: 0.0.1
+Summary: temparse is template + parse
+Author: jiang-zhexin
+Author-email: jiang-zhexin <162887873+jiang-zhexin@users.noreply.github.com>
+License-Expression: MIT
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.14
+Project-URL: homepage, https://github.com/jiang-zhexin/temparse
+Description-Content-Type: text/markdown
+
+# temparse
+
+**temparse = template + parse**, parse strings using t-string templates.
+
+Inspired by [parse](https://github.com/r1chardj0n3s/parse), but built on Python
+3.14's [t-strings](https://peps.python.org/pep-0750/), with better type hints.
+
+## Installation
+
+### uv
+
+```bash
+uv add temparse
+```
+
+### pip
+
+```bash
+# Requires Python >= 3.14.
+pip install temparse
+```
+
+## Quick Start
+
+```python
+from temparse import parse
+
+city, year = parse[str, int](
+    t"I live in {str}, since {int}", "I live in Tokyo, since 2010"
+)
+assert city == "Tokyo"
+assert year == 2010
+```
+
+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`               |
+
+## Custom Conversions
+
+Decorate a function with `@Conversion` to use it directly in a template:
+
+```python
+from temparse import Conversion, parse
+
+
+@Conversion
+def upper(s: str) -> str:
+    return s.upper()
+
+
+(result,) = parse[str](t"{upper}", "hello")
+assert result == "HELLO"
+```
+
+When your converter needs the format spec as well, use `FormatConversion`:
+
+```python
+from temparse import FormatConversion, parse
+
+
+@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"
+```
+
+## `Parser` (Compiled Templates)
+
+Build a parser once and reuse it:
+
+```python
+from temparse import Parser
+
+parser = Parser[str, int, float](t"{str} + {int} = {float}")
+
+assert parser.parse("foo + 3 = 3.14") == ("foo", 3, 3.14)
+assert parser.parse("bar + 7 = 2.72") == ("bar", 7, 2.72)
+```
+
+## License
+
+MIT

temparse-0.0.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+temparse/__init__.py,sha256=CjLr0CIDsQAQlvswMT41KlX0IPhCLCLQXEzx_WFGDks,2958
+temparse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+temparse-0.0.1.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
+temparse-0.0.1.dist-info/METADATA,sha256=kQaH9M5WkFX0eBYDz2EH8xop_w9bQBJDh-uiR_NnLQA,3292
+temparse-0.0.1.dist-info/RECORD,,

temparse-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.17
+Root-Is-Purelib: true
+Tag: py3-none-any