Merge pull request #9 from eadwinCode/injector_rename

Starlette Class Renames

Author: eadwinCode

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__":

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

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]

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

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__(

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)

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
         )
 

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",

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()

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)