Get decorated page endpoint

[WSH032]

Hi, thank you for developing this fantastic library. 💖

---

Question

During usage, I notice that nicegui wraps the original endpoint function, making it impossible to retrieve the actual endpoint from the scope of request

from fastapi import Request
from nicegui import ui


@ui.page("/")
def foo(request: Request):
    endpoint = request.scope.get("endpoint")
    print(endpoint)
    print(endpoint is foo)  # False

if __name__ == "__main__":
    ui.run(reload=False)

---

Feature Requests

How about adding a page_endpoints property for class nicegui.page.page,

nicegui/nicegui/page.py

Line 134 in ccab181

Client.page_routes[func] = self.path

something like:

_OriginEndpointType = Callable[..., Any]
_DecoratedEndpointType = Callable[..., Coroutine[Any, Any, Response]]

def __init__(self, ...):
    ...
    self.page_endpoints: Dict[_OriginEndpointType, _DecoratedEndpointType] = {}

def __call__(self, ...):
    ...
    return self.page_endpoints[func] = decorated

[rodja]

I wonder for what purpose you need the actual undecorated endpoint?

[rodja]

Ah, now I understand! Thanks for elaborating @WSH032. I think we could solve it by adding @wraps(func) to the async def decorated function in page.__call__. With this change the original functions metadata a preserved and you can write:

    def __call__(self, conn: HTTPConnection) -> Optional[str]:
        user = conn.cookies.get("user")
        endpoint = conn.scope.get("endpoint")
        if endpoint is not None and endpoint.__wrapped__ in self._private_page:
            if user is None:
                print('redirecting')
                raise HTTPException(307, headers={"Location": "/login"})
        return user

What do you think? It would be great if you could create a pull request and thereby become official contributor.

[WSH032]

I do agree with using @wraps(func); it can greatly improve Swagger docs.

@ui.page("/")
def index():
    """The index page."""
    ui.label("Hello")

For example, in the case of this code, previously, it could only display decorated endpoints without documentation.

After using @wraps(func), it is now able to display the actual index endpoint documentation.

---

However, for my use case, I still prefer an API similar to self.page_endpoints: Dict[_OriginEndpointType, _DecoratedEndpointType] = {}.

Authentication is not only required for nicegui's page endpoint but also for pure FastAPI endpoints, for example:

@app.get("/")
def index(user: str = Depends(user)):
    return "secret"

So, we need to execute code like this:

if endpoint in endpoint_set or (
        hasattr(endpoint, "__wrapped__") and endpoint.__wrapped__ in endpoint_set
    ):

This introduces a performance cost

import functools


def endpoint():
  return 0


@functools.wraps(endpoint)
def decorated_endpoint():
  return endpoint()


endpoint_set = {(lambda i: i) for i in range(10)}


def need_to_check_wrapped(endpoint):
  if endpoint in endpoint_set or (
      hasattr(endpoint, "__wrapped__") and endpoint.__wrapped__ in endpoint_set
  ):
      return True


def no_need_to_check_wrapped(endpoint):
  if endpoint in endpoint_set:
      return True


%timeit need_to_check_wrapped(decorated_endpoint) ; need_to_check_wrapped(endpoint)
%timeit no_need_to_check_wrapped(decorated_endpoint) ; no_need_to_check_wrapped(endpoint)

322 ns ± 5.34 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
201 ns ± 1.97 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Another consideration is:

• what if other users still want to obtain decorated endpoints in advance for other purposes?
• In the authentication example provided earlier, the code logic was written by me, so I could easily modify the code. But what if it's another third-party authentication library?

[WSH032]

Using weakref.WeakKeyDictionary, we can introduce this new API with minimal performance loss. Additionally, deprecating it is straightforward. All that needs to be done is:

- self.page_endpoints[func] = decorated
+ self.page_endpoints[func] = func

---

You have been maintaining NiceGUI for a long time, and I may not have the same foresight in API design and maintenance as you do. I apologize if I am making too many requests.

The solution you provided already meets my needs. I am happy to initiate a pull request. Please give me some time to study the CONTRIBUTING.md guidelines.

Let me know your thoughts, thank you!

[rodja]

I just created pull request #2412 to add the @wraps decorator.

@WSH032 the diff is surely bigger than changing decorated to func because we do not have page_endpoints yet. While your arguments are sound, I'm still not sure if it's the best approach. Could you maybe create a pull request including an example of the usage? That would help a lot.

[WSH032]

After merging #2412, I came up with a compromise:

from collections import defaultdict

from nicegui import APIRouter, ui
from fastapi.routing import APIRoute

private_router = APIRouter()


@private_router.page("/private")
def private_page():
    ui.label("secret")


def build_endpoint_map(router: APIRouter):
    map_ = defaultdict(list)

    for route in router.routes:
        if isinstance(route, APIRoute) and hasattr(route.endpoint, "__wrapped__"):
            map_[route.endpoint.__wrapped__].append(route.endpoint)

    return map_

page_endpoints = build_endpoint_map(private_router)

This way, we maintain our own page_endpoints.

---

This approach still has some drawbacks:

• Lack of type annotation support for __wrapped__.
  

• @wraps is an internal implementation detail of NiceGUI, and it seems it should not be considered a stable API?

---

Could you maybe create a pull request including an example of the usage?

I haven't come up with a better solution either. For me, the current solution completely satisfies my use case, so it seems we should close this discussion for now?

Thank you very much for your assistance!