Added ARS

Ars/ai_functions.py

@@ -1,18 +1,18 @@
 from pdfminer.high_level import extract_text_to_fp
 from io import BytesIO
-from Ars.objects import ai,ResumeData,AutomationRiskResult,AutomationRiskInput,RealWorldQuestion,SkillDepthResult,SkillDepthInput,BreakDownByDomainUpdate,FlaggedRiskAreasUpdate,BoostSuggestionsUpdate,AICollabReadinessInput
-from Ars.embedDoc import search_pinecone_text
+from objects import ai,ResumeData,AutomationRiskResult,AutomationRiskInput,RealWorldQuestion,SkillDepthResult,SkillDepthInput,BreakDownByDomainUpdate,FlaggedRiskAreasUpdate,BoostSuggestionsUpdate,AICollabReadinessInput
+from embedDoc import search_pinecone_text
 from fastapi import UploadFile
+
 def extract_text_from_bytes(pdf_bytes: bytes) -> str:
     output_string = BytesIO()
     with BytesIO(pdf_bytes) as input_stream:
         extract_text_to_fp(input_stream, output_string)
     return output_string.getvalue().decode()
 
-
             
-async def resume_analysis(contents) -> ResumeData:
-    
+async def resume_analysis(upload_file:UploadFile) -> ResumeData:
+    contents = await upload_file.read()
     resume = extract_text_from_bytes(pdf_bytes=contents)
     if resume:
         prompt = f"""

Ars/controllers.py

@@ -1,44 +1,19 @@
-from Ars.core import r
-from Ars.repositories import get_document_by_hashed_doc_complete,get_document_by_hashed_doc,create_new_hashed_doc_entry,create_boost_suggestions,create_breakdown_by_domain,create_flagged_risk_areas,create_user_resilience
+from core import r
+from repositories import create_boost_suggestions,create_breakdown_by_domain,create_flagged_risk_areas,create_user_resilience
 from fastapi import UploadFile
-from Ars.ai_functions import extract_text_from_bytes,resume_analysis,calculate_automation_risk,calculate_Ai_collab_readiness,calculate_skill_depth,generate_boost_suggestion,generate_domain_breakdown,generate_flagged_risk_areas
-from Ars.objects import AICollabReadiness,SkillDepthResult,AutomationRiskResult 
-import hashlib
+from ai_functions import resume_analysis,calculate_automation_risk,calculate_Ai_collab_readiness,calculate_skill_depth,generate_boost_suggestion,generate_domain_breakdown,generate_flagged_risk_areas
+from objects import AICollabReadiness,SkillDepthResult,AutomationRiskResult 
+async def resilience_analysis(file:UploadFile):
+    resume= await resume_analysis(file)
+    risk = calculate_automation_risk(resume)
+    risk = AutomationRiskResult(**risk.model_dump())
+    skill_depth =  calculate_skill_depth(resume)
+    skill_depth= SkillDepthResult(**skill_depth.model_dump())
+    ai_readiness = calculate_Ai_collab_readiness(resume)
+    ai_readiness = AICollabReadiness(**ai_readiness.model_dump())
+    ResilienceScore = ((1-(risk.result/100))*0.5+(skill_depth.result/100)*0.3+(ai_readiness.result/100)*0.2)
+    flagged_risk =generate_flagged_risk_areas(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+    boost_suggestion = generate_boost_suggestion(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
+    domain_breakdown = generate_domain_breakdown(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
 
-def get_document_hash(document_content: str) -> str:
-    # Ensure consistent encoding (e.g., UTF-8) before hashing
-    document_bytes = document_content.encode('utf-8')
-    hasher = hashlib.sha256()
-    hasher.update(document_bytes)
-    return hasher.hexdigest()
-
-async def resilience_analysis(file:UploadFile,userId:str):
-    contents = await file.read()
-    resume_text = extract_text_from_bytes(pdf_bytes=contents)
-    hashed_doc = get_document_hash(resume_text)
-    
-    check = await get_document_by_hashed_doc(hashed_doc=hashed_doc)
-    if check==None:
-        resume= await resume_analysis(contents)
-        risk = calculate_automation_risk(resume)
-        risk = AutomationRiskResult(**risk.model_dump())
-        skill_depth =  calculate_skill_depth(resume)
-        skill_depth= SkillDepthResult(**skill_depth.model_dump())
-        ai_readiness = calculate_Ai_collab_readiness(resume)
-        ai_readiness = AICollabReadiness(**ai_readiness.model_dump())
-        ResilienceScore = ((1-(risk.result/100))*0.5+(skill_depth.result/100)*0.3+(ai_readiness.result/100)*0.2)
-        flagged_risk =generate_flagged_risk_areas(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
-        boost_suggestion = generate_boost_suggestion(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
-        domain_breakdown = generate_domain_breakdown(resume=resume,skil_depth=skill_depth,risk=risk,ai_readiness=ai_readiness)
-        final_analysis_response ={"overall score": ResilienceScore,"flagged Risk": flagged_risk.model_dump(),"boost suggestion":boost_suggestion.model_dump(),"domain breakdown":domain_breakdown.model_dump(),"resume":resume.model_dump(),"skil_depth":skill_depth.model_dump(),"risk":risk.model_dump(),"ai_readiness":ai_readiness.model_dump()}
-        resultId =await create_new_hashed_doc_entry(data={"hashed_doc":hashed_doc,"resume":final_analysis_response,"userId":userId})
-        return  final_analysis_response
-    else:
-        result_hash =await get_document_by_hashed_doc_complete(hashed_doc)
-        if result_hash['hashed_doc']==hashed_doc and result_hash['userId']== userId:
-            
-            await create_new_hashed_doc_entry(data={"hashed_doc":hashed_doc,"resume":check,"userId":userId})
-            return check
-        
-        await create_new_hashed_doc_entry(data={"hashed_doc":hashed_doc,"resume":check,"userId":userId})
-        return check
+    return {"overall score": ResilienceScore,"flagged Risk": flagged_risk,"boost suggestion":boost_suggestion,"domain breakdown":domain_breakdown,"resume":resume,"skil_depth":skill_depth,"risk":risk,"ai_readiness":ai_readiness}

Ars/repositories.py

@@ -1,68 +1,11 @@
-from Ars.core import db
+from core import db
 from bson import ObjectId
 from fastapi import HTTPException
 from typing import Optional, List
 from motor.motor_asyncio import AsyncIOMotorDatabase
-from Ars.objects import UserResilienceScoreCreate, UserResilienceScoreOut,BreakDownByDomainCreate,BreakDownByDomainOut,FlaggedRiskAreasCreate,FlaggedRiskAreasOut,BoostSuggestionsCreate,BoostSuggestionsOut,BoostSuggestionsUpdate,UserResilienceScoreUpdate,FlaggedRiskAreasUpdate,BreakDownByDomainUpdate
-import pymongo
+from objects import UserResilienceScoreCreate, UserResilienceScoreOut,BreakDownByDomainCreate,BreakDownByDomainOut,FlaggedRiskAreasCreate,FlaggedRiskAreasOut,BoostSuggestionsCreate,BoostSuggestionsOut,BoostSuggestionsUpdate,UserResilienceScoreUpdate,FlaggedRiskAreasUpdate,BreakDownByDomainUpdate
+
 
-async def create_new_hashed_doc_entry(data: dict):
-    
-    try:
-        # Attempt to insert the document, ensuring hashed_doc is unique due to the index
-        result = await db.resume_resilience_analysis.insert_one(document=data)
-        return {"inserted_id": result.inserted_id,"error":None}  # Return the inserted ID
-    except pymongo.errors.DuplicateKeyError:
-        # Handle the case where a document with the same 'hashed_doc' already exists
-        return {"error": "Document with this 'hashed_doc' already exists"}
-    except Exception as e:
-        # Catch other exceptions (e.g., database connection issues)
-        return {"error": str(e)}
-    
-async def get_document_by_hashed_doc(hashed_doc: str):
-    try:
-        # Find the document using the hashed_doc field
-        document = await db.resume_resilience_analysis.find_one({"hashed_doc": hashed_doc})
-        
-        if document:
-            return document['resume']
-        else:
-            return None
-    
-    except Exception as e:
-        # Handle any other errors, like database issues
-        return {"error": str(e)}
-    
-async def get_document_by_hashed_doc_complete(hashed_doc: str):
-    try:
-        # Find the document using the hashed_doc field
-        document = await db.resume_resilience_analysis.find_one({"hashed_doc": hashed_doc})
-        
-        if document:
-            return document
-        else:
-            return None
-    
-    except Exception as e:
-        # Handle any other errors, like database issues
-        return {"error": str(e)}
-
-
-async def get_document_by_userId(userId: str):
-    try:
-        # Find the document using the hashed_doc field
-        document = await db.resume_resilience_analysis.find_one({"userId": userId})
-        
-        if document:
-            return document['resume']
-        else:
-            return None
-    
-    except Exception as e:
-        # Handle any other errors, like database issues
-        return {"error": str(e)}
-    
-    
 async def create_user_resilience(  data: UserResilienceScoreCreate) -> UserResilienceScoreOut:
     """
     Create a new UserResilienceScore in the database.

Ars/routes.py

@@ -1,31 +1,15 @@
 import base64
-from fastapi import FastAPI, File, UploadFile,HTTPException,Depends
-from Ars.controllers import resilience_analysis
-from Ars.repositories import get_document_by_userId
-from security.authDependency import verifyAccessToken
-from Ars.embedDoc import upsert_text_with_chunks,search_pinecone_text
-import hashlib
-
-
+from fastapi import FastAPI, File, UploadFile,HTTPException
+from controllers import resilience_analysis
+from embedDoc import upsert_text_with_chunks,search_pinecone_text
 ARS = FastAPI()
 
-
-
-
-
 @ARS.post("/risk-analysis")
-async def perform_risk_analysis(user =Depends(verifyAccessToken) ,file: UploadFile = File(...), ):
+async def perform_risk_analysis(file: UploadFile = File(...)):
     if file.content_type != "application/pdf":
         return HTTPException(status_code=400, detail={"error": "File must be a PDF."})
-    
-    ResilienceScore = await resilience_analysis(file=file,userId=user['userId'])
+    ResilienceScore = await resilience_analysis(file=file)
     return ResilienceScore
 
 
     
-@ARS.get("/risk-analysis")
-async def perform_risk_analysis(user=Depends(verifyAccessToken) ):
-    ResilienceScore = await get_document_by_userId(userId=user['userId'])
-    
-    return ResilienceScore
-

Dockerfile

@@ -1,7 +1,7 @@
 # Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
 # you will also find guides on how best to write your Dockerfile
 
-FROM python:3.11
+FROM python:3.9
 
 RUN useradd -m -u 1000 user
 USER user

README.md

@@ -8,4 +8,7 @@ pinned: false
 license: apache-2.0
 ---
 
+<<<<<<< HEAD
+=======
 if you are changing the connection string in the env to a new one ensure you populate the levels table with levels up to level9 for a default career path and default level name else points won't be calculated properly
+>>>>>>> master

controller/imports.py

@@ -12,7 +12,7 @@ import fitz
 from gamification.routes import gamification
 from controller.scraper import scrapeCourse
 import asyncio
-from google import genai
+from google import genai 
 from typing import Optional,List
 from pydantic import BaseModel
 import re

gamification/pointLogic.py

@@ -93,6 +93,16 @@ def get_all_simple_points_func(userId) -> SimpleIndividualUserLevel:
     db = client[db_name]
     collection = db[collection_name]
     dreamJob = get_dream_job(userId=userId)
+<<<<<<< HEAD
+    
+    point_cursor = collection.find({"userId": userId})
+    try:
+        points_list = list(point_cursor)
+    
+        totalPoints = sum([point['numOfPoints'] for point in points_list])
+        particularLevelInfo = get_particular_level(dreamJob=dreamJob,totalPoints=totalPoints)
+
+=======
     print(dreamJob)
     point_cursor = collection.find({"userId": userId})
     try:
@@ -102,6 +112,7 @@ def get_all_simple_points_func(userId) -> SimpleIndividualUserLevel:
         
         particularLevelInfo = get_particular_level(dreamJob=dreamJob,totalPoints=totalPoints)
         print(particularLevelInfo)
+>>>>>>> master
         points = SimpleIndividualUserLevel(totalpoints=totalPoints,levelName=particularLevelInfo[0].levelName,maxPoints=particularLevelInfo[0].maxPoints,minPoints=particularLevelInfo[0].minPoints,levelNumber=particularLevelInfo[0].levelNumber)
     except:
         totalPoints = 0

requirements.txt

@@ -1,75 +1,22 @@
-# Core web stack
 fastapi[all]
-uvicorn
-gunicorn
 requests
 python-dotenv
-
-# PDF, Docx handling
 pymupdf
-python-docx
-docx2txt
-pdfminer.six # Use only this (newest), remove old 'pdfminer'
-
-# MongoDB
+<<<<<<< HEAD
+=======
 motor
-pymongo
-
-# AI and embedding
-openai
-sentence-transformers
+>>>>>>> master
 pinecone
-langchain-text-splitters
-langchain-core
-transformers
-torch
+sentence-transformers
 einops
-
-# Google GenAI
-google-generativeai
-google-auth
-google-api-python-client
 google-genai
-
-# Authentication
+python-docx
+beautifulsoup4
+pymongo
 bcrypt
-passlib[bcrypt]
 python-jose[cryptography]
-
-# Redis
+passlib[bcrypt]
+uvicorn
+gunicorn  # Add this for production
 redis
-
-# Frontend templating and security
-jinja2
-itsdangerous
-
-# Other utilities
-python-multipart
-pydantic-settings
-pydantic-extra-types
-
-# Windows only (skip on Linux/mac)
-# Remove pywin32==308, use the latest
-
-# Optional tools
-tqdm
-beautifulsoup4
-httpx
-httpcore
-
-# ML / Data
-scikit-learn
-pandas
-numpy
-matplotlib-inline
-joblib
-scipy
-
-# Optional for resume parsing
-pyresparser
-email-validator
-
-# Logging, async, extras
-rich
-watchfiles
-nest-asyncio
+cryptography

security/authDependency.py

@@ -1,14 +0,0 @@
-from fastapi.security import HTTPBearer
-from fastapi import Depends
-from controller.imports import *
-
-token_auth_scheme = HTTPBearer()
-
-def verifyAccessToken(token:str =Depends(token_auth_scheme)):
-    credentials = token.credentials
-    decoded_user_id,decoded_access_token = decode_jwt(credentials) 
-    is_valid = verify_access_token(db_uri=MONGO_URI, user_id=decoded_user_id, access_token=decoded_access_token)
-    if is_valid != True:  # Example check
-        raise HTTPException(status_code=401, detail="Invalid token")
-    else:
-        return {"userId":decoded_user_id}