better user API

Author: Archmonger

docs/examples/python/custom_router_easy_resolver.py

@@ -3,14 +3,12 @@
 
 # Create a custom resolver that uses the following pattern: "{name:type}"
 class CustomResolver(ReactPyResolver):
-    def __init__(
-        self,
-        route,
-        param_pattern=r"{(?P<name>\w+)(?P<type>:\w+)?}",  # Match parameters that use the "{name:type}" format
-        converters={  # Enable matching for the following types: int, str, any
-            "int": ConversionInfo(regex=r"\d+", func=int),
-            "str": ConversionInfo(regex=r"[^/]+", func=str),
-            "any": ConversionInfo(regex=r".*", func=str),
-        },
-    ) -> None:
-        super().__init__(route, param_pattern, converters)
+    # Match parameters that use the "<name:type>" format
+    param_pattern = r"<(?P<name>\w+)(?P<type>:\w+)?>"
+
+    # Enable matching for the following types: int, str, any
+    converters = {
+        "int": ConversionInfo(regex=r"\d+", func=int),
+        "str": ConversionInfo(regex=r"[^/]+", func=str),
+        "any": ConversionInfo(regex=r".*", func=str),
+    }

docs/examples/python/example/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from reactpy_router.converters import CONVERTERS
 from reactpy_router.types import MatchedRoute
@@ -17,16 +17,13 @@ class ReactPyResolver:
 
     URL routing syntax for this resolver is based on Starlette, and supports a mixture of Starlette and Django parameter types."""
 
-    def __init__(
-        self,
-        route: Route,
-        param_pattern: str = r"{(?P<name>\w+)(?P<type>:\w+)?}",
-        converters: dict[str, ConversionInfo] | None = None,
-    ) -> None:
+    param_pattern: str = r"{(?P<name>\w+)(?P<type>:\w+)?}"
+    converters: ClassVar[dict[str, ConversionInfo]] = CONVERTERS
+
+    def __init__(self, route: Route) -> None:
         self.element = route.element
-        self.registered_converters = converters or CONVERTERS
         self.converter_mapping: ConverterMapping = {}
-        self.param_regex = re.compile(param_pattern)
+        self.param_regex = re.compile(self.param_pattern)
         self.pattern = self.parse_path(route.path)
         self.key = self.pattern.pattern  # Unique identifier for ReactPy rendering
 
@@ -49,7 +46,7 @@ def parse_path(self, path: str) -> re.Pattern[str]:
 
             # Check if a converter exists for the type
             try:
-                conversion_info = self.registered_converters[param_type]
+                conversion_info = self.converters[param_type]
             except KeyError as e:
                 msg = f"Unknown conversion type {param_type!r} in {path!r}"
                 raise ValueError(msg) from e

src/reactpy_router/resolvers.py

@@ -17,6 +17,18 @@ def test_resolve_any():
     )
 
 
+def test_custom_resolver():
+    class CustomResolver(ReactPyResolver):
+        param_pattern = r"<(?P<name>\w+)(?P<type>:\w+)?>"
+
+    resolver = CustomResolver(route("<404:any>", "Hello World"))
+    assert resolver.parse_path("<404:any>") == re.compile("^(?P<_numeric_404>.*)$")
+    assert resolver.converter_mapping == {"_numeric_404": str}
+    assert resolver.resolve("/hello/world") == MatchedRoute(
+        element="Hello World", params={"404": "/hello/world"}, path="/hello/world"
+    )
+
+
 def test_parse_path():
     resolver = ReactPyResolver(route("/", None))
     assert resolver.parse_path("/a/b/c") == re.compile("^/a/b/c$")