Initial Commit

KiraPC · KiraPC · commit 26e976cbbb43 · 2021-02-06T14:39:37.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,15 @@
+/build/*
+/dist/*
+/swagger_confluence_pub.egg-info/*
+/venv/*
+**/.DS_Store
+**/*.pyc
+.vscode/*
+/.eggs/*
+/docs/build/*
+/test-reports/*
+/_build/*
+/_static/*
+/_templates/*
+/__pycache__/*
+/*.egg-info/
diff --git a/LICENSE.txt b/LICENSE.txt
@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2018 YOUR NAME
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/MANIFEST.in b/MANIFEST.in
@@ -0,0 +1 @@
+include requirements.txt
diff --git a/README.md b/README.md
@@ -0,0 +1,46 @@
+# What this repository contains
+#### A FastAPI utility to allow Controller Class usage
+
+## Installation: 
+
+install the package
+```
+pip install fastapi-router-controller
+```
+
+## How to use
+
+In a Class module
+
+```python
+from fastapi import APIRouter
+from fastapi_router_controller import Controller
+
+router = APIRouter()
+controller = Controller(router)
+
+@controller.resource()
+class ExampleController():
+    @controller.route.get(
+        '/some_aoi', 
+        summary='A sample description')
+    def sample_api(_):
+        return 'A sample response'
+```
+
+Load the controller to the main FastAPI app
+```python
+from fastapi import FastAPI
+from fastapi_router_controller import Controller
+
+import ExampleController
+
+app = FastAPI(
+    title='A sample application using fastapi_router_controller',
+    version="0.1.0")
+
+example_controller = ExampleController()
+app.include_router(example_controller.router())
+```
+
+## For some Example use-cases visit the example folder
diff --git a/example/sample_app/app.py b/example/sample_app/app.py
@@ -0,0 +1,17 @@
+from fastapi import FastAPI
+from fastapi_router_controller import ControllersTags
+from controller.sample_controller import SampleController
+from controller.sample_controller_2 import AnotherSampleController
+
+app = FastAPI(
+    title='A sample application using fastapi_router_controller',
+    version="0.1.0",
+    openapi_tags=ControllersTags)
+
+sample_controller = SampleController()
+another_sample_controller = AnotherSampleController()
+
+app.include_router(sample_controller.router())
+app.include_router(another_sample_controller.router())
+
+print(app.openapi())
diff --git a/example/sample_app/controller/__init__.py b/example/sample_app/controller/__init__.py
diff --git a/example/sample_app/controller/sample_controller.py b/example/sample_app/controller/sample_controller.py
@@ -0,0 +1,31 @@
+from fastapi import APIRouter, status, Query, Body
+from fastapi_router_controller import Controller
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix='/sample_controller')
+
+controller = Controller(router, openapi_tag={
+    'name': 'sample_controller',
+})
+
+class SampleObject(BaseModel):
+    id: str = Field(..., description='sample id')
+
+# With the "resource" decorator define the controller Class linked to the Controller router arguments 
+@controller.resource()
+class SampleController():
+    @controller.route.get(
+        '/',
+        tags=['sample_controller'], 
+        summary='return a sample object')
+    def sample_get_request(self, id: str = Query(..., title="itemId", description="The id of the sample object")):
+        return JSONResponse(status_code=status.HTTP_200_OK, content=SampleObject(id))
+
+    @controller.route.post(
+        '/', 
+        tags=['sample_controller'], 
+        summary='create another sample object', 
+        status_code=201)
+    def sample_post_request(self, simple_object: SampleObject = Body(None, title="SampleObject", description="A sample object model")):
+        return JSONResponse(status_code=status.HTTP_201_CREATED, content={})
diff --git a/example/sample_app/controller/sample_controller_2.py b/example/sample_app/controller/sample_controller_2.py
@@ -0,0 +1,31 @@
+from fastapi import APIRouter, status, Query, Body
+from fastapi_router_controller import Controller
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+
+router = APIRouter(prefix='/sample_controller_2')
+
+controller = Controller(router, openapi_tag={
+    'name': 'sample_controller_2',
+})
+
+class SampleObject(BaseModel):
+    id: str = Field(..., description='sample id')
+
+# With the "resource" decorator define the controller Class linked to the Controller router arguments 
+@controller.resource()
+class AnotherSampleController():
+    @controller.route.get(
+        '/',
+        tags=['sample_controller_2'], 
+        summary='return another sample object')
+    def sample_get_request(_, id: str = Query(..., title="itemId", description="The id of the sample object")):
+        return JSONResponse(status_code=status.HTTP_200_OK, content=SampleObject(id))
+
+    @controller.route.post(
+        '/', 
+        tags=['sample_controller_2'], 
+        summary='create a sample object', 
+        status_code=201)
+    def sample_post_request(_, simple_object: SampleObject = Body(None, title="SampleObject", description="A sample object model")):
+        return JSONResponse(status_code=status.HTTP_201_CREATED, content={})
diff --git a/example/sample_app_with_auto_import/app.py b/example/sample_app_with_auto_import/app.py
@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+from fastapi_router_controller import Controller, ControllersTags
+
+# just import the main package to load all the controllers in
+import controller
+
+app = FastAPI(
+    title='A sample application using fastapi_router_controller with controller auto import',
+    version="0.1.0",
+    # all of the router openapi_tags are collected in ControllerTags object
+    openapi_tags=ControllersTags)
+
+for router in Controller.routers():
+    app.include_router(router)
+
+print(app.openapi())
diff --git a/example/sample_app_with_auto_import/controller/__init__.py b/example/sample_app_with_auto_import/controller/__init__.py
@@ -0,0 +1,7 @@
+import os
+from fastapi_router_controller import ControllerLoader
+
+this_dir = os.path.dirname(__file__)
+
+# load all the module inside the given path
+ControllerLoader.load(this_dir, __package__)
diff --git a/example/sample_app_with_auto_import/controller/sample_controller.py b/example/sample_app_with_auto_import/controller/sample_controller.py
@@ -0,0 +1,35 @@
+from fastapi import APIRouter, status, Query, Body
+from fastapi_router_controller import Controller
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+
+from libs.sample_parent_controller import SampleParentController
+
+router = APIRouter(prefix='/sample_extended_controller')
+
+controller = Controller(router, openapi_tag={
+    'name': 'sample_extended_controller',
+})
+
+class SampleObject(BaseModel):
+    id: str = Field(..., description='sample id')
+
+# With the "use" decorator the lib save the Controller Class to load it automatically
+@controller.use()
+# With the "resource" decorator define the controller Class linked to the Controller router arguments 
+@controller.resource()
+class SampleController(SampleParentController):
+    @controller.route.get(
+        '/',
+        tags=['sample_extended_controller'], 
+        summary='return a sample object')
+    def sample_get_request(self, id: str = Query(..., title="itemId", description="The id of the sample object")):
+        return JSONResponse(status_code=status.HTTP_200_OK, content=SampleObject(id))
+
+    @controller.route.post(
+        '/', 
+        tags=['sample_extended_controller'], 
+        summary='create another sample object', 
+        status_code=201)
+    def sample_post_request(self, simple_object: SampleObject = Body(None, title="SampleObject", description="A sample object model")):
+        return JSONResponse(status_code=status.HTTP_201_CREATED, content={})
diff --git a/example/sample_app_with_auto_import/libs/__init__.py b/example/sample_app_with_auto_import/libs/__init__.py
diff --git a/example/sample_app_with_auto_import/libs/sample_parent_controller.py b/example/sample_app_with_auto_import/libs/sample_parent_controller.py
@@ -0,0 +1,16 @@
+from fastapi import APIRouter, status
+from fastapi_router_controller import Controller
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+controller = Controller(router)
+
+# This is a Sample Controller that can be exteded by another to inherit its routes
+@controller.resource()
+class SampleParentController():
+    @controller.route.get(
+        '/parent_api', 
+        summary='A sample API from the extended class, it will inherit the basepat of the child router')
+    def sample_parent_api(_):
+        return JSONResponse(status_code=status.HTTP_200_OK, content={ 'message': 'I\'m the parent'})
diff --git a/fastapi_router_controller/__init__.py b/fastapi_router_controller/__init__.py
@@ -0,0 +1,7 @@
+"""FastAPI Router Contoller, FastAPI utility to allow Controller Class usage"""
+
+__version__ = "0.1.0"
+
+from fastapi_router_controller.lib.controller import Controller as Controller
+from fastapi_router_controller.lib.controller import OPEN_API_TAGS as ControllersTags
+from fastapi_router_controller.lib.controller_loader import ControllerLoader as ControllerLoader
diff --git a/fastapi_router_controller/lib/__init__.py b/fastapi_router_controller/lib/__init__.py
diff --git a/fastapi_router_controller/lib/controller.py b/fastapi_router_controller/lib/controller.py
@@ -0,0 +1,118 @@
+from fastapi import APIRouter
+
+OPEN_API_TAGS = []
+__app_classes__ = []
+__router_params__ = [
+        'response_model',
+        'status_code',
+        'tags',
+        'dependencies',
+        'summary',
+        'description',
+        'response_description',
+        'responses',
+        'deprecated',
+        'methods',
+        'operation_id',
+        'response_model_include',
+        'response_model_exclude',
+        'response_model_by_alias',
+        'response_model_exclude_unset',
+        'response_model_exclude_defaults',
+        'response_model_exclude_none',
+        'include_in_schema',
+        'response_class',
+        'name',
+        'callbacks'
+    ]
+
+class Controller():
+    '''
+        The Controller class.
+
+        It expose some utilities and decorator functions to define a router controller class
+    '''
+    router: APIRouter
+
+    def __init__(self, router: APIRouter, openapi_tag: dict = None) -> None:
+        '''
+            :param router:          The FastApi router to link to the Class
+            :param openapi_tag:     An openapi object that will describe your routes in the openapi tamplate 
+        '''
+        self.router = router
+        self.openapi_tag = openapi_tag
+
+        if openapi_tag:
+            OPEN_API_TAGS.append(openapi_tag)
+    
+    def __get_parent_routes(self, router: APIRouter):
+        '''
+            Private utility to get routes from an extended class
+        '''
+        for route in router.routes:
+            options = {key: getattr(route, key) for key in __router_params__}
+
+            # inherits child tags if presents
+            if len(options['tags']) == 0 and self.openapi_tag:
+                options['tags'].append(self.openapi_tag['name'])
+
+            self.router.add_api_route(route.path, route.endpoint, **options)
+
+    def resource(self):
+        '''
+            A decorator function to mark a Class as a Controller
+        '''
+        def wrapper(cls):
+            if hasattr(cls, '__router__'):
+                self.__get_parent_routes(cls.__router__)
+            
+            cls.__router__ = self.router
+            cls.router = lambda _: Controller.__parse_controller_router(cls)
+            return cls
+
+        return wrapper
+
+    def use(_):
+        '''
+            A decorator function to mark a Class to be automatically loaded by the Controller
+        '''
+        def wrapper(cls):
+            __app_classes__.append(cls)
+            return cls
+
+        return wrapper
+
+    @staticmethod
+    def __parse_controller_router(controller):
+        '''
+            Private utility to parse the router controller property and extract the correct functions handlers
+        '''
+        for route in controller.__router__.routes:
+            func = route.endpoint
+            if hasattr(func, '__get__'):
+                route.endpoint = func.__get__(controller, controller.__class__)
+        
+        return controller.__router__
+
+    @staticmethod
+    def routers():
+        '''
+            It returns all the Classes marked to be used by the "use" decorator
+        '''
+        routers = []
+
+        for app_class in __app_classes__:
+            controller = app_class()
+            routers.append(
+                controller.router()
+            )
+        
+        return routers
+    
+    @property
+    def route(self) -> APIRouter:
+        '''
+            It returns the FastAPI router.
+            Use it as if you are using the original one.
+        '''
+        return self.router
diff --git a/fastapi_router_controller/lib/controller_loader.py b/fastapi_router_controller/lib/controller_loader.py
@@ -0,0 +1,21 @@
+import os
+import importlib
+
+class ControllerLoader():
+    '''
+        The ControllerLoader class.
+    '''
+    @staticmethod
+    def load(directory, package):
+        '''
+            It is an utility to load automatically all the python module presents on a given directory
+        '''
+        for module in os.listdir(directory):
+            sub_dir = directory + '/' + module
+            if os.path.isdir(sub_dir):
+                ControllerLoader.load(sub_dir, '{}.{}'.format(package, module))
+            if module == '__init__.py' or module[-3:] != '.py':
+                continue
+            else:
+                module_import_name = '{}.{}'.format(package, module[:-3])
+                importlib.import_module(module_import_name)
diff --git a/pub.sh b/pub.sh
diff --git a/requirements.txt b/requirements.txt
diff --git a/setup.py b/setup.py
