Merge pull request #64 from python-ellar/non_pyproject_cli

Non-PyProject Ellar CLI Support

Author: eadwinCode

README.md

@@ -11,7 +11,8 @@
 [![PyPI version](https://img.shields.io/pypi/pyversions/ellar-cli.svg)](https://pypi.python.org/pypi/ellar-cli)
 
 # Introduction
-Ellar-CLI is an abstracted tool for ellar python web framework that helps in the standard project scaffolding and managing typer and click commands.
+Ellar-CLI is an abstracted tool for the Ellar web framework
+that helps in the standard project scaffolding and other application commands.
 
 Ellar CLI is built on [Click](https://click.palletsprojects.com/en/8.1.x/)
 
@@ -22,7 +23,7 @@ pip install ellar-cli
 ```
 
 ## Usage
-To verify ellar-cli is working, run the command belove
+To verify ellar-cli is working, run the command below
 ```shell
 ellar --help
 ```
@@ -45,7 +46,6 @@ Commands:
   new             - Runs a complete Ellar project scaffold and creates...
   runserver       - Starts Uvicorn Server -
   say-hi
-
 ```
 
 Full Documentation: [Here](https://python-ellar.github.io/ellar/cli/introduction/)

ellar_cli/__init__.py

@@ -1,3 +1,3 @@
 """Ellar CLI Tool for Scaffolding Ellar Projects, Modules and also running Ellar Commands"""
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"

ellar_cli/click/__init__.py

@@ -46,7 +46,7 @@
 from .argument import Argument
 from .command import Command
 from .group import AppContextGroup, EllarCommandGroup
-from .util import with_app_context
+from .util import run_as_async, with_app_context
 
 
 def argument(
@@ -89,6 +89,8 @@ def group(
 
 __all__ = [
     "argument",
+    "run_as_async",
+    "command",
     "Argument",
     "Option",
     "option",

ellar_cli/click/group.py

@@ -3,10 +3,10 @@
 import click
 from ellar.app import AppFactory
 from ellar.common.constants import MODULE_METADATA
-from ellar.core import ModuleSetup, reflector
+from ellar.core import ModuleBase, ModuleSetup, reflector
 
 from ellar_cli.constants import ELLAR_META
-from ellar_cli.service import EllarCLIService
+from ellar_cli.service import EllarCLIService, EllarCLIServiceWithPyProject
 
 from .command import Command
 from .util import with_app_context
@@ -45,29 +45,56 @@ def group(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
 class EllarCommandGroup(AppContextGroup):
     """Overrides AppContextGroup to add loading of Ellar Application registered commands in the modules"""
 
+    def __init__(
+        self, app_import_string: t.Optional[str] = None, **kwargs: t.Any
+    ) -> None:
+        super().__init__(**kwargs)
+        meta = None
+
+        if app_import_string:
+            meta = EllarCLIServiceWithPyProject(app_import_string=app_import_string)
+
+        self._cli_meta: t.Optional[EllarCLIServiceWithPyProject] = meta
+
     def _load_application_commands(self, ctx: click.Context) -> None:
         # get project option from cli
-        app_name = ctx.params.get("project")
+        module_configs: t.Any
+        if self._cli_meta:
+            application = self._cli_meta.import_application()
 
-        # loads project metadata from pyproject.toml
-        meta_: t.Optional[EllarCLIService] = EllarCLIService.import_project_meta(
-            app_name
-        )
-        ctx.meta[ELLAR_META] = meta_
+            module_configs = (i for i in application.injector.get_modules().keys())
 
-        if meta_ and meta_.has_meta:
-            module_configs = AppFactory.get_all_modules(
-                ModuleSetup(meta_.import_root_module())
+            ctx.meta[ELLAR_META] = self._cli_meta
+        else:
+            module_configs = ()
+            app_name = ctx.params.get("project")
+
+            # loads project metadata from pyproject.toml
+            meta_: t.Optional[EllarCLIService] = EllarCLIService.import_project_meta(
+                app_name
             )
 
-            for module_config in module_configs:
-                click_commands = (
-                    reflector.get(MODULE_METADATA.COMMANDS, module_config.module) or []
-                )
+            ctx.meta[ELLAR_META] = meta_
 
-                for click_command in click_commands:
-                    if isinstance(click_command, click.Command):
-                        self.add_command(click_command, click_command.name)
+            if meta_ and meta_.has_meta:
+                module_configs = (
+                    module_config.module
+                    for module_config in AppFactory.get_all_modules(
+                        ModuleSetup(meta_.import_root_module())
+                    )
+                )
+        self._find_commands_from_modules(module_configs)
+
+    def _find_commands_from_modules(
+        self,
+        modules: t.Union[t.Sequence[ModuleBase], t.Iterator[ModuleBase], t.Generator],
+    ) -> None:
+        for module in modules:
+            click_commands = reflector.get(MODULE_METADATA.COMMANDS, module) or []
+
+            for click_command in click_commands:
+                if isinstance(click_command, click.Command):
+                    self.add_command(click_command, click_command.name)
 
     def get_command(
         self, ctx: click.Context, cmd_name: str

ellar_cli/click/util.py

@@ -1,62 +1,55 @@
 import asyncio
+import functools
 import typing as t
 from functools import update_wrapper
 
 import click
-from ellar.threading import execute_coroutine_with_sync_worker
+from ellar.threading.sync_worker import (
+    execute_async_context_manager_with_sync_worker,
+    execute_coroutine_with_sync_worker,
+)
 
 from ellar_cli.constants import ELLAR_META
 from ellar_cli.service import EllarCLIService
 
 
-def _async_run(future: t.Coroutine) -> t.Any:
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:  # no event loop running:
-        loop = asyncio.new_event_loop()
-
-    if not loop.is_running():
-        try:
-            res = loop.run_until_complete(loop.create_task(future))
-            loop.run_until_complete(loop.shutdown_asyncgens())
-        except Exception as e:
-            raise e
-        finally:
-            loop.stop()
-            loop.close()
-    else:
-        res = execute_coroutine_with_sync_worker(future)
-
-    return res
-
-
 def with_app_context(f: t.Callable) -> t.Any:
     """
     Wraps a callback so that it's guaranteed to be executed with application context.
-    Also, wrap commands can be a coroutine.
     """
 
-    async def _run_with_application_context(
-        meta_: t.Optional[EllarCLIService], *args: t.Any, **kwargs: t.Any
-    ) -> t.Any:
-        if meta_ and meta_.has_meta:
-            async with meta_.get_application_context():
-                res = f(*args, **kwargs)
-                if isinstance(res, t.Coroutine):
-                    return await res
-                return res
-
-        res = f(*args, **kwargs)
-        if isinstance(res, t.Coroutine):
-            return await res
-
     @click.pass_context
     def decorator(__ctx: click.Context, *args: t.Any, **kwargs: t.Any) -> t.Any:
-        meta_ = __ctx.meta.get(ELLAR_META)
+        meta_: t.Optional[EllarCLIService] = __ctx.meta.get(ELLAR_META)
 
-        def _get_command_args(*ar: t.Any, **kw: t.Any) -> t.Any:
-            return _async_run(_run_with_application_context(meta_, *ar, **kw))
+        if meta_ and meta_.has_meta:
+            __ctx.with_resource(
+                execute_async_context_manager_with_sync_worker(
+                    meta_.get_application_context()
+                )
+            )
 
-        return __ctx.invoke(update_wrapper(_get_command_args, f), *args, **kwargs)
+        return __ctx.invoke(f, *args, **kwargs)
 
     return update_wrapper(decorator, f)
+
+
+def run_as_async(f: t.Callable) -> t.Callable:
+    """
+    Runs async click commands
+
+    eg:
+
+    @click.command()
+    @click.argument('name')
+    @click.run_as_async
+    async def print_name(name: str):
+        click.echo(f'Hello {name}, this is an async command.')
+    """
+    assert asyncio.iscoroutinefunction(f), "Decorated function must be Coroutine"
+
+    @functools.wraps(f)
+    def _decorator(*args: t.Any, **kw: t.Any) -> t.Any:
+        return execute_coroutine_with_sync_worker(f(*args, **kw))
+
+    return _decorator

ellar_cli/main.py

@@ -10,7 +10,7 @@
 from .click import EllarCommandGroup
 from .manage_commands import create_module, create_project, new_command, runserver
 
-__all__ = ["app_cli"]
+__all__ = ["app_cli", "create_ellar_cli"]
 
 
 def version_callback(ctx: click.Context, _: t.Any, value: bool) -> None:
@@ -25,34 +25,40 @@ def version_callback(ctx: click.Context, _: t.Any, value: bool) -> None:
         raise click.Exit(0)
 
 
-@click.group(
-    name="Ellar CLI Tool... ",
-    cls=EllarCommandGroup,
-    help="Ellar, ASGI Python Web framework",
-)
-@click.option(
-    "--project",
-    show_default=True,
-    default="default",
-    help="Run Specific Command on a specific project",
-)
-@click.option(
-    "-v",
-    "--version",
-    callback=version_callback,
-    help="Show the version and exit.",
-    is_flag=True,
-    expose_value=False,
-    is_eager=True,
-)
-@click.pass_context
-def app_cli(ctx: click.Context, project: str) -> None:
-    ctx.meta[ELLAR_PROJECT_NAME] = project
-
-
-app_cli.command(name="new")(new_command)
-app_cli.command(
-    context_settings={"auto_envvar_prefix": "UVICORN"}, with_app_context=False
-)(runserver)
-app_cli.command(name="create-project")(create_project)
-app_cli.command(name="create-module")(create_module)
+def create_ellar_cli(app_import_string: t.Optional[str] = None) -> click.Group:
+    @click.group(
+        name="Ellar CLI Tool... ",
+        cls=EllarCommandGroup,
+        app_import_string=app_import_string,
+        help="Ellar, ASGI Python Web framework",
+    )
+    @click.option(
+        "--project",
+        show_default=True,
+        default="default",
+        help="Run Specific Command on a specific project",
+    )
+    @click.option(
+        "-v",
+        "--version",
+        callback=version_callback,
+        help="Show the version and exit.",
+        is_flag=True,
+        expose_value=False,
+        is_eager=True,
+    )
+    @click.pass_context
+    def _app_cli(ctx: click.Context, **kwargs: t.Any) -> None:
+        ctx.meta[ELLAR_PROJECT_NAME] = kwargs["project"]
+
+    if not app_import_string:
+        _app_cli.command(name="new")(new_command)
+        _app_cli.command(name="create-project")(create_project)
+
+    _app_cli.command(context_settings={"auto_envvar_prefix": "UVICORN"})(runserver)
+    _app_cli.command(name="create-module")(create_module)
+
+    return _app_cli  # type:ignore[no-any-return]
+
+
+app_cli = create_ellar_cli()

ellar_cli/manage_commands/runserver.py

@@ -5,7 +5,6 @@
 from datetime import datetime
 
 from ellar import __version__ as ellar_version
-from ellar.app import current_config
 from ellar.common.utils.enums import create_enums_from_list
 from uvicorn import config as uvicorn_config
 from uvicorn import run as uvicorn_run
@@ -382,6 +381,7 @@ def runserver(
         )
 
     application_import_string = ellar_project_meta.project_meta.application
+    current_config = ellar_project_meta.get_application_config()
 
     log_config = current_config.LOGGING_CONFIG
     _log_level = current_config.LOG_LEVEL

ellar_cli/schema.py

@@ -1,9 +1,22 @@
 import typing as t
 
+from ellar.app import App
+from ellar.common.compatible import AttributeDict
 from ellar.common.serializer import Serializer
+from ellar.core import ModuleBase
 from ellar.pydantic import Field
 
 
+class MetadataStore(AttributeDict):
+    app_instance: t.Optional[App]
+    config_instance: t.Optional[App]
+    is_app_reference_callable: bool
+    root_module: t.Type[ModuleBase]
+
+    def __missing__(self, name) -> None:
+        return None
+
+
 class EllarPyProjectSerializer(Serializer):
     project_name: str = Field(alias="project-name")
     application: str = Field(alias="application")

ellar_cli/service/__init__.py

@@ -0,0 +1,10 @@
+from .cli import EllarCLIService, EllarCLIServiceWithPyProject
+from .exceptions import EllarCLIException
+from .pyproject import EllarPyProject
+
+__all__ = [
+    "EllarPyProject",
+    "EllarCLIService",
+    "EllarCLIServiceWithPyProject",
+    "EllarCLIException",
+]