Dev matthieu to dev guillaume

README.md

@@ -1 +1,50 @@
-# Python_OOP_Project
+# 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
+
+
+
+

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"])
+"""

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}

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