@api.route(
    r'/image/iiif/'
    r'<image_id>/'
    r'<region:full|square|\d+,\d+,\d+,\d+>/'
    r'<size:max|\d+,|,\d+|\d+,\d+>/'
    r'<rotation:int>/'
    r'default.jpg')

>>> from sanic_routing.utils import path_to_parts
>>> s = (
...     r'/image/iiif/'
...     r'<image_id>/'
...     r'<region:full|square|\d+,\d+,\d+,\d+>/'
...     r'<size:max|\d+,|,\d+|\d+,\d+>/'
...     r'<rotation:int>/'
...     r'default.jpg')
>> path_to_parts(s)
('image', 'iiif', '<image_id>/<region:full|square|\\d+,\\d+,\\d+,\\d+>', '<size:max|\\d+,|,\\d+|\\d+,\\d+>', '<rotation:int>', 'default.jpg')

@app.get("/invoice/<invoice_id:ext:pdf|txt>")
async def invoice_handler(request, invoice_id, ext):
    ...

from sanic import Sanic
from sanic.response import text

app = Sanic('app')

@app.route("/test/<x:int>", unquote=True)
async def handler(request, x: int):
    return text(f'hi {x}')

if __name__=='__main__':
    app.run(port=4321, debug=True)

if num == 4:  # CHECK 1
    try:
        basket['__matches__'][3] = int(parts[3])
    except ValueError:
        pass
    else:
        basket['__matches__'][3] = unquote(basket['__matches__'][3])

from sanic import Sanic, response

app = Sanic("MyApp", strict_slashes=False)


async def hello_world(request, *args, **kwargs):
  return response.text('Hello World!')


async def catch_all(request, path):
  return response.text(f'Caught one: {path}')


app.add_route(hello_world, '/hello/')  # same behavior using '/hello'
app.add_route(catch_all, '/<path:path>')

if __name__ == '__main__':
  app.run(port=8080)

from multiprocessing import Process
import time

import requests
from sanic import Blueprint, HTTPResponse, Request, Sanic


async def get(request: Request, *args, **kwargs) -> HTTPResponse:
    print(request.route.path)
    print(args)
    print(kwargs)
    return HTTPResponse()


bp0 = Blueprint(name='base')
bp1 = Blueprint(name='first', url_prefix='/<first>')
bp2 = Blueprint(name='second', url_prefix='/<first>/<second>')
bp3 = Blueprint(name='third', url_prefix='/<first>/<second>/<third>')

bp0.add_route(get, '/')
bp1.add_route(get, '/')
bp2.add_route(get, '/')
bp3.add_route(get, '/')

app = Sanic(name='test')
app.blueprint(bp0)
app.blueprint(bp1)
app.blueprint(bp2)
app.blueprint(bp3)

p = Process(target=app.run, kwargs={'port': 9000})
try:
    p.start()
    time.sleep(2)

    print(requests.get('http://localhost:9000/'))
    print(requests.get('http://localhost:9000/1'))
    print(requests.get('http://localhost:9000/1/2'))
    print(requests.get('http://localhost:9000/1/2/3'))
finally:
    p.terminate()

def find_route(path, router, basket, extra):
    parts = tuple(path[1:].split(router.delimiter))
    try:
        route = router.static_routes[parts]
        basket['__raw_path__'] = path
        return route, basket
    except KeyError:
        pass
    num = len(parts)
    if num > 0:
        basket[0] = parts[0]
        if num > 1:
            basket[1] = parts[1]
            if num == 3:
                basket[2] = parts[2]
                try:
                    basket['__params__']['first'] = str(basket[0])
                    basket['__params__']['second'] = str(basket[1])
                    basket['__params__']['third'] = str(basket[2])
                except ValueError:
                    ...
                else:
                    basket['__raw_path__'] = '<first>/<second>/<third>'
                    return router.dynamic_routes[('<first>', '<second>', '<third>')], basket
    try:
        basket['__params__']['first'] = str(basket[0])
        basket['__params__']['second'] = str(basket[1])
    except ValueError:
        ...
    else:
        basket['__raw_path__'] = '<first>/<second>'
        return router.dynamic_routes[('<first>', '<second>')], basket
try:
basket['__params__']['first'] = str(basket[0])
except ValueError:
...
else:
basket['__raw_path__'] = '<first>'
return router.dynamic_routes[('<first>',)], basket

router.register_pattern("ipv4", ipaddress.ip_address, r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$")

@app.route("/foo/<ip:ipv4>")
async def handler(request, ip: IPv4Address):
    ....

app.route("/<foo>/", strict_slashes=True)(lambda _: text("..."))
app.route("/<foo>/", strict_slashes=True, host="foo.com")(
    lambda _: text("...")
)

# tree.py
    def _inject_requirements(self, location, indent):
        for idx, reqs in self.route.requirements.items():
            conditional = "if" if idx == 0 else "elif"

    def _inject_requirements(self, location, indent):
        for k, (idx, reqs) in enumerate(self.route.requirements.items()):
            conditional = "if" if k == 0 else "elif"

app.route("/<foo>")(lambda _, **__: text("..."))
app.route("/<foo>", host="foo.com")(lambda _: text("..."))

def find_route(path, router, basket, extra):
    parts = tuple(path[1:].split(router.delimiter))
    num = len(parts)
    if num > 0:
        basket[0] = parts[0]
        if extra == {'host': 'foo.com'}:
            basket['__handler_idx__'] = 1
        else:
            raise NotFound
        try:
            basket['__params__']['foo'] = str(basket[0])
        except ValueError:
            ...
        else:
            basket['__raw_path__'] = '<foo>'
            return router.dynamic_routes[('<foo>',)], basket
    raise NotFound

def find_route(path, router, basket, extra):
    parts = tuple(path[1:].split(router.delimiter))
    num = len(parts)
    if num > 0:
        basket[0] = parts[0]
        if extra == {'host': 'foo.com'}:
            basket['__handler_idx__'] = 1

        try:
            basket['__params__']['foo'] = str(basket[0])
        except ValueError:
            ...
        else:
            basket['__raw_path__'] = '<foo>'
            return router.dynamic_routes[('<foo>',)], basket
    raise NotFound

from sanic import Sanic, Blueprint
from sanic.response import HTTPResponse
from sanic.views import HTTPMethodView

app = Sanic(name='test')


@app.get(uri='/with-func', name='get-func')
def handler_str(request):
    print(None)
    return HTTPResponse()


@app.get(uri='/with-func/str/<identifier>', name='str-id-get-func')
def handler_str(request, identifier: str):
    print(identifier, type(identifier))
    return HTTPResponse()


@app.get(uri='/with-func/int/<identifier:int>', name='int-id-get-func')
def handler_int(request, identifier: int):
    print(identifier, type(identifier))
    return HTTPResponse()


class StrView(HTTPMethodView, attach=app, uri='/with-view', name='get-view'):
    @staticmethod
    def get(request):
        print(None)
        return HTTPResponse()


class StrView(HTTPMethodView, attach=app, uri='/with-view/str/<identifier>', name='str-id-get-view'):
    @staticmethod
    def get(request, identifier):
        print(identifier, type(identifier))
        return HTTPResponse()


class IntView(HTTPMethodView, attach=app, uri='/with-view/int/<identifier:int>', name='int-id-get-view'):
    @staticmethod
    def get(request, identifier: int):
        print(identifier, type(identifier))
        return HTTPResponse()


app.run(host='localhost', port=8080, single_process=True)

from httpx import get, post

paths = [
    '/with-func',
    '/with-func/str/test',
    '/with-func/int/1',
    '/with-view',
    '/with-view/str/test',
    '/with-view/int/1'
]

for path in paths:
    print(path)

    for method in [get, post]:
        response = method(f'http://localhost:8080{path}')
        print(f'\t{method.__name__:8}{response}')

app.router.register_pattern(
    "ipv4",
    ipaddress.ip_address,
    IP_ADDRESS_PATTERN,
)

@property
def uri(self):
    return f"/{self.path}"

def test_failing():

    def handler1():
        return "handler1"

    def handler2():
        return "handler2"

    router = Router()
    router.add("/v1/c", handler1, methods=["GET"])
    router.add("/v1/c/<c_id:int>", handler2, methods=["GET"])
    router.add("/v1/c/<c_id:int>/e", handler1, methods=["GET"])
    router.add("/v1/c/<c_id:int>/e/<e_id:int>", handler2, methods=["GET"])
    router.add("/v1/c/<c_id:int>/f", handler1, methods=["GET"])
    router.add("/v1/c/<c_id:int>/f/<f_id:int>", handler2, methods=["GET"])
    # Comment next line to pass the test
    router.add("/v1/c/<c_id:int>/d", handler1, methods=["GET"])
    router.add("/v1/c/<c_id:int>/d/<d_id:int>", handler2, methods=["GET"])
    router.finalize()


    _, handler, params = router.get("/v1/c", "GET")
    assert handler() == "handler1"
    assert params == {}

    _, handler, params = router.get("/v1/c/123", "GET")
    assert handler() == "handler2"
    assert params == {"c_id": 123}

    _, handler, params = router.get("/v1/c/123/e", "GET")
    assert handler() == "handler1"
    assert params == {"c_id": 123}

    _, handler, params = router.get("/v1/c/123/e/456", "GET")
    assert handler() == "handler2"
    assert params == {"c_id": 123, "e_id": 456}

    _, handler, params = router.get("/v1/c/123/f", "GET")
    assert handler() == "handler1"
    assert params == {"c_id": 123}

    _, handler, params = router.get("/v1/c/123/f/890", "GET")
    assert handler() == "handler2"
    assert params == {"c_id": 123, "f_id": 890}

"/<foo>"
r"/<foo>/<invoice:(?P<invoice>[0-9]+)\.pdf>"

def find_route(path, method, router, basket, extra):
    parts = tuple(path[1:].split(router.delimiter))
    num = len(parts)
    if parts[0]:
        if parts[0] == "v2":
            if num > 1:
                basket[1] = parts[1]
                if num > 3:
                    ...
                elif num == 3:
                    basket[2] = parts[2]
                    ...
                if num > 2:
                    raise NotFound
                try:
                    basket['__params__']['foo'] = str(basket[1])
                except (ValueError, KeyError):
                    pass
                else:
                    if method in frozenset({'OPTIONS'}):
                        route_idx = 0
                    elif method in frozenset({'GET'}):
                        route_idx = 1
                    else:
                        raise NoMethod
                    return router.dynamic_routes[('v2', '<foo>')][route_idx], basket
    match = router.matchers[0].match(path)
    if match:
        basket['__params__'] = match.groupdict()
        if method in frozenset({'OPTIONS'}):
            route_idx = 0
        elif method in frozenset({'GET'}):
            route_idx = 1
        else:
            raise NoMethod
        return router.regex_routes[('v2', '<foo>', '<invoice:(?P<invoice>[0-9]+)\\.pdf>')][route_idx], basket
    raise NotFound
matchers = [
    re.compile(r'^/v2/<foo>/(?P<invoice>[0-9]+)\.pdf$'),
]

def test_use_route_test_bug2():
    router = Router()
    def h1(foo):
        return "first"
    router.add("/<foo:int>", h1)
    def h2(foo):
        return "second"
    router.add("/<foo:int>/bar", h2)

    router.finalize()
    with pytest.raises(NotFound):
        router.get("/foo/aaaa", "BASE")  #<-- This raises NotFound as expected
    with pytest.raises(NotFound):
        router.get("/0/aaaa", "BASE")  #<-- This returns route h1, should raise NotFound.

def find_route(path, router, basket, extra):
    parts = tuple(path[1:].split(router.delimiter))
    num = len(parts)
    if num > 0:
        basket[0] = parts[0]
        if num == 2:
            if parts[1] == "bar":
                try:
                    basket['__params__']['foo'] = int(basket[0])
                except ValueError:
                    ...
                else:
                    basket['__raw_path__'] = '<foo:int>/bar'
                    return router.dynamic_routes[('<foo:int>', 'bar')], basket
        try:
            basket['__params__']['foo'] = int(basket[0])
        except ValueError:
            ...
        else:
            basket['__raw_path__'] = '<foo:int>'
            return router.dynamic_routes[('<foo:int>',)], basket
    raise NotFound

from sanic import Sanic
from sanic.response import text

app = Sanic("MyHelloWorldApp")

@app.get("/<id:int>/<subpath:path>")
async def hello_world(request, id, subpath):
    return text(str(type(id)))

        return (
            child.dynamic,
            len(child._children),
            key,
            bool(child.group and child.group.regex),
            type_ * -1,
        )

        return (
            child.dynamic,
            len(child._children),
            bool(child.group and child.group.regex),
            type_ * -1,
            key,
        )

app = Sanic()

@app.get("/login")
async def login(request):
    ...

@app.get("/logout")
async def logout(request):
    ...

@app.get("/metrics")
async def metrics(request):
    ...

@app.route("/<mypath:path>")
async def fallback(request, mypath: str):
    # all other routes go to this handler
    ...

@app.get("/login", priority=1)
async def login(request):
    ...

@app.route("/<mypath:path>", priority=9)
async def fallback(request, mypath: str):
    # this handler is evaluated after those with higher priority (lower number)
    ...

@app.route("/<mypath:fallback>")
async def fallback(request, mypath: str):
    # this handler is evaluated after those with higher priority (lower number)
    ...

{
    "/some/path": set("GET", "POST")
}

    def _finalize_methods(self):
        self.methods = set()
        for handlers in self.handlers.values():
            self.methods.update(set(key.upper() for key in handlers.keys()))

from sanic import Sanic, Request, HTTPResponse

app = Sanic('zzz')


@app.get(f'/abc/x:y')
async def main(_: Request):
    return HTTPResponse()


if __name__ == '__main__':
    app.run()

# This is router code
if need_foo:
    with codegen:
        # This is generated code
        if route == "foo":
            return handler_foo

from sanic import Sanic
from sanic.response import text

app = Sanic("MyHelloWorldApp")


@app.get("/conversation/<conversation_id:path>/story")
async def story(request, conversation_id):
    return text("story")

@app.put("/conversation/<conversation_id:path>/tracker/events")
async def put_events(request, conversation_id):
    return text("put events")

@app.post("/conversation/<conversation_id:path>/tracker/events")
async def post_events(request, conversation_id):
    return text("post events")

app.router.register_pattern(
    "nestr",
    nonempty_str,
    re.compile(r"^[^/]+$")
)

app.router.register_pattern(
    "nestr",
    nonempty_str,
    r"^[^/]+$"
)

router.add("/path", methods=("foo", "bar"))

router.add("/path", methods=("foo",))
router.add("/path", methods=("bar"))

            try:
                compiled_src = compile(
                    self.find_route_src,
                    "",
                    "exec",
                )
            except SyntaxError as e:
                lines = self.find_route_src.split("\n")
                pad = len(str(len(lines)))
                logger.error(
                    "\n".join(
                        f"{str(idx+1).rjust(pad)}: {line}"
                        for idx, line in enumerate(lines)
                    )
                )
                raise e

@app.get("/")
def index(req):
    ...

@app.websocket("/")
def websocket(req, ws):
    ...