python-ellar · eadwinCode · Jul 27, 2022 · Jul 26, 2022 · Jul 26, 2022
diff --git a/ellar/cli.py b/ellar/cli.py
@@ -1,15 +1,15 @@
 from typer import Typer, echo
 
-app = Typer()
+_typer = Typer()
 
 
-@app.command()
+@_typer.command()
 def init(name: str):
     echo(f"Welcome {name} to Ellar CLI, python web framework")
 
 
 def main():
-    app(prog_name="Ellar, Python Web framework")
+    _typer(prog_name="Ellar, Python Web framework")
 
 
 if __name__ == "__main__":

diff --git a/ellar/common/decorators/html.py b/ellar/common/decorators/html.py
@@ -28,7 +28,7 @@ def render(template_name: t.Optional[str] = NOT_SET) -> t.Callable:
     if template_name is not NOT_SET:
         assert isinstance(
             template_name, str
-        ), "Render Operation must invoked eg. @Render()"
+        ), "Render Operation must invoked eg. @render()"
     template_name = None if template_name is NOT_SET else template_name
     class_base_function_regex = re.compile(
         "<\\w+ (\\w+)\\.(\\w+) at \\w+>", re.IGNORECASE

diff --git a/ellar/core/factory.py b/ellar/core/factory.py
@@ -14,7 +14,7 @@
 from ellar.core.main import App
 from ellar.core.modules import ModuleBase
 from ellar.core.modules.ref import ModuleTemplateRef, create_module_ref_factor
-from ellar.di import ProviderConfig, StarletteInjector
+from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover
@@ -35,7 +35,7 @@ def _read_all_module(
 
     @classmethod
     def _build_modules(
-        cls, app_module: t.Type[ModuleBase], config: Config, injector: StarletteInjector
+        cls, app_module: t.Type[ModuleBase], config: Config, injector: EllarInjector
     ) -> None:
         assert reflect.get_metadata(
             MODULE_WATERMARK, app_module
@@ -69,7 +69,7 @@ def _create_app(cls, module: t.Type[ModuleBase], config_module: str = None) -> A
         assert reflect.get_metadata(MODULE_WATERMARK, module), "Only Module is allowed"
 
         config = Config(app_configured=True, config_module=config_module)
-        injector = StarletteInjector(auto_bind=t.cast(bool, config.INJECTOR_AUTO_BIND))
+        injector = EllarInjector(auto_bind=t.cast(bool, config.INJECTOR_AUTO_BIND))
         cls._build_modules(app_module=module, injector=injector, config=config)
 
         shutdown_event = config[ON_REQUEST_STARTUP_KEY]

diff --git a/ellar/core/main.py b/ellar/core/main.py
@@ -18,7 +18,7 @@
 from ellar.core.routing import ApplicationRouter
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
-from ellar.di.injector import StarletteInjector
+from ellar.di.injector import EllarInjector
 from ellar.logger import logger
 from ellar.services.reflector import Reflector
 from ellar.types import ASGIApp, T, TReceive, TScope, TSend
@@ -28,7 +28,7 @@ class App(AppTemplating):
     def __init__(
         self,
         config: Config,
-        injector: StarletteInjector,
+        injector: EllarInjector,
         on_startup_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         on_shutdown_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         lifespan: t.Optional[t.Callable[["App"], t.AsyncContextManager]] = None,
@@ -38,8 +38,8 @@ def __init__(
     ):
         assert isinstance(config, Config), "config must instance of Config"
         assert isinstance(
-            injector, StarletteInjector
-        ), "injector must instance of StarletteInjector"
+            injector, EllarInjector
+        ), "injector must instance of EllarInjector"
 
         # The lifespan context function is a newer style that replaces
         # on_startup / on_shutdown handlers. Use one or the other, not both.
@@ -49,7 +49,7 @@ def __init__(
 
         self._config = config
         # TODO: read auto_bind from configure
-        self._injector: StarletteInjector = injector
+        self._injector: EllarInjector = injector
 
         self._global_guards = [] if global_guards is None else list(global_guards)
         self._exception_handlers = dict(t.cast(dict, self.config.EXCEPTION_HANDLERS))
@@ -141,7 +141,7 @@ def use_global_guards(self, *guards: "GuardCanActivate") -> None:
         self._global_guards.extend(guards)
 
     @property
-    def injector(self) -> StarletteInjector:
+    def injector(self) -> EllarInjector:
         return self._injector
 
     @property

diff --git a/ellar/core/middleware/di.py b/ellar/core/middleware/di.py
@@ -10,7 +10,7 @@
 from ellar.types import ASGIApp, TReceive, TScope, TSend
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.di.injector import StarletteInjector
+    from ellar.di.injector import EllarInjector
 
 
 class RequestServiceProviderMiddleware(ServerErrorMiddleware):
@@ -19,7 +19,7 @@ def __init__(
         app: ASGIApp,
         *,
         debug: bool,
-        injector: "StarletteInjector",
+        injector: "EllarInjector",
         handler: t.Callable = None
     ) -> None:
         super(RequestServiceProviderMiddleware, self).__init__(

diff --git a/ellar/core/staticfiles.py b/ellar/core/staticfiles.py
@@ -3,10 +3,10 @@
 import typing as t
 
 import anyio
-from starlette.staticfiles import PathLike, StaticFiles
+from starlette.staticfiles import PathLike, StaticFiles as StarletteStaticFiles
 
 
-class StarletteStaticFiles(StaticFiles):
+class StaticFiles(StarletteStaticFiles):
     def __init__(
         self,
         *,
@@ -15,7 +15,7 @@ def __init__(
         html: bool = False,  # TODO: expose to config
         check_dir: bool = True,  # TODO: expose to config
     ):
-        super(StarletteStaticFiles, self).__init__(
+        super(StaticFiles, self).__init__(
             html=html, packages=packages, check_dir=check_dir
         )
         self._directories = [] if directories is None else list(directories)

diff --git a/ellar/core/templating/interface.py b/ellar/core/templating/interface.py
@@ -10,7 +10,7 @@
 from ellar.compatible import cached_property
 from ellar.constants import TEMPLATE_FILTER_KEY, TEMPLATE_GLOBAL_KEY
 from ellar.core.connection import Request
-from ellar.core.staticfiles import StarletteStaticFiles
+from ellar.core.staticfiles import StaticFiles
 from ellar.types import ASGIApp, TemplateFilterCallable, TemplateGlobalCallable
 
 from ..conf import Config
@@ -19,7 +19,7 @@
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.main import App
-    from ellar.di import StarletteInjector
+    from ellar.di import EllarInjector
 
 
 class TemplateFunctionData(t.NamedTuple):
@@ -133,7 +133,7 @@ def static_directory(self) -> t.Optional[str]:
 class AppTemplating(JinjaTemplating):
     config: Config
     _static_app: t.Optional[ASGIApp]
-    _injector: "StarletteInjector"
+    _injector: "EllarInjector"
     has_static_files: bool
 
     def get_module_loaders(self) -> t.Generator[ModuleTemplating, None, None]:
@@ -192,7 +192,7 @@ def create_global_jinja_loader(self) -> JinjaLoader:
         return JinjaLoader(t.cast("App", self))
 
     def create_static_app(self) -> ASGIApp:
-        return StarletteStaticFiles(
+        return StaticFiles(
             directories=self.static_files, packages=self.config.STATIC_FOLDER_PACKAGES  # type: ignore
         )
 

diff --git a/ellar/di/__init__.py b/ellar/di/__init__.py
@@ -1,4 +1,4 @@
-from .injector import Container, RequestServiceProvider, StarletteInjector
+from .injector import Container, EllarInjector, RequestServiceProvider
 from .scopes import (
     RequestScope,
     SingletonScope,
@@ -18,7 +18,7 @@
 __all__ = [
     "Container",
     "RequestServiceProvider",
-    "StarletteInjector",
+    "EllarInjector",
     "RequestScope",
     "SingletonScope",
     "TransientScope",

diff --git a/ellar/di/injector.py b/ellar/di/injector.py
@@ -49,7 +49,7 @@ def get(self, interface: t.Type[T]) -> T:
         scope_instance = t.cast(DIScope, scope_binding.provider.get(self))
 
         log.debug(
-            "%StarletteInjector.get(%r, scope=%r) using %r",
+            "%EllarInjector.get(%r, scope=%r) using %r",
             self._log_prefix,
             interface,
             scope,
@@ -79,7 +79,7 @@ def dispose(self) -> None:
 class Container(InjectorBinder):
     __slots__ = ("injector", "_auto_bind", "_bindings", "parent")
 
-    injector: "StarletteInjector"
+    injector: "EllarInjector"
 
     @t.no_type_check
     def create_binding(
@@ -211,7 +211,7 @@ def register_services(self, container):
         return instance
 
 
-class StarletteInjector(Injector):
+class EllarInjector(Injector):
     __slots__ = ("_stack", "parent", "app", "container", "_modules")
 
     def __init__(
@@ -229,7 +229,7 @@ def __init__(
             parent=parent.binder if parent is not None else None,
         )
         # Bind some useful types
-        self.container.register_instance(self, StarletteInjector)
+        self.container.register_instance(self, EllarInjector)
         self.container.register_instance(self.binder)
         self._modules: t.DefaultDict = defaultdict(OrderedDict)
         self._modules[MODULE_REF_TYPES.TEMPLATE] = OrderedDict()

diff --git a/tests/test_di/test_injector.py b/tests/test_di/test_injector.py
@@ -3,15 +3,15 @@
 
 from ellar.common import Module
 from ellar.core import ModuleBase
-from ellar.di import Container, StarletteInjector
+from ellar.di import Container, EllarInjector
 from ellar.di.providers import ClassProvider, InstanceProvider
 
 from .examples import Foo, Foo1, Foo2
 
 
 def test_container_install_module():
     called = False
-    app_container = StarletteInjector().container
+    app_container = EllarInjector().container
 
     class FakeModule(ModuleBase):
         def register_services(self, container: Container) -> None:
@@ -36,10 +36,10 @@ def register_services(self, container: Container) -> None:
 
 
 def test_default_container_registration():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
     assert isinstance(injector.get(Container), Container)
-    assert isinstance(injector.get(StarletteInjector), StarletteInjector)
-    assert isinstance(injector.get(StarletteInjector), StarletteInjector)
+    assert isinstance(injector.get(EllarInjector), EllarInjector)
+    assert isinstance(injector.get(EllarInjector), EllarInjector)
 
     with pytest.raises(UnsatisfiedRequirement):
         injector.get(Injector)
@@ -50,7 +50,7 @@ def test_default_container_registration():
 
 @pytest.mark.asyncio
 async def test_request_service_provider():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
     injector.container.register_scoped(Foo1)
     injector.container.register_exact_transient(Foo2)
 

diff --git a/tests/test_di/test_middleware.py b/tests/test_di/test_middleware.py
@@ -7,7 +7,7 @@
 from ellar.core.context import IExecutionContext
 from ellar.core.middleware import RequestServiceProviderMiddleware
 from ellar.core.response import Response
-from ellar.di import StarletteInjector
+from ellar.di import EllarInjector
 
 from ..injector_module import Configuration, DummyModule
 
@@ -70,7 +70,7 @@ async def assert_iexecute_context_app(scope, receive, send):
 
 
 def test_di_middleware(test_client_factory):
-    injector_ = StarletteInjector()
+    injector_ = EllarInjector()
     injector_.container.install(DummyModule)
     asgi_app = RequestServiceProviderMiddleware(
         assert_service_provider_app, debug=False, injector=injector_
@@ -87,7 +87,7 @@ def test_di_middleware(test_client_factory):
 
 def test_di_middleware_execution_context_initialization(test_client_factory):
     asgi_app = RequestServiceProviderMiddleware(
-        assert_iexecute_context_app, debug=False, injector=StarletteInjector()
+        assert_iexecute_context_app, debug=False, injector=EllarInjector()
     )
 
     client = test_client_factory(asgi_app)

diff --git a/tests/test_di/test_provider_scopes.py b/tests/test_di/test_provider_scopes.py
@@ -1,6 +1,6 @@
 import pytest
 
-from ellar.di import ProviderConfig, StarletteInjector
+from ellar.di import EllarInjector, ProviderConfig
 from ellar.di.scopes import RequestScope, SingletonScope, TransientScope
 
 from .examples import AnyContext, Foo, IContext
@@ -23,7 +23,7 @@
     ],
 )
 def test_container_scopes(action, base_type, concrete_type, ref_type, expected_scope):
-    container = StarletteInjector().container
+    container = EllarInjector().container
     container_action = getattr(container, action)
     if concrete_type:
         container_action(base_type, concrete_type)
@@ -35,7 +35,7 @@ def test_container_scopes(action, base_type, concrete_type, ref_type, expected_s
 
 @pytest.mark.asyncio
 async def test_request_scope_instance():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
     ProviderConfig(IContext, use_class=AnyContext).register(injector.container)
 
     # resolving RequestScope Providers outside RequestServiceProvider will behaves like TransientScope

diff --git a/tests/test_di/test_providers.py b/tests/test_di/test_providers.py
@@ -6,8 +6,8 @@
 )
 
 from ellar.di import (
+    EllarInjector,
     ProviderConfig,
-    StarletteInjector,
     get_scope,
     injectable,
     is_decorated_with_injectable,
@@ -29,7 +29,7 @@
 
 
 def test_circle_dependency():
-    injector = StarletteInjector()
+    injector = EllarInjector()
     ProviderConfig(CircularDependencyType).register(injector.container)
 
     with pytest.raises(CircularDependency):
@@ -55,7 +55,7 @@ class NoneInjectType:
 
 
 def test_provider_config_registers_correctly():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
     providers = [
         ProviderConfig(Foo2),
         ProviderConfig(InjectType2),
@@ -78,7 +78,7 @@ def test_provider_config_registers_correctly():
 
 
 def test_provider_advance_use_case():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
 
     providers_advance = [
         ProviderConfig(
@@ -108,7 +108,7 @@ def test_provider_advance_use_case():
     providers_advance.append(ProviderConfig(AnyDBContext))
     providers_advance.append(ProviderConfig(FooDBCatsRepository))
 
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
 
     for provider in providers_advance:
         provider.register(injector.container)
@@ -121,7 +121,7 @@ def test_provider_advance_use_case():
 
 
 def test_module_provider_works():
-    injector = StarletteInjector(auto_bind=False)
+    injector = EllarInjector(auto_bind=False)
     ProviderConfig(Foo1, use_value=Foo1()).register(injector.container)
 
     @injectable