Simplify API into builtins

Author: adriangb

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 files: ^python/.*|^tests/.*|^src/.*
 repos:
   - repo: https://github.com/ambv/black
-    rev: 21.11b1
+    rev: 22.3.0
     hooks:
       - id: black
   - repo: local
@@ -24,11 +24,11 @@ repos:
       - id: flake8
         args: ["--max-line-length=88"]
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.910-1
+    rev: v0.961
     hooks:
       - id: mypy
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.0.1
+    rev: v4.3.0
     hooks:
       - id: end-of-file-fixer
       - id: trailing-whitespace

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "routrie"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 description = "Rust port of the Python stdlib routrie modules"
 readme = "README.md"

Cargo.toml

@@ -24,25 +24,29 @@ assert matched is None
 
 matched = router.find("/users/routrie")
 assert matched is not None
-assert matched.value == 2
-assert matched.params[0].name == "id"
-assert matched.params[0].value == "routrie"
+value, params = matched
+assert value == 2
+assert params[0].name == "id"
+assert params[0].value == "routrie"
 
 matched = router.find("/users")
 assert matched is not None
-assert matched.value == 1
-assert matched.params == []
+value, params = matched
+assert value == 1
+assert params == []
 
 matched = router.find("/users/repos/)
 assert matched is not None
-assert matched.value == 3
-assert matched.params == []
+value, params = matched
+assert value == 3
+assert params == []
 
 matched = router.find("/users/repos/something)
 assert matched is not None
-assert matched.value == 3
-assert matched.params[0].name = "any"
-assert matched.params[0].value = "something"
+value, params = matched
+assert value == 3
+assert params[0].name = "any"
+assert params[0].value = "something"
 ```
 
 ## Contributing

README.md

@@ -2,25 +2,23 @@
 
 import typing
 
-from routrie.routrie import Match, Param
-from routrie.routrie import Router as _Router
-
-__all__ = ("Router", "Match", "Param")
-
+from routrie._routrie import Router as _Router
 
 T = typing.TypeVar("T")
 
+Params = typing.List[typing.Tuple[str, str]]
+
 
 class Router(typing.Generic[T]):
     __slots__ = ("_router",)
 
-    _router: _Router[T]
+    _router: "_Router[T]"
 
     def __init__(self) -> None:
         self._router = _Router()
 
     def insert(self, path: str, value: T) -> None:
         self._router.insert(path, value)
 
-    def find(self, path: str) -> typing.Optional[Match[T]]:
+    def find(self, path: str) -> typing.Tuple[T, Params]:
         return self._router.find(path)

python/routrie/__init__.py

@@ -0,0 +1,9 @@
+from typing import Generic, List, Tuple, TypeVar
+
+T = TypeVar("T")
+
+Params = List[Tuple[str, str]]
+
+class Router(Generic[T]):
+    def insert(self, path: str, value: T, /) -> None: ...
+    def find(self, path: str, /) -> Tuple[T, Params]: ...

python/routrie/_routrie.pyi

@@ -1,3 +1,3 @@
-pytest==6.2.5
-maturin==0.12.3
-pre-commit==2.16.0
+pytest==7.1.2
+maturin==0.13.0b6
+pre-commit==2.19.0

python/routrie/routrie.pyi

@@ -1,58 +1,6 @@
 use path_tree::PathTree;
 use pyo3::prelude::*;
 
-#[pyclass(module = "routrie")]
-#[derive(Clone)]
-struct Param {
-    #[pyo3(get)]
-    name: String,
-    #[pyo3(get)]
-    value: String,
-}
-
-impl Param {
-    fn to_string(&self) -> String {
-        format!("Param({}, {})", self.name, self.value)
-    }
-}
-
-#[pymethods]
-impl Param {
-    fn __str__(&self) -> String {
-        self.to_string()
-    }
-    fn __repr__(&self) -> String {
-        self.to_string()
-    }
-}
-
-#[pyclass(module = "routrie")]
-#[derive(Clone)]
-struct Match {
-    #[pyo3(get)]
-    value: Py<PyAny>,
-    #[pyo3(get)]
-    params: Vec<Param>,
-}
-
-#[pymethods]
-impl Match {
-    fn __str__(&self) -> String {
-        let params = format!(
-            "[{}]",
-            self.params
-                .iter()
-                .map(|param| format!("{}, ", param.to_string()))
-                .collect::<Vec<String>>()
-                .join(", ")
-        );
-        format!("Match({}, {})", self.value, params)
-    }
-    fn __repr__(&self) -> String {
-        self.__str__()
-    }
-}
-
 #[pyclass(module = "routrie._routrie")]
 struct Router {
     router: PathTree<Py<PyAny>>,
@@ -69,28 +17,13 @@ impl Router {
     fn insert(&mut self, path: &str, data: &PyAny, py: Python) -> () {
         self.router.insert(path, data.into_py(py));
     }
-    fn find(&self, path: &str) -> Option<Match> {
-        match self.router.find(path) {
-            None => None,
-            Some(found) => Some(Match {
-                value: found.0.clone(),
-                params: found
-                    .1
-                    .into_iter()
-                    .map(|(name, value)| Param {
-                        name: name.to_string(),
-                        value: value.to_string(),
-                    })
-                    .collect(),
-            }),
-        }
+    fn find<'m>(&'m self, path: &'m str) -> Option<(&'m Py<PyAny>, Vec<(&'m str, &'m str)>)> {
+        self.router.find(path)
     }
 }
 
 #[pymodule]
 fn _routrie(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_class::<Param>()?;
-    m.add_class::<Match>()?;
     m.add_class::<Router>()?;
     Ok(())
 }

requirements-bench.txt

@@ -1,15 +1,9 @@
-from typing import Iterable, List, Tuple
-
 import pytest
 
-from routrie import Router, Param
-
+from routrie import Router
 
-def params_to_tuple(params: Iterable[Param]) -> List[Tuple[str, str]]:
-    return [(p.name, p.value) for p in params]
 
-
-def test_routing():
+def test_routing() -> None:
     router: Router[int] = Router()
     router.insert("/", 0)
     router.insert("/users", 1)
@@ -28,20 +22,32 @@ def test_routing():
     # Matched "/"
     node = router.find("/")
     assert node is not None
-    assert node.value == 0
-    assert params_to_tuple(node.params) == []
+    match, params = node
+    assert match == 0
+    assert params == []
 
     # Matched "/:username"
     node = router.find("/username")
     assert node is not None
-    assert node.value == 7
-    assert params_to_tuple(node.params) == [("username", "username")]
+    match, params = node
+    assert match == 7
+    assert params == [("username", "username")]
 
     # Matched "/*any"
     node = router.find("/user/s")
     assert node is not None
-    assert node.value == 8
-    assert params_to_tuple(node.params) == [("any", "user/s")]
+    match, params = node
+    assert match == 8
+    assert params == [("any", "user/s")]
+
+
+def test_no_match() -> None:
+    router: Router[int] = Router()
+    router.insert("/", 0)
+
+    # No match
+    node = router.find("/noway-jose")
+    assert node is None
 
 
 if __name__ == "__main__":