sanic-org/sanic-routing — 16★ on GitHub (Python). Internal handler routing for Sanic beginning with v21.3.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
We can can see the code that the router has generated for us. It is available as a string at router.find_route_src.
def find_route(path, method, router, basket, extra):
parts = tuple(path[1:].split(router.delimiter))
num = len(parts)
# node=1 // part=__dynamic__:str
if num == 1: # CHECK 1
try:
basket['__matches__'][0] = str(parts[0])
except ValueError:
pass
else:
# Return 1
return router.dynamic_routes[('<__dynamic__:str>',)][0], basket
raise NotFound
FYI: If you are on Python 3.9, you can see a representation of the source after compilation at router.find_route_src_compiled
What's it doing?
Therefore, in general implementation requires you to:
Define a router with a get method;
Add one or more routes;
Finalize the router (router.finalize()); and
Call the router's get method.
NOTE: You can call router.finalize(False) if you do not want to compile the source code into executable form. This is useful if you only intend to review the generated output.
Every time you call router.add you create one (1) new Route instance. Even if that one route is created with multiple methods, it generates a single instance. If you add() another Route that has a similar path structure (but, perhaps has differen methods) they will be grouped together into a RouteGroup. It is worth also noting that a RouteGroup is created the first time you call add(), but subsequent similar routes will reuse the existing grouping instance.
When you call finalize(), it is taking the defined route groups and arranging them into "nodes" in a hierarchical tree. A single node is a path segment. A Node instance can have one or more RouteGroup on it where the Node is the termination point for that path.
def find_route(path, method, router, basket, extra):
parts = tuple(path[1:].split(router.delimiter))
num = len(parts)
# node=1 // part=path
if num > 1: # CHECK 1
if parts[0] == "path": # CHECK 4
# node=1.1 // part=to
if num > 2: # CHECK 1
if parts[1] == "to": # CHECK 4
# node=1.1.1 // part=different
if num > 3: # CHECK 1
if parts[2] == "different": # CHECK 4
# node=1.1.1.1 // part=__dynamic__:str
if num == 4: # CHECK 1
try:
basket['__matches__'][3] = str(parts[3])
except ValueError:
pass
else:
if method in frozenset({'one', 'two'}):
route_idx = 0
elif method in frozenset({'BASE'}):
route_idx = 1
else:
raise NoMethod
# Return 1.1.1.1
return router.dynamic_routes[('path', 'to', 'different', '<__dynamic__:str>')][route_idx], basket
# node=1.1.2 // part=__dynamic__:int
if num >= 3: # CHECK 1
try:
basket['__matches__'][2] = int(parts[2])
except ValueError:
pass
else:
if num == 3: # CHECK 5
# Return 1.1.2
return router.dynamic_routes[('path', 'to', '<__dynamic__:int>')][0], basket
# node=1.1.3 // part=__dynamic__:str
if num >= 3: # CHECK 1
try:
basket['__matches__'][2] = str(parts[2])
except ValueError:
pass
else:
if num == 3: # CHECK 5
# Return 1.1.3
return router.dynamic_routes[('path', 'to', '<__dynamic__:str>')][0], basket
raise NotFound
Special cases
The above example only shows routes that have a dynamic path segment in them (example: <foo>). But, there are other use cases that are covered differently:
fully static paths - These are paths with no parameters (example: /user/login). These are basically matched against a key/value store.
regex paths - If a route as a single regular expression match, then the whole route will be matched via regex. In general, this happens inline not too dissimilar than what we see in the above example.
special regex paths - The router comes with a special path type (example: <foo:path>) that can match on an expanded delimiter. This is also true for any regex that uses the path delimiter in it. These cannot be matched in the normal course since they are of unknown length.
How active is development on sanic-org/sanic-routing?
The most recent commit recorded on sanic-org/sanic-routing was 2.9 years ago, based on the GitHub push timestamp. The repository has 10 forks — one of the better signals of community interest.
How many stars does sanic-org/sanic-routing have?
sanic-org/sanic-routing has 16 GitHub stars — refresh the page for the live number, or check github.com/sanic-org/sanic-routing. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
Is sanic-org/sanic-routing open source?
Yes — sanic-org/sanic-routing ships under the MIT license, which makes its source code freely readable (and, depending on license terms, forkable and reusable). Source: github.com/sanic-org/sanic-routing.
What else is in the Backend space?
sanic-org/sanic-routing is tracked by TopGit under the Backend category, alongside 4 GitHub-tagged topics. Trending and Topics pages list peer repositories of comparable stars and language.
What topics is sanic-org/sanic-routing associated with?
GitHub's repository topics for sanic-org/sanic-routing: "python", "routing", "sanic", "webframework". TopGit's editorial category is Backend.
Where can I see sanic-org/sanic-routing in action?
The project maintains a homepage at https://sanicframework.org/. The README tab on this page also usually contains screenshots and a quickstart.
Where do I read more about sanic-org/sanic-routing?
This TopGit page is a snapshot — the READ ME tab shows the project's own README content (links stripped, images preserved). The GitHub repository at github.com/sanic-org/sanic-routing is the definitive source.
Read full README in the tab above.
Is sanic-routing worth your time?
ChatGPT, Claude and Perplexity can all read this page. Ask one of them what it makes of sanic-routing.