Update app.py

app.py

@@ -1,152 +1,124 @@
-MAX_API_RETRIES=3
-from pydantic import BaseModel
-import pydantic_core._pydantic_core as pydantic_core
-from fastapi import FastAPI
-import json,requests
-app = FastAPI()
-def morph(valor,tipo):
-    if isinstance(valor,dict):
-        return tipo(valor)
-    elif isinstance(valor,list):
-        return list(map(lambda v:morph(v,tipo),valor))
-    else:
-        return valor 
-class ResponseData(BaseModel):
-    error:bool
-    message:str
-class Diccionario:
-    def __init__(self,diccionario:dict):
-        self.d = diccionario
-    def __str__(self):
-        return json.dumps(self.d)
-    def __repr__(self):
-        return self.__str__()
-    def __getattr__(self,data:str):
-        attr = self.d.get(data,None)
-        return morph(attr,Diccionario)
-class Mensaje(BaseModel):
-    content:str = ""
-    role:str = "user"
-class persona(BaseModel):
-    nombres:str 
-    apellidos:str
-    edad:int
-    personalidad:str
-    biografia:str
-    pais:str
-    sexo:str
-    hobbies:list[str]
-class personaje(BaseModel):
-    interpretador:persona
-    nombre:str
-    personalidad:str
-    apariencia:str
-    papel:str
-    edad:int
-class pelicula(BaseModel):
-    personajes: list[personaje]
-    titulo:str
-    traduccion:dict[str,str]
-    sinopsis:str
-    duracion:int
-    detailed_image_token_prompt_english:list[str]
+from fastapi import FastAPI, Query,Path
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel,Field
+from typing import Annotated
+from bs4 import BeautifulSoup,ResultSet
+import requests
+from hashlib import md5
+from enum import Enum
 
-class trabajador(BaseModel):
-    identidad:persona
-    trabajo:str
-    sueldo:int
-    remoto:bool=False
-    historial_sueldo:list[str]
-class comentario(BaseModel):
-    mensaje:str
-    autor:persona
-    likes:int
-    dislikes:int
-class publicacion(BaseModel):
-    mensaje:str
-    likes:int
-    dislikes:int
-    visitas:int
-    comentarios:list[comentario]
-class perfil(BaseModel):
-    data:persona
-    amigos:list[persona]
-    publicaciones:list[publicacion]
-class steamgame(BaseModel):
+EVA_MAIN_URL:str = "https://eva.fing.edu.uy"
+EVA_CATEGORY_URL:str = f"{EVA_MAIN_URL}/course/index.php?categoryid={{cat_id}}"
+EVA_COURSE_URL:str=f"{EVA_MAIN_URL}/course/view.php?id={{course_id}}"
+EVA_FORUM_URL:str=f"{EVA_MAIN_URL}/mod/forum/view.php?id={{forum_id}}"
+EVA_RESOURCES_URL:str=f"{EVA_MAIN_URL}/course/resources.php?id={{course_id}}"
+app:FastAPI = FastAPI(title="EVA API(No oficial)")
+class Estado(Enum):
+    ABIERTO = 1
+    CERRADO = 0
+class TipoMaterial(Enum):
+    PÁGINA = 0
+    ARCHIVO = 1
+    FORO = 2
+    CARPETA = 3
+    URL = 4
+class Instituto(BaseModel):
+    id:int
     nombre:str
-    descripcion_corta:str
-    descripcion_larga:str
-    reviews:list[comentario]
-    calificacion:int
-    descargas:int
-
-class episodio(BaseModel):
-    personajes_involucrados:list[personaje]
-    dialogos:list[dict[int,dict[str,str]]]
-    descripcion:str
-class serie(BaseModel):
+class Curso(BaseModel):
+    estado:Estado = Estado.CERRADO
     nombre:str
-    personajes:list[personaje]
-    clasificacion:str
-    rating:int
-    episodios:int
-    lista_episodios:list[episodio]
-def ask(query:str,system_prompt:str)->ResponseData:
-    msgs:list[dict[str,str]] = [
-        Mensaje(role="system",content=system_prompt).model_dump(),
-        Mensaje(content=query).model_dump()
-    ]
-    response = requests.post("https://text.pollinations.ai/openai",json={
-        "messages":msgs,
-        "private":True,
-        "jsonMode":True,
-        "model":"openai",
-        "seed":__import__("random").randint(10000,999999)
-    })
-    data=response.json()
+    id:int
+class Material(BaseModel):
+    tema:str
+    tipo:TipoMaterial = TipoMaterial.PÁGINA
+    estado:Estado = Estado.CERRADO
+    descripcion: str | None = None
+
+def insertar_dentro(lista:list[str],opcion) -> any:
+    return {lista.pop(0):{"info":
+        {'url':opcion.get('value'),
+        'id':int(opcion.get('value').split("=",1)[-1])}
+    } if len(lista)==0 else insertar_dentro(lista,opcion)}
+def parse_dict(d1:dict,d2:dict)->dict:
+    claves_repetidas =list( set(d1.keys()) & set(d2.keys()))
+    claves_d1_unicas = list(set(d1.keys())-set(d2.keys()))
+    claves_d2_unicas = list(set(d2.keys())-set(d1.keys()))
+    nuevo_diccionario = {}
+    for key in claves_repetidas:
+        nuevo_diccionario[key] = parse_dict(d1[key],d2[key])
+    for key in claves_d1_unicas:
+        nuevo_diccionario[key]= d1[key]
+    for key in claves_d2_unicas:
+        nuevo_diccionario[key]= d2[key]
+    return nuevo_diccionario
+def obtener_institutos() -> dict:
+    response = requests.get(EVA_CATEGORY_URL.format(cat_id=2))
+    scraper = BeautifulSoup(response.text,'html.parser')
+    opciones:ResultSet = scraper.find_all("option")
+    selecciones:dict = {}
+    for opcion in list(opciones):
+        carpeta:list[str]= opcion.getText().split(" / ")
+        if len(carpeta)<=1: continue
+        a = insertar_dentro(carpeta,opcion)
+        selecciones = parse_dict(selecciones,a)
+    return selecciones
+
+def obtener_cursos(category_id:str|int)->list[Curso]:
+    def format_option(opcion):
+        opcion = opcion.parent
+        is_locked = len(opcion.find_all("i"))<2
+        nombre=opcion.find('div',class_='coursename').getText()
+        id=int(opcion.find('a').get('href').split("=")[-1])
+        return Curso(**{
+            "estado":Estado.CERRADO if is_locked else Estado.ABIERTO,
+            "nombre":nombre,
+            "id":id
+        })
+    
+
+
 
-    error_msg = Diccionario(data).error
-    structured_data = ResponseData(error=True if error_msg else False,message=error_msg or Diccionario(data).choices[0].message.content)
-    return structured_data
 
-def generate_model(model:BaseModel,gived_data:BaseModel=None,retries=0)->BaseModel | None:
-    system = f"""Eres un generador de contenido avanzado(evita contenido repetido) capaz de comprender cualquier contexto, debes generar un json valido con estas propiedades, las claves son los valores de title y los valores deben ser del mismo tipo que el valor de type, el title que esta por fuera de propierties debe ser el tipo general, tipo el que contiene todas las propiedades,no realices ningun comentario o acotacion,otorga un json valido,las claves deben estar en minuscula pero los valores no necesariamente"""
-    if gived_data:
-        system+=f"\n Ademas tengo esta informacion: {gived_data.model_dump_json()}"
-    resultado = ask(json.dumps(model.model_json_schema()),system)
-    if resultado.error==True: 
-        return {"error":resultado.message}
-    try:
-        data = list(json.loads(resultado.message).values())[0]
-        if retries>MAX_API_RETRIES: return {"error":"Se ha intentado, pero no hubo caso, prueba nuevamente","failed_data":data}
-        if isinstance(data,str):
-            retries+=1
-            return generate_model(model,gived_data,retries)
-        
+    response = requests.get(EVA_CATEGORY_URL.format(cat_id=category_id))
+    scraper = BeautifulSoup(response.text,'html.parser')
+    opciones:ResultSet = scraper.find_all('div',class_="coursename")
+    fixed_opciones = list(map(format_option,opciones))
+    return fixed_opciones
+def obtener_recursos(course_id:str|int)->list[Material]:
+    def format_recourse(recurso):
+        datos = recurso.find_all("td")
+        tema = datos[0].getText()
+        info = datos[1]
+        tipo:str = info.find("img").get("alt")
+        url = info.find("a").get("href")
+        tema += info.find("a").getText() if tipo=="URL" else ''
+        descripcion=datos[2].getText()
+        return Material(**{"tema":tema.strip(),
+                "tipo":TipoMaterial[tipo.upper()],
+                "url":url,
+                "descripcion":descripcion})
+    response = requests.get(EVA_RESOURCES_URL.format(course_id=course_id))
+    scraper = BeautifulSoup(response.text,'html.parser')
+    recursos = scraper.find("table",class_="generaltable mod_index").find_all("tr")[1:]
+    recursos_formateados = list(map(format_recourse,recursos))
+    return recursos_formateados
+def obtener_hilos(foro_id:int)->list:
+    response = requests.get(EVA_FORUM_URL.format(forum_id=foro_id))
+    #scraper = BeautifulSoup(response.text,'html.parser')
+    return HTMLResponse(content=response.text,status_code=200);
+    return str(scraper)
 
-        return model(**(data))
-    except (pydantic_core.ValidationError, json.JSONDecodeError) as e:
-        retries+=1
-        return generate_model(model,gived_data,retries) 
+@app.get('/institutos',tags=["institutos"],description="Lista los institutos",response_model=dict,name="Institutos")
+def ob_ins():
+    return obtener_institutos()
 
-models:BaseModel= [
-    persona,
-    pelicula,
-    trabajador,
-    publicacion,
-    perfil,
-    steamgame,
-    serie
-]
-def create_handler(model_class: BaseModel):
-    def handler() -> dict:
-        generated=generate_model(model_class)
-        
-        return generated if isinstance(generated,dict) else json.loads(generated.model_dump_json())
-    handler.__name__=f"Crear {model_class.__name__}"
-    return handler
-for model in models:
-    app.add_api_route(f"/{model.__name__}",create_handler(model))
-@app.post("/generate_movie")
-def gen_movie(user:persona):
-    return generate_model(pelicula,user)
+@app.get('/cursos/{instituto_id}',tags=["cursos"],response_model=list[Curso])
+def get_courses(instituto_id:Annotated[int,Path(title="ID del instituto",description="ID DEL INSTITUTO")]):
+    return obtener_cursos(instituto_id)
+@app.get('/recursos/{curso_id}',tags=["cursos","recursos"],response_model=list[Material],description="Obtiene los recursos del curso")
+def get_recursos(curso_id:Annotated[int,Path(title="ID del curso")]):
+    return obtener_recursos(curso_id)
+@app.get('/foros/{foro_id}')
+def get_foro_data(foro_id:Annotated[int,Path(title="ID del foro")]):
+    return obtener_hilos(foro_id)