refactored examples

Author: eadwinCode

examples/catapp/application/cats/controllers.py

@@ -1,30 +1,31 @@
-from catapp.application.cats.services import CatService
-from ellar.common import Controller, Get, Put, Post, Delete, version, Render, Ctx
+from ellar.common import Controller, Ctx, delete, get, put, render, version
+
+from .services import CatService
 
 
 @Controller
 class CatController:
     def __init__(self, cat_service: CatService) -> None:
         self.cat_service = cat_service
 
-    @Get("/create")
+    @get("/create")
     async def create_cat(self):
         return self.cat_service.create_cat()
 
-    @Put("/{cat_id:int}")
+    @put("/{cat_id:int}")
     async def update_cat(self, cat_id: int):
         return self.cat_service.update_cat(cat_id)
 
-    @Delete("/{cat_id:int}")
+    @delete("/{cat_id:int}")
     async def deleted_cat(self, cat_id: int):
         return self.cat_service.deleted_cat(cat_id)
 
-    @Get("/")
-    @Render()
+    @get("/")
+    @render()
     async def list(self, ctx=Ctx()):
         return self.cat_service.list_cat()
 
-    @Get("/create", name='v2_create')
+    @get("/create", name='v2_create')
     @version('v2')
     async def create_cat_v2(self):
         return self.cat_service.create_cat()

examples/catapp/application/cats/module.py

@@ -1,9 +1,9 @@
+from ellar.common import Module
 from ellar.core.modules import ModuleBase
 
-from catapp.application.cats.controllers import CatController
-from catapp.application.cats.routers import cat_router
-from catapp.application.cats.services import CatService, AnotherService
-from ellar.common import Module
+from .controllers import CatController
+from .routers import cat_router
+from .services import AnotherService, CatService
 
 
 @Module(

examples/catapp/application/cats/routers.py

@@ -1,11 +1,12 @@
-from typing import List
 from dataclasses import dataclass
+from typing import List
 
-from catapp.application.cats.services import CatService
-from ellar.serializer import DataclassSerializer
+from ellar.common import Provide, render, Req
 from ellar.core.routing import ModuleRouter
-from ellar.common import Provide, Req, Render
 from ellar.core.templating import render_template
+from ellar.serializer import DataclassSerializer
+
+from .services import CatService
 
 cat_router = ModuleRouter("/cats-router", tag='Testing')
 
@@ -15,17 +16,17 @@ class CatObject(DataclassSerializer):
     name: str
 
 
-@cat_router.Get(response={200: List[CatObject]})
+@cat_router.get(response={200: List[CatObject]})
 async def get_cats(request=Req(), service: CatService = Provide()):
     return service.list_cat()
 
 
-@cat_router.HttpRoute('/html', methods=['get', 'post'])
-@Render("index.html")
+@cat_router.http_route('/html', methods=['get', 'post'])
+@render("index.html")
 async def get_cat_help(service: CatService = Provide()):
     return service.list_cat()
 
 
-@cat_router.Get('/html/outside')
+@cat_router.get('/html/outside')
 async def get_outside(request, service: CatService = Provide()):
     return render_template("index.html", request=request, context=service.list_cat())

examples/catapp/application/module.py

@@ -1,8 +1,9 @@
-from catapp.application.cats.module import CatModule
-from ellar.common import ApplicationModule
+from ellar.common import Module
 
+from ..application.cats.module import CatModule
 
-@ApplicationModule(
+
+@Module(
     modules=(CatModule, )
 )
 class AppModuleTest:

examples/catapp/server.py

@@ -1,21 +1,22 @@
 import os
 
-from catapp.application.module import AppModuleTest
 from ellar.core.factory import AppFactory
 from ellar.openapi.builder import OpenAPIDocumentBuilder
 from ellar.openapi.module import OpenAPIDocumentModule
 
-os.environ.setdefault('ELLAR_CONFIG_MODULE', 'app_module_test.settings')
+from .application.module import AppModuleTest
+
+os.environ.setdefault('ELLAR_CONFIG_MODULE', 'catapp.settings')
 
 app = AppFactory.create_from_app_module(AppModuleTest)
 
 document_builder = OpenAPIDocumentBuilder()
-document_builder.set_title('Mirabel Title')\
+document_builder.set_title('Cat Application')\
     .set_version('1.0.2')\
     .set_contact(name='Eadwin', url='https://www.yahoo.com', email='[email protected]')\
     .set_license('MIT Licence', url='https://www.google.com')
 
 document = document_builder.build_document(app)
-module = app.install_module(OpenAPIDocumentModule, app=app, document=document)
+module = app.install_module(OpenAPIDocumentModule, document=document)
 module.setup_redocs()
 module.setup_swagger_doc()

examples/catapp/tests/test_application.py

@@ -1,11 +1,11 @@
 import os
-import pytest
-
 from pathlib import Path
-from catapp.application.cats.routers import cat_router
 
+import pytest
 from ellar.core.testclient import TestClientFactory
 
+from catapp.application.cats.routers import cat_router
+
 os.environ.setdefault('ELLAR_CONFIG_MODULE',  'app_module_test.tests.settings')
 
 BASEDIR = Path(__file__).resolve().parent.parent

tests/main.py

@@ -10,195 +10,195 @@
 router = ModuleRouter("")
 
 
-@router.Get("/root")
+@router.get("/root")
 def non_operation():
     return {"message": "Hello World"}
 
 
-@router.Get("/text")
+@router.get("/text")
 def get_text():
     return "Hello World"
 
 
-@router.Get("/path/{item_id}")
+@router.get("/path/{item_id}")
 def get_id(item_id):
     return item_id
 
 
-@router.Get("/path/str/{item_id}")
+@router.get("/path/str/{item_id}")
 def get_str_id(item_id: str):
     return item_id
 
 
-@router.Get("/path/int/{item_id}")
+@router.get("/path/int/{item_id}")
 def get_int_id(item_id: int):
     return item_id
 
 
-@router.Get("/path/float/{item_id}")
+@router.get("/path/float/{item_id}")
 def get_float_id(item_id: float):
     return item_id
 
 
-@router.Get("/path/bool/{item_id}")
+@router.get("/path/bool/{item_id}")
 def get_bool_id(item_id: bool):
     return item_id
 
 
-@router.Get("/path/param/{item_id}")
+@router.get("/path/param/{item_id}")
 def get_path_param_id(item_id: Optional[str] = Path(None)):
     return item_id
 
 
-@router.Get("/path/param-required/{item_id}")
+@router.get("/path/param-required/{item_id}")
 def get_path_param_required_id(item_id: str = Path(...)):
     return item_id
 
 
-@router.Get("/path/param-minlength/{item_id}")
+@router.get("/path/param-minlength/{item_id}")
 def get_path_param_min_length(item_id: str = Path(..., min_length=3)):
     return item_id
 
 
-@router.Get("/path/param-maxlength/{item_id}")
+@router.get("/path/param-maxlength/{item_id}")
 def get_path_param_max_length(item_id: str = Path(..., max_length=3)):
     return item_id
 
 
-@router.Get("/path/param-min_maxlength/{item_id}")
+@router.get("/path/param-min_maxlength/{item_id}")
 def get_path_param_min_max_length(item_id: str = Path(..., max_length=3, min_length=2)):
     return item_id
 
 
-@router.Get("/path/param-gt/{item_id}")
+@router.get("/path/param-gt/{item_id}")
 def get_path_param_gt(item_id: float = Path(..., gt=3)):
     return item_id
 
 
-@router.Get("/path/param-gt0/{item_id}")
+@router.get("/path/param-gt0/{item_id}")
 def get_path_param_gt0(item_id: float = Path(..., gt=0)):
     return item_id
 
 
-@router.Get("/path/param-ge/{item_id}")
+@router.get("/path/param-ge/{item_id}")
 def get_path_param_ge(item_id: float = Path(..., ge=3)):
     return item_id
 
 
-@router.Get("/path/param-lt/{item_id}")
+@router.get("/path/param-lt/{item_id}")
 def get_path_param_lt(item_id: float = Path(..., lt=3)):
     return item_id
 
 
-@router.Get("/path/param-lt0/{item_id}")
+@router.get("/path/param-lt0/{item_id}")
 def get_path_param_lt0(item_id: float = Path(..., lt=0)):
     return item_id
 
 
-@router.Get("/path/param-le/{item_id}")
+@router.get("/path/param-le/{item_id}")
 def get_path_param_le(item_id: float = Path(..., le=3)):
     return item_id
 
 
-@router.Get("/path/param-lt-gt/{item_id}")
+@router.get("/path/param-lt-gt/{item_id}")
 def get_path_param_lt_gt(item_id: float = Path(..., lt=3, gt=1)):
     return item_id
 
 
-@router.Get("/path/param-le-ge/{item_id}")
+@router.get("/path/param-le-ge/{item_id}")
 def get_path_param_le_ge(item_id: float = Path(..., le=3, ge=1)):
     return item_id
 
 
-@router.Get("/path/param-lt-int/{item_id}")
+@router.get("/path/param-lt-int/{item_id}")
 def get_path_param_lt_int(item_id: int = Path(..., lt=3)):
     return item_id
 
 
-@router.Get("/path/param-gt-int/{item_id}")
+@router.get("/path/param-gt-int/{item_id}")
 def get_path_param_gt_int(item_id: int = Path(..., gt=3)):
     return item_id
 
 
-@router.Get("/path/param-le-int/{item_id}")
+@router.get("/path/param-le-int/{item_id}")
 def get_path_param_le_int(item_id: int = Path(..., le=3)):
     return item_id
 
 
-@router.Get("/path/param-ge-int/{item_id}")
+@router.get("/path/param-ge-int/{item_id}")
 def get_path_param_ge_int(item_id: int = Path(..., ge=3)):
     return item_id
 
 
-@router.Get("/path/param-lt-gt-int/{item_id}")
+@router.get("/path/param-lt-gt-int/{item_id}")
 def get_path_param_lt_gt_int(item_id: int = Path(..., lt=3, gt=1)):
     return item_id
 
 
-@router.Get("/path/param-le-ge-int/{item_id}")
+@router.get("/path/param-le-ge-int/{item_id}")
 def get_path_param_le_ge_int(item_id: int = Path(..., le=3, ge=1)):
     return item_id
 
 
-@router.Get("/path/param-starlette-str/{item_id:str}")
+@router.get("/path/param-starlette-str/{item_id:str}")
 def get_path_param_starlette_str(item_id):
     return item_id
 
 
-@router.Get("/path/param-starlette-int/{item_id:int}")
+@router.get("/path/param-starlette-int/{item_id:int}")
 def get_path_param_starlette_int(item_id: int):
     assert isinstance(item_id, int)
     return item_id
 
 
-@router.Get("/path/param-starlette-int-str/{item_id:int}")
+@router.get("/path/param-starlette-int-str/{item_id:int}")
 def get_path_param_starlette_int_str(item_id: str):
     assert isinstance(item_id, str)
     return item_id
 
 
-@router.Get("/path/param-starlette-uuid/{item_id:uuid}")
+@router.get("/path/param-starlette-uuid/{item_id:uuid}")
 def get_path_param_starlette_uuid(item_id: UUID):
     assert isinstance(item_id, UUID)
     return item_id
 
 
-@router.Get("/query")
+@router.get("/query")
 def get_query(query):
     return f"foo bar {query}"
 
 
-@router.Get("/query/optional")
+@router.get("/query/optional")
 def get_query_optional(query=None):
     if query is None:
         return "foo bar"
     return f"foo bar {query}"
 
 
-@router.Get("/query/int")
+@router.get("/query/int")
 def get_query_type(query: int):
     return f"foo bar {query}"
 
 
-@router.Get("/query/int/optional")
+@router.get("/query/int/optional")
 def get_query_type_optional(query: int = None):
     if query is None:
         return "foo bar"
     return f"foo bar {query}"
 
 
-@router.Get("/query/int/default")
+@router.get("/query/int/default")
 def get_query_type_optional_10(query: int = 10):
     return f"foo bar {query}"
 
 
-@router.Get("/query/param-required")
+@router.get("/query/param-required")
 def get_query_param_required(query=Query(...)):
     assert isinstance(query, str)
     return f"foo bar {query}"
 
 
-@router.Get("/query/param-required/int")
+@router.get("/query/param-required/int")
 def get_query_param_required_type(query: int = Query(...)):
     assert isinstance(query, int)
     return f"foo bar {query}"
@@ -208,12 +208,12 @@ class AliasedSchema(Schema):
     query: str = Field(..., alias="aliased.-_~name")
 
 
-@router.Get("/query/aliased-name")
+@router.get("/query/aliased-name")
 def get_query_aliased_name(query: AliasedSchema = Query(..., alias="aliased.-_~name")):
     return f"foo bar {query.query}"
 
 
-@router.Get("/query/param")
+@router.get("/query/param")
 def get_query_param(request, query=Query(None)):
     if query is None:
         return "foo bar"