diff --git a/README.md b/README.md index 1edc188..001a724 100644 --- a/README.md +++ b/README.md @@ -1 +1,50 @@ -# Python_OOP_Project \ No newline at end of file +# FastApiDecoratorBuilder + +"FastApiDecoratorBuilder" est un algorithme permettant de concevoir un décorateur Python qui transforme une fonction Python en une API FastAPI. + +## Installation + +1. Télécharger les fichiers Python +2. Installer l'application FastAPI + $ pip install fastapi +3. Installer le serveur ASGI + $ pip install "uvicorn[standard]" +4. Lancer le serveur dans le terminal de l'application Python + $ python -m uvicorn main:app --reload +5. Le serveur API démarrera et sera accessible à http://127.0.0.1:8000. + +## Utilisation +Le décorateur 'fast_api_decorator' ajoute une route avec un endpoint correspondant aux paramètres de la requête (paramètres de la fonction). Le décorateur appliqué à une fonction puis "lancée" sur le même script de l'instance FastAPI (app) permet de requêter l'API avec une route qui dépend de la fonction et de ses propres paramètres. +L'API est configurée directement grâce aux paramètres du décorateur avec les routes ("/power/", "/add/" et "/sous/") et les méthodes HTTP ("GET", "POST", "PUT", "DELETE"). + +## Test +Dans le code suivant, il y a trois fonctions qui ont été implémenté dans l'API. Il suffit d'entrer les points de terminaison suivants après le lien 'http://127.0.0.1:8000'. + +1. Power + Description : Calcul de la puissance d'un nombre + Paramètres : + - 'x': Nombre (integer) + - 'a': La puissance (integer) + + Exemple : '/power/?x=2&a=3' retournera le résultat de 2 à la puissance 3 + +2. Add + Description : Calcul l'addition de deux nombres + Paramètres : + - 'x': Nombre (integer) + - 'a': Nombre (integer) + + Exemple : '/add/?x=2&a=3' retournera la somme de 2 et 3 + +3. Sous + Description : Calcul la soustraction de trois nombres + Paramètres : + - 'x': Nombre à soustraire(integer) + - 'a': Nombre (integer) + - 'b': Nombre (integer) + + Exemple : '/sous/?x=10&a=3&b=2' pour soustraire 3 et 2 à 10 + + + + diff --git a/app.py b/app.py new file mode 100644 index 0000000..d201419 --- /dev/null +++ b/app.py @@ -0,0 +1,69 @@ +from fastapi import FastAPI, APIRouter + + +my_router = APIRouter() +app = FastAPI() + + +def fast_api_decorator(route, method): + def decorator(func): + def wrapper(*args, **kwargs): + my_router.add_api_route(path=route, endpoint=func, methods=method) + app.include_router(my_router) + return func(*args, **kwargs) + return wrapper + return decorator + + +@fast_api_decorator(route="/power/", method=["GET"]) +def power_function(x: str, a: str): + return {f"{x} to the power of {a}": int(x)**int(a)} + + +@fast_api_decorator(route="/add/", method=["GET"]) +def add_function(x: str, a: str): + return {f"{x} + {a} equals": int(x) + int(a)} + + +@fast_api_decorator(route="/sous/", method=["GET"]) +def sous_function(x: str, lst): + return {f"{x} - {lst[0]} - {lst[1]} equals": int(x) - int(lst[0]) - int(lst[1])} + + +# On "lance" les fonctions pour qu'elles soient lisibles par l'app FastAPI +power_function(x="0", a="0") +add_function(x="0", a="0") +sous_function(x="0", lst=[0, 0]) + +# résolution pb de lancement des fonctions +""" +from fastapi import FastAPI, APIRouter + +app = FastAPI() + +class PowerEndpoint: + router = APIRouter() + + @router.get("/power/") + async def power_function(self, x: str, a: str): + return {f"{x} to the power of {a}": int(x)**int(a)} + +class AddEndpoint: + router = APIRouter() + + @router.get("/add/") + async def add_function(self, x: str, a: str): + return {f"{x} + {a} equals": int(x) + int(a)} + +class SousEndpoint: + router = APIRouter() + + @router.get("/sous/") + async def sous_function(self, x: str, lst): + return {f"{x} - {lst[0]} - {lst[1]} equals": int(x) - int(lst[0]) - int(lst[1])} + +# Including the routers directly in the main app +app.include_router(PowerEndpoint.router, tags=["power"]) +app.include_router(AddEndpoint.router, tags=["add"]) +app.include_router(SousEndpoint.router, tags=["sous"]) +""" \ No newline at end of file diff --git a/decorator.py b/decorator.py new file mode 100644 index 0000000..3e40809 --- /dev/null +++ b/decorator.py @@ -0,0 +1,18 @@ +# In this script we build the decorator and the function we want to transform into an API +from app import app, my_router + + +def fast_api_decorator(route): + def decorator(func): + def wrapper(x, a): + func(x, a) + return func(x, a) + my_router.add_api_route(path='/{func}/{x}/{a}', endpoint=wrapper) + app.include_router(my_router) + return wrapper + return decorator + + +@fast_api_decorator(route="") +def power_function(x, a): + return {f"{x} to the power of {a}": x**a} diff --git a/main.py b/main.py new file mode 100644 index 0000000..79dc920 --- /dev/null +++ b/main.py @@ -0,0 +1,44 @@ +""" +FastApiDecoratorBuilder + +Description du Projet : +Votre défi dans le projet "FastApiDecoratorBuilder" est de concevoir un décorateur Python qui +transforme une fonction Python en une API FastAPI basée sur la fonction et des configurations +définies. + +Objectifs du Projet : +- Création de Décorateur: Construire un décorateur qui transforme une fonction Python en API FastAPI. +- Gestion de Configurations: Implanter un mécanisme de configuration pour l’API. + +Consignes : +1) Développement du Décorateur : Elaborez un décorateur qui, appliqué à une fonction, génère une API FastAPI +correspondante. +2) Configuration de l'API : Intégrez une méthode pour configurer les propriétés de l’API générée, telles que +les routes et les méthodes HTTP acceptées. +""" + +# Use command : "python -m uvicorn main:app --reload" to lauch server and be able to request the "app" API. + +from app import app, power_function, add_function, sous_function +import requests + + +def power(x, a): + print(requests.get(f"http://127.0.0.1:8000/power/?x={x}&a={a}").json()) + + +def add(x, a): + print(requests.get(f"http://127.0.0.1:8000/add/?x={x}&a={a}").json()) + + +def sous(x, a, b): + print(requests.post(f"http://127.0.0.1:8000/sous/?x={x}&a={a}&b={b}").json()) + + +if __name__ == "__main__": + power(x=9, a=2) + add(x=9, a=2) + sous(x=9, a=2, b=1) + print(power_function(x="9", a="2")) + print(add_function(x="9", a="2")) + print(sous_function(x="9", a="2", b="1"))