Merge pull request #147 from python-ellar/file_system

File System

Author: eadwinCode

.coveragerc

@@ -12,3 +12,7 @@ exclude_lines =
     if __name__ == .__main__.:
     class .*\bProtocol\):
     @(abc\.)?abstractmethod
+[run]
+omit =
+    # omit this single file
+    ellar/core/files/storages/aws_s3.py

docs/techniques/configurations.md

@@ -138,13 +138,17 @@ It defines a list of `IExceptionHandler` objects used in handling custom excepti
 ### **STATIC_MOUNT_PATH**
 Default: `/static`
 
-It configures the root path to get to static files. eg `http://localhost:8000/static/stylesheet.css`.
-And if for instance `STATIC_MOUNT_PATH`=`'/my-static'`, then the route becomes `http://localhost:8000/my-static/stylesheet.css`
+It configures the root path to serve static files.
+For example, if there is a `stylesheet.css` in a **static** folder, and `STATIC_MOUNT_PATH=/static`,
+`stylesheet.css` can be reached through the link
+`http://localhost:8000/static/stylesheet.css` assuming you are on local development server.
+
+Also, if `STATIC_MOUNT_PATH=None`, static route handler would not be registered to application routes.
 
 ### **SERIALIZER_CUSTOM_ENCODER**
-Default: `ENCODERS_BY_TYPE` (`pydantic.json.ENCODERS_BY_TYPE`)
+Default: `ENCODERS_BY_TYPE` (`ellar.pydantic.ENCODERS_BY_TYPE`)
 
-**SERIALIZER_CUSTOM_ENCODER** is a key-value pair of type and function. Default is a pydantic JSON encode type.
+**SERIALIZER_CUSTOM_ENCODER** is a key-value pair of a type and function. Default is a pydantic JSON encode type.
 It is used when serializing objects to JSON format.
 
 ### **DEFAULT_NOT_FOUND_HANDLER**
@@ -183,7 +187,8 @@ together instead of having a separate handler for `startup` and `shutdown` event
 
 ```python
 import contextlib
-from ellar.core import App, ConfigDefaultTypesMixin
+from ellar.core import ConfigDefaultTypesMixin
+from ellar.app import App
 
 
 @contextlib.asynccontextmanager
@@ -271,7 +276,7 @@ To apply these configurations without having to load everything, you have to pro
 belongs to ellar. For example,
 
 ```python
-from ellar.core.factory import AppFactory
+from ellar.app import AppFactory
 from .root_module import ApplicationModule
 
 application = AppFactory.create_from_app_module(ApplicationModule, config_module=dict(
@@ -286,13 +291,16 @@ This will be applied to the configuration instance when the application is ready
 During application bootstrapping with `AppFactory`, you can define app configurations directly under `config_module` as a dict object as some below.
 
 ```python
-from ellar.core.factory import AppFactory
+from ellar.app import AppFactory
 from .root_module import ApplicationModule
 
-application = AppFactory.create_from_app_module(ApplicationModule, config_module=dict(
-    SECRET_KEY = "your-secret-key-changed",
-    INJECTOR_AUTO_BIND = True,
-    MIDDLEWARE=[],
-    EXCEPTION_HANDLERS=[]
-))
+application = AppFactory.create_from_app_module(
+    ApplicationModule, 
+    config_module=dict(
+        SECRET_KEY = "your-secret-key-changed",
+        INJECTOR_AUTO_BIND = True,
+        MIDDLEWARE=[],
+        EXCEPTION_HANDLERS=[]
+    )
+)
 ```

ellar/app/factory.py

@@ -167,8 +167,7 @@ def _get_config_kwargs() -> t.Dict:
 
         if module_changed:
             app.router.extend(routes)
-            app.reload_static_app()
-            app.rebuild_middleware_stack()
+            app.rebuild_stack()
 
         return app
 

ellar/app/main.py

@@ -31,11 +31,12 @@
     ModuleSetup,
     ModuleTemplateRef,
 )
-from ellar.core.routing import ApplicationRouter
+from ellar.core.routing import ApplicationRouter, AppStaticFileMount
 from ellar.core.services import Reflector
 from ellar.core.versioning import BaseAPIVersioning, VersioningSchemes
 from ellar.di import EllarInjector
-from starlette.routing import BaseRoute, Mount
+from jinja2 import Environment as JinjaEnvironment
+from starlette.routing import BaseRoute
 
 from .lifespan import EllarApplicationLifespan
 from .mixin import AppMixin
@@ -67,12 +68,11 @@ def __init__(
 
         self._user_middleware = list(t.cast(list, self.config.MIDDLEWARE))
 
-        self._static_app: t.Optional[ASGIApp] = None
-
         self.state = State()
         self.config.DEFAULT_LIFESPAN_HANDLER = (
             lifespan or self.config.DEFAULT_LIFESPAN_HANDLER
         )
+
         self.router = ApplicationRouter(
             routes=self._get_module_routes(),
             redirect_slashes=self.config.REDIRECT_SLASHES,
@@ -81,10 +81,20 @@ def __init__(
                 self.config.DEFAULT_LIFESPAN_HANDLER  # type: ignore[arg-type]
             ).lifespan,
         )
+        if (
+            self.config.STATIC_MOUNT_PATH
+            and self.config.STATIC_MOUNT_PATH not in self.router.routes
+        ):
+            self.router.append(AppStaticFileMount(self))
+
         self._finalize_app_initialization()
         self.middleware_stack = self.build_middleware_stack()
         self._config_logging()
 
+        self.reload_event_manager += lambda app: self._update_jinja_env_filters(  # type:ignore[misc]
+            self.jinja_environment
+        )
+
     def _config_logging(self) -> None:
         log_level = (
             self.config.LOG_LEVEL.value
@@ -106,26 +116,8 @@ def _config_logging(self) -> None:
             logging.getLogger("ellar").setLevel(log_level)
             logging.getLogger("ellar.request").setLevel(log_level)
 
-    def _statics_wrapper(self) -> t.Callable:
-        async def _statics_func_wrapper(
-            scope: TScope, receive: TReceive, send: TSend
-        ) -> t.Any:
-            assert self._static_app, 'app static ASGIApp can not be "None"'
-            return await self._static_app(scope, receive, send)
-
-        return _statics_func_wrapper
-
     def _get_module_routes(self) -> t.List[BaseRoute]:
         _routes: t.List[BaseRoute] = []
-        if self.has_static_files:
-            self._static_app = self.create_static_app()
-            _routes.append(
-                Mount(
-                    str(self.config.STATIC_MOUNT_PATH),
-                    app=self._statics_wrapper(),
-                    name="static",
-                )
-            )
 
         for _, module_ref in self._injector.get_modules().items():
             _routes.extend(module_ref.routes)
@@ -157,9 +149,8 @@ def install_module(
         module_ref.run_module_register_services()
         if isinstance(module_ref, ModuleTemplateRef):
             self.router.extend(module_ref.routes)
-            self.reload_static_app()
 
-        self.rebuild_middleware_stack()
+        self.rebuild_stack()
 
         return t.cast(T, module_ref.get_module_instance())
 
@@ -189,12 +180,6 @@ def injector(self) -> EllarInjector:
     def versioning_scheme(self) -> BaseAPIVersioning:
         return t.cast(BaseAPIVersioning, self._config.VERSIONING_SCHEME)
 
-    @property
-    def has_static_files(self) -> bool:  # type: ignore
-        return (
-            True if self.static_files or self.config.STATIC_FOLDER_PACKAGES else False
-        )
-
     @property
     def config(self) -> "Config":
         return self._config
@@ -298,7 +283,9 @@ def _finalize_app_initialization(self) -> None:
         self.injector.container.register_instance(self)
         self.injector.container.register_instance(self.config, Config)
         self.injector.container.register_instance(self.jinja_environment, Environment)
-        self.injector.container.register_instance(self.jinja_environment, Environment)
+        self.injector.container.register_instance(
+            self.jinja_environment, JinjaEnvironment
+        )
 
     def add_exception_handler(
         self,
@@ -310,10 +297,11 @@ def add_exception_handler(
                 self._exception_handlers.append(exception_handler)
                 _added_any = True
         if _added_any:
-            self.rebuild_middleware_stack()
+            self.rebuild_stack()
 
-    def rebuild_middleware_stack(self) -> None:
+    def rebuild_stack(self) -> None:
         self.middleware_stack = self.build_middleware_stack()
+        self.reload_event_manager.run(self)
 
     @property
     def reflector(self) -> Reflector:

ellar/app/mixin.py

@@ -1,6 +1,5 @@
 import json
 import typing as t
-from abc import abstractmethod
 
 from ellar.common.compatible import cached_property
 from ellar.common.constants import TEMPLATE_FILTER_KEY, TEMPLATE_GLOBAL_KEY
@@ -14,8 +13,8 @@
 from ellar.common.types import ASGIApp
 from ellar.core.conf import Config
 from ellar.core.connection import Request
-from ellar.core.staticfiles import StaticFiles
 from ellar.di import EllarInjector
+from ellar.events import EventManager
 from jinja2 import Environment as BaseEnvironment
 from starlette.templating import pass_context
 
@@ -27,15 +26,8 @@ class AppMixin(JinjaTemplating):
     _static_app: t.Optional[ASGIApp]
     _injector: EllarInjector
     _config: Config
-    has_static_files: bool
-
-    @abstractmethod
-    def build_middleware_stack(self) -> t.Callable:  # pragma: no cover
-        pass
-
-    @abstractmethod
-    def rebuild_middleware_stack(self) -> None:  # pragma: no cover
-        pass
+    rebuild_stack: t.Callable
+    reload_event_manager = EventManager()
 
     def get_module_loaders(self) -> t.Generator[ModuleTemplating, None, None]:
         for loader in self._injector.get_templating_modules().values():
@@ -50,7 +42,7 @@ def debug(self, value: bool) -> None:
         del self.__dict__["jinja_environment"]
         self._config.DEBUG = value
         # TODO: Add warning
-        self.rebuild_middleware_stack()
+        self.rebuild_stack()
 
     @cached_property
     def jinja_environment(self) -> BaseEnvironment:  # type: ignore[override]
@@ -94,26 +86,6 @@ def url_for(context: dict, name: str, **path_params: t.Any) -> URL:
     def create_global_jinja_loader(self) -> JinjaLoader:
         return JinjaLoader(t.cast("App", self))
 
-    def create_static_app(self) -> ASGIApp:
-        return StaticFiles(
-            directories=self.static_files,  # type: ignore[arg-type]
-            packages=self._config.STATIC_FOLDER_PACKAGES,
-        )
-
-    def reload_static_app(self) -> None:
-        del self.__dict__["static_files"]
-        if self.has_static_files:
-            self._static_app = self.create_static_app()
-        self._update_jinja_env_filters(self.jinja_environment)
-
     def _update_jinja_env_filters(self, jinja_environment: BaseEnvironment) -> None:
         jinja_environment.globals.update(self._config.get(TEMPLATE_GLOBAL_KEY, {}))
         jinja_environment.filters.update(self._config.get(TEMPLATE_FILTER_KEY, {}))
-
-    @cached_property
-    def static_files(self) -> t.List[str]:
-        static_directories = t.cast(t.List, self._config.STATIC_DIRECTORIES or [])
-        for module in self.get_module_loaders():
-            if module.static_directory:
-                static_directories.append(module.static_directory)
-        return static_directories

ellar/common/datastructures.py

@@ -1,4 +1,5 @@
 import typing as t
+from io import BytesIO, StringIO
 
 from ellar.pydantic import as_pydantic_validator
 from starlette.datastructures import (
@@ -36,6 +37,7 @@
     "UploadFile",
     "URLPath",
     "State",
+    "ContentFile",
 ]
 
 
@@ -89,3 +91,18 @@ def __validate_input__(cls, __input_value: t.Any, _: t.Any) -> "UploadFile":
             filename=__input_value.filename,
             headers=__input_value.headers,
         )
+
+
+class ContentFile(UploadFile):
+    """
+    A File-like object that takes just raw content, rather than an actual file.
+    """
+
+    def __init__(
+        self, content: t.Union[str, bytes], name: t.Optional[str] = None
+    ) -> None:
+        stream_class = StringIO if isinstance(content, str) else BytesIO
+        headers = Headers({"content-type": "text/plain"})
+        super().__init__(
+            stream_class(content), filename=name, size=len(content), headers=headers
+        )

ellar/common/decorators/controller.py

@@ -48,28 +48,35 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
                     )
                 reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, item)
 
-                parameter = item.__dict__[ROUTE_OPERATION_PARAMETERS]
+                parameters = item.__dict__[ROUTE_OPERATION_PARAMETERS]
                 operation: t.Union[
                     ControllerRouteOperation, ControllerWebsocketRouteOperation
                 ]
-                if isinstance(parameter, RouteParameters):
-                    operation = ControllerRouteOperation(**parameter.dict())
-                elif isinstance(parameter, WsRouteParameters):
-                    operation = ControllerWebsocketRouteOperation(**parameter.dict())
-                else:  # pragma: no cover
-                    logger.warning(
-                        f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
+
+                if not isinstance(parameters, list):
+                    parameters = [parameters]
+
+                for parameter in parameters:
+                    if isinstance(parameter, RouteParameters):
+                        operation = ControllerRouteOperation(**parameter.dict())
+                    elif isinstance(parameter, WsRouteParameters):
+                        operation = ControllerWebsocketRouteOperation(
+                            **parameter.dict()
+                        )
+                    else:  # pragma: no cover
+                        logger.warning(
+                            f"Parameter type is not recognized. {type(parameter) if not isinstance(parameter, type) else parameter}"
+                        )
+                        continue
+
+                    reflect.define_metadata(
+                        CONTROLLER_OPERATION_HANDLER_KEY,
+                        [operation],
+                        cls,
                     )
-                    continue
 
                 del item.__dict__[ROUTE_OPERATION_PARAMETERS]
 
-                reflect.define_metadata(
-                    CONTROLLER_OPERATION_HANDLER_KEY,
-                    [operation],
-                    cls,
-                )
-
 
 @t.no_type_check
 def Controller(

ellar/common/responses/models/base.py

@@ -6,7 +6,7 @@
 from ellar.common.exceptions import RequestValidationError
 from ellar.common.interfaces import IExecutionContext, IResponseModel
 from ellar.common.logging import request_logger
-from ellar.common.serializer import BaseSerializer, SerializerFilter
+from ellar.common.serializer import BaseSerializer, SerializerFilter, serialize_object
 from ellar.pydantic import ModelField, create_model_field
 from ellar.reflect import reflect
 from starlette.responses import Response
@@ -204,7 +204,18 @@ def serialize(
         response_obj: t.Any,
         serializer_filter: t.Optional[SerializerFilter] = None,
     ) -> t.Union[t.List[t.Dict], t.Dict, t.Any]:
-        return response_obj
+        return self._serialize_with_serializer_object(response_obj)
+
+    def _serialize_with_serializer_object(
+        self,
+        response_obj: t.Any,
+        serializer_filter: t.Optional[SerializerFilter] = None,
+    ) -> t.Union[t.List[t.Dict], t.Dict, t.Any]:
+        try:
+            return serialize_object(response_obj, serializer_filter=serializer_filter)
+        except Exception:  # pragma: no cover
+            """Could not serialize response obj"""
+            return response_obj
 
 
 class ResponseResolver(t.NamedTuple):