allow wrapped lilya instances, add lilya_app (#269)

* allow wrapped lilya instances, add lilya_app
- recheck some app variables app, appilication if there is a wrapped lilya instance
- fix crash in show-urls
- fix double import in runserver
* fix ignored path
* use baselilya as type

---------

Co-authored-by: tarsil <tiago.arasilva@gmail.com>

Author: devkral

docs/en/docs/release-notes.md

@@ -14,6 +14,20 @@ hide:
 
 ### Changed
 
+- Morph path argument into path option and expose it for all commands.
+
+### Fixed
+
+- Properly detect wrapped Lilya instances.
+- Fix crash in show-urls.
+- Fix double initialization of app in runserver.
+
+### Breaking
+
+- lilya runserver loses its path argument. You can specify it via `lilya --path foo runserver`.
+
+### Changed
+
 - Add `wrap_dependency` for inherited Controller dependencies.
 
 ## 0.20.0

lilya/cli/cli.py

@@ -79,7 +79,8 @@ def invoke(self, ctx: click.Context) -> typing.Any:
         Directives can be ignored depending of the functionality from what is being
         called.
         """
-        path = ctx.params.get("app", None)
+        app = ctx.params.get("app", None)
+        path = ctx.params.get("path", None)
 
         # Process any settings
         self.process_settings(ctx)
@@ -89,7 +90,7 @@ def invoke(self, ctx: click.Context) -> typing.Any:
         ):
             try:
                 directive = DirectiveEnv()
-                app_env = directive.load_from_env(path=path)
+                app_env = directive.load_from_env(path=app, cwd=path)
                 ctx.obj = app_env
             except EnvError as e:
                 if not any(value in sys.argv for value in IGNORE_DIRECTIVES):
@@ -132,6 +133,13 @@ def lilya_callback(
             required=False, help="Module path to the Lilya application. In a module:path format."
         ),
     ],
+    path: typing.Annotated[
+        str | None,
+        Option(
+            required=False,
+            help="A path to a Python file or package directory with ([blue]__init__.py[/blue] files) containing a [bold]Lilya[/bold] app. If not provided, Lilya will try to discover.",
+        ),
+    ],
 ) -> None: ...
 
 

lilya/cli/constants.py

@@ -6,4 +6,5 @@
 IGNORE_DIRECTIVES = ["directives"]
 DISCOVERY_FILES = ["application.py", "app.py", "main.py"]
 DISCOVERY_FUNCTIONS = ["get_application", "get_app"]
+DISCOVERY_ATTRS = ["application", "app"]
 TREAT_AS_PROJECT_DIRECTIVE = ["deployment"]

lilya/cli/directives/operations/run.py

@@ -15,10 +15,10 @@
 from lilya.cli.env import DirectiveEnv
 from lilya.cli.utils import fetch_directive
 from lilya.context import G, g_context
-from lilya.types import Lifespan
+from lilya.types import ASGIApp, Lifespan
 
 if TYPE_CHECKING:
-    from lilya.apps import ChildLilya, Lilya
+    pass
 
 T = TypeVar("T")
 
@@ -94,9 +94,9 @@ async def run(
     ## Check if application is up and execute any event
     # Shutting down after
     lifespan = generate_lifespan_events(
-        env.app.router.on_startup,
-        env.app.router.on_shutdown,
-        env.app.router.lifespan_context,
+        env.lilya_app.router.on_startup,
+        env.lilya_app.router.on_shutdown,
+        env.lilya_app.router.lifespan_context,
     )
     await execute_lifespan(env.app, lifespan, directive, program_name, position)
 
@@ -135,7 +135,7 @@ async def reset_global_context(token: Any) -> None:
 
 
 async def execute_lifespan(
-    app: Lilya | ChildLilya | None,
+    app: ASGIApp | None,
     lifespan: Lifespan,
     directive: Any,
     program_name: str,

lilya/cli/directives/operations/runserver.py

@@ -7,7 +7,7 @@
 
 import click
 from rich.tree import Tree
-from sayer import Argument, Option, command, error
+from sayer import Option, command, error
 
 from lilya.cli.env import DirectiveEnv
 from lilya.cli.exceptions import DirectiveError
@@ -42,13 +42,6 @@ def get_app_tree(module_paths: list[Path], discovery_file: str) -> Tree:
 
 @command
 def runserver(
-    path: Annotated[
-        str | None,
-        Argument(
-            required=False,
-            help="A path to a Python file or package directory with ([blue]__init__.py[/blue] files) containing a [bold]Lilya[/bold] app. If not provided, Lilya will try to discover.",
-        ),
-    ],
     port: Annotated[
         int, Option(8000, "-p", help="Port to run the development server.", show_default=True)
     ],
@@ -187,13 +180,15 @@ def runserver(
             tag="note",
         )
 
-        if debug:
-            app.debug = debug
+        if debug and env.lilya_app:
+            env.lilya_app.debug = debug
 
         toolkit.print_line()
 
         uvicorn.run(
-            app=path or env.path,
+            # in case of no reload and workers, we might end up initializing twice when
+            # using a function, so use app instead
+            app=app if not reload and not workers else env.path,
             port=port,
             host=host,
             reload=reload,

lilya/cli/directives/operations/show_urls.py

@@ -18,7 +18,7 @@
 from lilya.routing import Path
 
 if TYPE_CHECKING:
-    from lilya.apps import ChildLilya, Lilya
+    from lilya.apps import BaseLilya
     from lilya.routing import BasePath, Router
 
 console = Console()
@@ -63,14 +63,16 @@ def show_urls(env: DirectiveEnv) -> None:
             "LILYA_DEFAULT_APP environment variable."
         )
         sys.exit(1)
-
-    app = env.app
+    if getattr(env, "lilya_app", None) is None:
+        error("Not a lilya app")
+        sys.exit(1)
+    app = env.lilya_app
     table = Table(title="Application Paths")
     table = get_routes_table(app, table)
     echo(table)
 
 
-def get_routes_table(app: Lilya | ChildLilya | None, table: Table) -> Table:
+def get_routes_table(app: BaseLilya | None, table: Table) -> Table:
     """Prints the routing system"""
     table.add_column("Path", style=OutputColour.GREEN, vertical="middle")
     table.add_column("Path Parameters", style=OutputColour.BRIGHT_CYAN, vertical="middle")
@@ -79,7 +81,7 @@ def get_routes_table(app: Lilya | ChildLilya | None, table: Table) -> Table:
     table.add_column("HTTP Methods", style=OutputColour.RED, vertical="middle")
 
     def parse_routes(
-        app: Lilya | ChildLilya | Router | BasePath | None,
+        app: BaseLilya | Router | BasePath | None,
         table: Table,
         route: Any | None = None,
         prefix: str | None = "",
@@ -100,7 +102,7 @@ def parse_routes(
                     else:
                         fn_type = "sync"
 
-                http_methods = ", ".join(sorted(route.methods))
+                http_methods = ", ".join(sorted(route.methods or []))
                 parameters = ", ".join(sorted(route.stringify_parameters))
                 table.add_row(path, parameters, route.name, fn_type, http_methods)
                 continue

lilya/cli/env.py

@@ -6,9 +6,16 @@
 from importlib import import_module
 from pathlib import Path
 
-from lilya.apps import ChildLilya, Lilya
-from lilya.cli.constants import DISCOVERY_FILES, DISCOVERY_FUNCTIONS, LILYA_DISCOVER_APP
+from lilya.apps import BaseLilya, Lilya
+from lilya.cli.constants import (
+    DISCOVERY_ATTRS,
+    DISCOVERY_FILES,
+    DISCOVERY_FUNCTIONS,
+    LILYA_DISCOVER_APP,
+)
+from lilya.conf import _monkay
 from lilya.exceptions import EnvError
+from lilya.types import ASGIApp
 
 
 @dataclass
@@ -20,9 +27,10 @@ class Scaffold:
     """
 
     path: str
-    app: Lilya | ChildLilya
+    app: ASGIApp
     app_location: Path | None = None
     discovery_file: str | None = None
+    lilya_app: BaseLilya | None = None
 
 
 @dataclass
@@ -41,17 +49,23 @@ class DirectiveEnv:
     """
 
     path: str | None = None
-    app: Lilya | ChildLilya | None = None
+    app: ASGIApp | None = None
+    lilya_app: BaseLilya | None = None
     command_path: str | None = None
     module_info: ModuleInfo | None = None
 
-    def load_from_env(self, path: str | None = None) -> DirectiveEnv:
+    def load_from_env(
+        self, path: str | None = None, cwd: None | str | Path = None
+    ) -> DirectiveEnv:
         """
         Loads the environment variables into the scaffold.
         """
         # Adds the current path where the command is being invoked
         # To the system path
-        cwd = Path().cwd()
+        if cwd is None:
+            cwd = Path.cwd()
+        if not isinstance(cwd, Path):
+            cwd = Path(cwd)
         command_path = str(cwd)
         if command_path not in sys.path:
             sys.path.append(command_path)
@@ -68,6 +82,7 @@ def load_from_env(self, path: str | None = None) -> DirectiveEnv:
         return DirectiveEnv(
             path=_app.path,
             app=_app.app,
+            lilya_app=_app.lilya_app,
             command_path=command_path,
             module_info=self.get_module_data_from_path(
                 _app.app_location, _app.path, _app.discovery_file
@@ -126,7 +141,11 @@ def import_app_from_string(cls, path: str | None = None) -> Scaffold:
         module_str_path, app_name = path.split(":")
         module = import_module(module_str_path)
         app = getattr(module, app_name)
-        return Scaffold(path=path, app=app)
+        if isinstance(app, BaseLilya):
+            lilya = app
+        else:
+            lilya = _monkay.instance
+        return Scaffold(path=path, app=app, lilya_app=lilya)
 
     def _get_folders(self, path: Path) -> list[str]:
         """
@@ -151,20 +170,53 @@ def _find_app_in_folder(self, path: Path, cwd: Path) -> Scaffold | None:
 
             # Iterates through the elements of the module.
             for attr, value in module.__dict__.items():
-                if isinstance(value, Lilya):
+                if isinstance(value, BaseLilya):
                     app_path = f"{dotted_path}:{attr}"
                     return Scaffold(
-                        app=value, path=app_path, app_location=path, discovery_file=discovery_file
+                        app=value,
+                        lilya_app=value,
+                        path=app_path,
+                        app_location=path,
+                        discovery_file=discovery_file,
                     )
 
+            # Check if a lilya app has self registered and is just wrapped
+            if (lilya_instance := _monkay.instance) is not None:
+                # Iterate over default pattern application names
+                for variable in DISCOVERY_ATTRS:
+                    if app_candidate := getattr(module, variable, None):
+                        app_path = f"{dotted_path}:{variable}"
+                        return Scaffold(
+                            app=app_candidate,
+                            lilya_app=lilya_instance,
+                            path=app_path,
+                            app_location=path,
+                            discovery_file=discovery_file,
+                        )
+
             # Iterate over default pattern application functions
             for func in DISCOVERY_FUNCTIONS:
-                if hasattr(module, func):
+                if fn := getattr(module, func, None):
                     app_path = f"{dotted_path}:{func}"
-                    fn = getattr(module, func)
-                    return Scaffold(
-                        app=fn(), path=app_path, app_location=path, discovery_file=discovery_file
-                    )
+                    app_candidate = fn()
+                    if isinstance(app_candidate, Lilya):
+                        return Scaffold(
+                            app=app_candidate,
+                            lilya_app=app_candidate,
+                            path=app_path,
+                            app_location=path,
+                            discovery_file=discovery_file,
+                        )
+
+                    # monkay.instance is a dynamic property, so recheck
+                    if (lilya_instance := _monkay.instance) is not None:
+                        return Scaffold(
+                            app=app_candidate,
+                            lilya_app=lilya_instance,
+                            path=app_path,
+                            app_location=path,
+                            discovery_file=discovery_file,
+                        )
         return None
 
     def find_app(self, path: str | None, cwd: Path) -> Scaffold: