1. Poner la BD en el proyecto (puedes visualizarla en VSC con SQLite Viewer extension).

2. Crear y activar environment ((esto es para windows))

   1. python -m venv venv
   2. venv\\Scripts\\activate

3. Instalar pip install fastapi , pip install pydantic y pip install uvicorn

4. Crear archivos request_handler.py, models.py, [domain.py](<http://domain.py>) y patient_service (service que maneja la conexión con la BD).

5. En el archivo request_handler.py, se crean los endpoints:

   from fastapi import FastAPI, HTTPException
   import patient_service
   from models import PatientModel
   
   app = FastAPI()
   
   @app.get("/patient/{patient_id}")
   def patient_details(patient_id: str):
       result = patient_service.get_patient_by_id(patient_id)
   
       return result
   
   @app.post("/patient")
   def add_patient(patient: PatientModel):
       print(patient)
       if not patient_service.add_patient(patient):
           raise HTTPException(status_code=400, detail="Patient already exist")
   

6. Crear una clase que defina la tabla en la BD en domain.py:

   class Patient:
       def __init__(self, id, name, current_city):
           self.id = id
           self.name = name
           self.current_city = current_city
   
       def __dict__(self):
           return {
                    "patient_id": self.id,
                    "name": self.name, 
                    "current_city": self.current_city}
   

7. Hacer la conexión con la BD en patient_service.py:

   import sqlite3
   from domain import Patient
   
   #service para conectarse con la BD
   def get_patient_by_id(patient_id):
       con = sqlite3.connect("tf_backend_api.db")
   
       #ejecuta consulta
       cur = con.cursor()
   
       res = cur.execute("SELECT * FROM patient WHERE patient_id_pk = ? ", (patient_id,)).fetchone()
    
       if res:
             #elementos dentro de la respuesta y retornamos como diccionario
           return Patient(res[0], res[1], res[2]).__dict__()
       else:
           return None
       
   def add_patient(patient):
       con = sqlite3.connect("tf_backend_api.db")
       cur = con.cursor()
   
       print(patient)
   
       try:
           cur.execute("INSERT INTO patient VALUES (?, ?, ?)", (patient.id, patient.name, patient.current_city))
           con.commit()
       except sqlite3.IntegrityError:
           return None
       finally:    
           con.close()
   

8. Creamos un modelo de la tabla para poder recibirla como RQ en models.py este model lo recibirá el endpoint post.

   from pydantic import BaseModel
   
   class PatientModel(BaseModel):
       id: str
       name: str
       current_city: str
   

9. Correr servidor con uvicorn app --host 127.0.0.1 --port 8000 --reload y hacer pruebas en Postman <3

Si tienes problemas intenta:

desde app: uvicorn main:app --port 8080

desde {carpeta_raiz} uvicorn app.main:app --port 8080