Add application file

app.py

@@ -1,21 +1,109 @@
 import os
 import uvicorn
-from typing import List, Optional
+import uuid
+import json
+import base64
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, HTMLResponse, RedirectResponse
 
+# Usa seus módulos existentes
 from models_schemas import AnalyzeResponse, AnalyzeBatchRequest
 from llm_client import analyze_cv_with_llm
 from parsers import extract_text_from_pdf
 
+# -----------------------------------------------------------------------------
+# Helpers de persistência (usa /data do Space) - sem arquivos extras
+# -----------------------------------------------------------------------------
+DATA_DIR = os.path.join(os.getcwd(), "data")
+JOBS_PATH = os.path.join(DATA_DIR, "jobs.json")
+CVS_PATH = os.path.join(DATA_DIR, "cvs.json")
+
+def _ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+def _read_json(path: str):
+    _ensure_data_dir()
+    if not os.path.exists(path):
+        return []
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return []
+
+def _write_json(path: str, data: Any):
+    _ensure_data_dir()
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+def _list_jobs() -> List[Dict[str, Any]]:
+    data = _read_json(JOBS_PATH)
+    return data if isinstance(data, list) else [data]
+
+def _create_job(title: str, description: str, details: str, requirements: Optional[List[str]] = None) -> Dict[str, Any]:
+    jobs = _list_jobs()
+    rec = {
+        "id": str(uuid.uuid4()),
+        "title": title,
+        "description": description,
+        "details": details,
+        "requirements": requirements or [],
+        "created_at": datetime.utcnow().isoformat()
+    }
+    jobs.append(rec)
+    _write_json(JOBS_PATH, jobs)
+    return rec
+
+def _get_job(job_id: str) -> Optional[Dict[str, Any]]:
+    for j in _list_jobs():
+        if j.get("id") == job_id:
+            return j
+    return None
+
+def _list_cvs() -> List[Dict[str, Any]]:
+    data = _read_json(CVS_PATH)
+    return data if isinstance(data, list) else [data]
+
+def _save_cv_result(result: Dict[str, Any], job: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    cvs = _list_cvs()
+    rec = {
+        "id": str(uuid.uuid4()),
+        "name": result.get("name") or "",
+        "area": result.get("area") or "",
+        "summary": result.get("summary") or "",
+        "skills": result.get("skills") or [],
+        "education": result.get("education") or "",
+        "interview_questions": result.get("interview_questions") or [],
+        "strengths": result.get("strengths") or [],
+        "areas_for_development": result.get("areas_for_development") or [],
+        "important_considerations": result.get("important_considerations") or [],
+        "final_recommendations": result.get("final_recommendations") or "",
+        "score": float(result.get("score") or 0.0),
+        "created_at": datetime.utcnow().isoformat(),
+        "job_id": job.get("id") if job else None,
+        "job_title": job.get("title") if job else None
+    }
+    cvs.append(rec)
+    _write_json(CVS_PATH, cvs)
+    return rec
+
+def _get_cv(cv_id: str) -> Optional[Dict[str, Any]]:
+    for c in _list_cvs():
+        if c.get("id") == cv_id:
+            return c
+    return None
+
 # -----------------------------------------------------------------------------
 # App & Middlewares
 # -----------------------------------------------------------------------------
 app = FastAPI(
     title="RecrAI API",
-    version="1.0.0",
-    description="API de triagem e análise de currículos com Groq LLM."
+    version="1.2.0",
+    description="API de triagem e análise de currículos com Groq LLM (compatível com o front)."
 )
 
 app.add_middleware(
@@ -51,21 +139,15 @@ def home():
           <h2>Endpoints</h2>
           <ul>
             <li><code>GET /health</code> – status básico</li>
-            <li><code>GET /info</code> – informações não sensíveis do runtime</li>
-            <li><code>POST /analyze_cv</code> – análise de 1 currículo (multipart)</li>
+            <li><code>GET /info</code> – informações do runtime</li>
+            <li><code>GET /jobs</code> &bull; <code>POST /jobs</code></li>
+            <li><code>GET /cvs</code> &bull; <code>GET /cvs/{{id}}</code></li>
+            <li><code>POST /analyze_cv</code> – 1 currículo (multipart)</li>
+            <li><code>POST /analyze_cv_batch_multipart</code> – vários PDFs (multipart: files[])</li>
             <li><code>POST /analyze_cv_batch</code> – análise em lote (JSON)</li>
           </ul>
           <p>Documentação: <a href="/docs">Swagger UI</a> | <a href="/redoc">ReDoc</a></p>
         </div>
-
-        <div class="card">
-          <h2>Exemplo rápido (cURL)</h2>
-          <pre>
-curl -X POST https://&lt;seu-space&gt;.hf.space/analyze_cv ^
-  -F "job=Desenvolvedor(a) Full Stack..." ^
-  -F "cv_text=Fulano trabalhou com Python e React ..."
-          </pre>
-        </div>
       </body>
     </html>
     """
@@ -85,7 +167,7 @@ def info():
     """Informações não sensíveis do ambiente (sem expor segredos)."""
     return {
         "app": "RecrAI API",
-        "version": "1.0.0",
+        "version": "1.2.0",
         "model_id": os.getenv("GROQ_MODEL_ID", "deepseek-r1-distill-llama-70b"),
         "temperature": float(os.getenv("TEMPERATURE", "0.7")),
         "env": "spaces" if os.getenv("HF_SPACE_ID") else "local"
@@ -105,21 +187,93 @@ async def unhandled_exception_handler(_: Request, exc: Exception):
     return JSONResponse(status_code=500, content={"detail": "Erro interno do servidor."})
 
 # -----------------------------------------------------------------------------
-# Endpoints principais
+# Jobs (compatível com teu front)
+# -----------------------------------------------------------------------------
+@app.get("/jobs", summary="Lista vagas cadastradas")
+def list_jobs():
+    return _list_jobs()
+
+@app.post("/jobs", summary="Cria uma vaga")
+def create_job(payload: Dict[str, Any]):
+    title = (payload.get("title") or "").strip()
+    description = (payload.get("description") or "").strip()
+    details = (payload.get("details") or "").strip()
+    requirements = payload.get("requirements") or []
+    if not title or not description or not details:
+        raise HTTPException(status_code=400, detail="Campos obrigatórios: title, description, details.")
+    if isinstance(requirements, str):
+        requirements = [r.strip() for r in requirements.split(",") if r.strip()]
+    rec = _create_job(title, description, details, requirements)
+    return {"message": "Vaga criada com sucesso.", "job": rec}
+
+# -----------------------------------------------------------------------------
+# CVs (listagem/detalhe) para a seção de resultados do front
+# -----------------------------------------------------------------------------
+@app.get("/cvs", summary="Lista currículos analisados")
+def list_cvs():
+    cvs = _list_cvs()
+    # reduz para listagem (nome, área, resumo, score…)
+    out = []
+    for c in cvs:
+        out.append({
+            "id": c.get("id"),
+            "name": c.get("name", ""),
+            "area": c.get("area", ""),
+            "summary": c.get("summary", ""),
+            "score": c.get("score", 0.0),
+            "created_at": c.get("created_at"),
+            "job_id": c.get("job_id"),
+            "job_title": c.get("job_title")
+        })
+    return out
+
+@app.get("/cvs/{cv_id}", summary="Detalhe do currículo analisado", response_model=AnalyzeResponse)
+def get_cv(cv_id: str):
+    c = _get_cv(cv_id)
+    if not c:
+        raise HTTPException(status_code=404, detail="Currículo não encontrado.")
+    # retorna o registro completo como AnalyzeResponse (os campos batem)
+    return AnalyzeResponse(**c)
+
+# -----------------------------------------------------------------------------
+# Analyze (single) — aceita job_id OU job texto
 # -----------------------------------------------------------------------------
 @app.post("/analyze_cv", response_model=AnalyzeResponse, summary="Analisa um currículo (PDF ou texto)")
 async def analyze_cv_endpoint(
-    job: str = Form(..., description="Descrição completa da vaga"),
+    job: Optional[str] = Form(None, description="Descrição completa da vaga (alternativa a job_id)"),
+    job_id: Optional[str] = Form(None, description="ID de uma vaga previamente criada"),
     cv_text: Optional[str] = Form(None, description="Texto do currículo (alternativa a PDF)"),
     file: Optional[UploadFile] = File(None, description="Arquivo PDF do currículo")
 ):
     """
     Envie **cv_text** OU **file** (PDF).
     - Se PDF for enviado, o texto é extraído automaticamente.
+    - Informe **job_id** ou **job** (texto). Se nenhum for informado, a avaliação será genérica.
     """
     if not cv_text and not file:
         raise HTTPException(status_code=400, detail="Envie 'cv_text' ou 'file' (PDF).")
 
+    # Resolve job details
+    job_rec = None
+    if job_id:
+        job_rec = _get_job(job_id)
+        if not job_rec:
+            raise HTTPException(status_code=404, detail="job_id não encontrado.")
+        job_details = f"""**Vaga: {job_rec.get('title')}**
+
+**Descrição:**
+{job_rec.get('description')}
+
+**Detalhes:**
+{job_rec.get('details')}
+
+**Requisitos:**
+{", ".join(job_rec.get("requirements") or [])}
+"""
+    else:
+        job_details = job or "Vaga não especificada."
+
+    # Extrai texto do PDF se necessário
     if file:
         if not file.filename.lower().endswith(".pdf"):
             raise HTTPException(status_code=415, detail="Apenas PDF é suportado no 'file'.")
@@ -129,19 +283,61 @@ async def analyze_cv_endpoint(
     if not cv_text or not cv_text.strip():
         raise HTTPException(status_code=422, detail="Não foi possível extrair texto do currículo.")
 
-    result = analyze_cv_with_llm(cv_text=cv_text, job_details=job)
-    return result
+    # Chama LLM
+    result = analyze_cv_with_llm(cv_text=cv_text, job_details=job_details)
+    # Persiste e devolve
+    saved = _save_cv_result(result.dict(), job=job_rec)
+    return AnalyzeResponse(**saved)
+
+# -----------------------------------------------------------------------------
+# Analyze (batch) — multipart: files[] (compatível com teu front)
+# -----------------------------------------------------------------------------
+@app.post("/analyze_cv_batch_multipart", summary="Analisa vários PDFs via multipart (files[])")
+async def analyze_cv_batch_multipart(
+    job_id: Optional[str] = Form(None),
+    files: List[UploadFile] = File(...)
+):
+    job_rec = _get_job(job_id) if job_id else None
+    if job_id and not job_rec:
+        raise HTTPException(status_code=404, detail="job_id não encontrado.")
+
+    if not files:
+        raise HTTPException(status_code=400, detail="Envie 'files[]' com pelo menos 1 PDF.")
+
+    if job_rec:
+        job_details = f"""**Vaga: {job_rec.get('title')}**
 
+**Descrição:**
+{job_rec.get('description')}
+
+**Detalhes:**
+{job_rec.get('details')}
+
+**Requisitos:**
+{", ".join(job_rec.get("requirements") or [])}
+"""
+    else:
+        job_details = "Vaga não especificada."
+
+    results = []
+    for f in files:
+        if not f.filename.lower().endswith(".pdf"):
+            raise HTTPException(status_code=415, detail=f"Apenas PDF é suportado. Arquivo inválido: {f.filename}")
+        pdf_bytes = await f.read()
+        cv_text = extract_text_from_pdf(pdf_bytes)
+        if not cv_text.strip():
+            continue
+        res = analyze_cv_with_llm(cv_text=cv_text, job_details=job_details)
+        saved = _save_cv_result(res.dict(), job=job_rec)
+        results.append(saved)
+
+    return {"message": f"Analisados {len(results)} currículo(s).", "results": results}
+
+# -----------------------------------------------------------------------------
+# Analyze (batch) — JSON (já existia; mantido para compatibilidade)
+# -----------------------------------------------------------------------------
 @app.post("/analyze_cv_batch", response_model=List[AnalyzeResponse], summary="Analisa múltiplos currículos (JSON)")
 async def analyze_cv_batch_endpoint(payload: AnalyzeBatchRequest):
-    """
-    Recebe uma lista de itens, cada um com:
-    - `job` (str)
-    - `cv_text` (opcional)
-    - `cv_pdf_b64` (opcional, base64 do PDF)
-
-    Pelo menos um dos campos `cv_text` ou `cv_pdf_b64` deve existir.
-    """
     results: List[AnalyzeResponse] = []
     for item in payload.items:
         if not item.cv_text and not item.cv_pdf_b64:
@@ -149,23 +345,34 @@ async def analyze_cv_batch_endpoint(payload: AnalyzeBatchRequest):
 
         cv_text = item.cv_text
         if not cv_text and item.cv_pdf_b64:
-            import base64
             try:
                 pdf_bytes = base64.b64decode(item.cv_pdf_b64)
+                cv_text = extract_text_from_pdf(pdf_bytes)
             except Exception:
                 raise HTTPException(status_code=422, detail="cv_pdf_b64 inválido (base64).")
-            cv_text = extract_text_from_pdf(pdf_bytes)
 
         if not cv_text or not cv_text.strip():
             raise HTTPException(status_code=422, detail="Não foi possível extrair texto de um dos currículos.")
 
         res = analyze_cv_with_llm(cv_text=cv_text, job_details=item.job)
-        results.append(res)
+        saved = _save_cv_result(res.dict(), job=None)
+        results.append(AnalyzeResponse(**saved))
 
     return results
 
+# --- DEBUG: listar rotas no startup ---
+@app.on_event("startup")
+async def _print_routes():
+    print("\n=== ROTAS CARREGADAS ===")
+    for r in app.router.routes:
+        methods = getattr(r, "methods", [])
+        path = getattr(r, "path", "")
+        if methods and path:
+            print(f"{sorted(list(methods))} {path}")
+    print("========================\n")
+
 # -----------------------------------------------------------------------------
-# Main (útil localmente; no HF Space o CMD do Dockerfile já executa uvicorn)
+# Main (útil localmente; no HF o CMD do Dockerfile já executa uvicorn)
 # -----------------------------------------------------------------------------
 if __name__ == "__main__":
     uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", "7860")))

models_schemas.py

@@ -1,7 +1,11 @@
 from typing import List, Optional
 from pydantic import BaseModel, Field, validator
+from datetime import datetime
+
+# ----------- CV / Analyze -----------
 
 class AnalyzeResponse(BaseModel):
+    id: Optional[str] = None  # id salvo na base local
     name: Optional[str] = ""
     area: Optional[str] = ""
     summary: Optional[str] = ""
@@ -13,6 +17,9 @@ class AnalyzeResponse(BaseModel):
     important_considerations: List[str] = Field(default_factory=list)
     final_recommendations: Optional[str] = ""
     score: float = 0.0
+    created_at: Optional[str] = None
+    job_id: Optional[str] = None
+    job_title: Optional[str] = None
 
     @validator("score", pre=True, always=True)
     def coerce_score(cls, v):
@@ -28,3 +35,38 @@ class AnalyzeBatchItem(BaseModel):
 
 class AnalyzeBatchRequest(BaseModel):
     items: List[AnalyzeBatchItem]
+
+# ----------- Jobs -----------
+
+class JobCreateRequest(BaseModel):
+    title: str
+    description: str
+    details: str
+    requirements: List[str] = Field(default_factory=list)
+
+class Job(BaseModel):
+    id: str
+    title: str
+    description: str
+    details: str
+    requirements: List[str] = Field(default_factory=list)
+    created_at: str
+
+# ----------- CV records (listagem) -----------
+
+class CvRecord(BaseModel):
+    id: str
+    name: Optional[str] = ""
+    area: Optional[str] = ""
+    summary: Optional[str] = ""
+    score: float = 0.0
+    created_at: str
+    job_id: Optional[str] = None
+    job_title: Optional[str] = None
+
+    @validator("score", pre=True, always=True)
+    def cv_score_coerce(cls, v):
+        try:
+            return float(v)
+        except Exception:
+            return 0.0

storage.py

@@ -0,0 +1,97 @@
+import os
+import json
+import uuid
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+DATA_DIR = os.path.join(os.getcwd(), "data")
+JOBS_PATH = os.path.join(DATA_DIR, "jobs.json")
+CVS_PATH  = os.path.join(DATA_DIR, "cvs.json")
+
+def _ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+def _read_json(path: str) -> Any:
+    _ensure_data_dir()
+    if not os.path.exists(path):
+        # inicializa vazios
+        return [] if path.endswith(".json") else None
+    with open(path, "r", encoding="utf-8") as f:
+        try:
+            return json.load(f)
+        except Exception:
+            return []
+
+def _write_json(path: str, data: Any):
+    _ensure_data_dir()
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+# ---------------- Jobs ----------------
+
+def list_jobs() -> List[Dict[str, Any]]:
+    data = _read_json(JOBS_PATH)
+    if isinstance(data, dict):
+        data = [data]
+    return data or []
+
+def create_job(title: str, description: str, details: str, requirements: Optional[list]=None) -> Dict[str, Any]:
+    jobs = list_jobs()
+    job_id = str(uuid.uuid4())
+    rec = {
+        "id": job_id,
+        "title": title,
+        "description": description,
+        "details": details,
+        "requirements": requirements or [],
+        "created_at": datetime.utcnow().isoformat()
+    }
+    jobs.append(rec)
+    _write_json(JOBS_PATH, jobs)
+    return rec
+
+def get_job(job_id: str) -> Optional[Dict[str, Any]]:
+    for j in list_jobs():
+        if j.get("id") == job_id:
+            return j
+    return None
+
+# ---------------- CVs ----------------
+
+def list_cvs() -> List[Dict[str, Any]]:
+    data = _read_json(CVS_PATH)
+    if isinstance(data, dict):
+        data = [data]
+    return data or []
+
+def save_cv_result(result: Dict[str, Any], job: Optional[Dict[str, Any]]=None) -> Dict[str, Any]:
+    cvs = list_cvs()
+    rec_id = str(uuid.uuid4())
+
+    rec = {
+        "id": rec_id,
+        "name": result.get("name") or "",
+        "area": result.get("area") or "",
+        "summary": result.get("summary") or "",
+        "skills": result.get("skills") or [],
+        "education": result.get("education") or "",
+        "interview_questions": result.get("interview_questions") or [],
+        "strengths": result.get("strengths") or [],
+        "areas_for_development": result.get("areas_for_development") or [],
+        "important_considerations": result.get("important_considerations") or [],
+        "final_recommendations": result.get("final_recommendations") or "",
+        "score": result.get("score") or 0.0,
+        "created_at": datetime.utcnow().isoformat(),
+        "job_id": job.get("id") if job else None,
+        "job_title": job.get("title") if job else None
+    }
+
+    cvs.append(rec)
+    _write_json(CVS_PATH, cvs)
+    return rec
+
+def get_cv(cv_id: str) -> Optional[Dict[str, Any]]:
+    for c in list_cvs():
+        if c.get("id") == cv_id:
+            return c
+    return None