ars

Ars/controllers.py

@@ -0,0 +1,53 @@
+
+# TODO: perform calculation Risk Calculation and also generate Breakdown by Domain from resume, generate Flagged Risk areas from resume and boost suggestions from resume
+
+# NOTE: to perform risk calculation we use this formula ResilienceScore = (1 - AutomationRisk) * 0.5 + SkillDepth * 0.3 + AICollabReadiness * 0.2 
+# NOTE: - **Automation Risk** is inverted (lower risk = higher score)
+# NOTE:- Normalize each sub-score to a scale of 0–100
+# NOTE: - Final score is a 0–100 **Crayonics Resilience Score**
+
+# TODO: things I'm gonna need 1. An AI , 2. Cache Controller 3. Database functions
+from Ars.core import r
+
+
+
+def analyze_resume(resume_text: str) -> dict:
+    # Step 1: Check cache
+    cached = r.get(resume_text)
+    if cached:
+        return cached
+
+    # Step 2: Extract skills, domains, and experience info
+    extracted_data = extract_resume_insights(resume_text)
+
+    # Step 3: Score sub-components
+    automation_risk = calculate_automation_risk(extracted_data)
+    skill_depth = calculate_skill_depth(extracted_data)
+    ai_collab_readiness = calculate_ai_collab_readiness(extracted_data)
+
+    # Normalize sub-scores to 0–100
+    automation_risk = normalize_score(1 - automation_risk)
+    skill_depth = normalize_score(skill_depth)
+    ai_collab_readiness = normalize_score(ai_collab_readiness)
+
+    # Step 4: Final score
+    resilience_score = (automation_risk * 0.5 +
+                        skill_depth * 0.3 +
+                        ai_collab_readiness * 0.2)
+
+    # Step 5: Breakdown, flags, suggestions
+    breakdown = generate_domain_breakdown(extracted_data)
+    risk_flags = identify_risk_flags(extracted_data)
+    suggestions = generate_boost_suggestions(risk_flags, extracted_data)
+
+    # Step 6: Package and cache
+    result = {
+        "resilience_score": round(resilience_score, 2),
+        "breakdown_by_domain": breakdown,
+        "flagged_risk_areas": risk_flags,
+        "boost_suggestions": suggestions,
+    }
+    r.setex(name=resume_text,value= result,time=3600)
+    db_controller.save_analysis_result(resume_text, result)
+
+    return result

Ars/core.py

@@ -0,0 +1,24 @@
+# db.py
+import os
+from dotenv import load_dotenv
+import redis
+from motor.motor_asyncio import AsyncIOMotorClient
+load_dotenv()
+
+MONGO_URI = os.getenv('MONGO_URI')
+DB_NAME = "crayonics"
+REDIS_HOST = os.getenv('REDIS_HOST', 'localhost')
+REDIS_PORT = int(os.getenv('REDIS_PORT', 6379))
+REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', None)
+FERNET_SECRET_KEY = os.getenv('FERNET_SECRET_KEY')
+REDIS_USERNAME=os.getenv('REDIS_USERNAME')
+client = AsyncIOMotorClient(MONGO_URI)
+db = client[DB_NAME]
+r = redis.StrictRedis(
+    host=REDIS_HOST,
+    port=REDIS_PORT,
+    password=REDIS_PASSWORD,
+    username=REDIS_USERNAME,
+    db=0,
+    decode_responses=True
+)

Ars/objects.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+from pydantic import model_validator, BaseModel
+from typing import List, Optional, Union
+from bson import ObjectId
+
+class UserResilienceScoreCreate(BaseModel):
+
+    overallScore: float
+    userId: str
+    BreakDownByDomainId: str
+    FlaggedRiskAreasId: str
+    BoostSuggestionsId: str
+
+
+class UserResilienceScoreUpdate(BaseModel):
+
+    overallScore: Optional[float]=None
+    BreakDownByDomainId: Optional[str]=None
+    FlaggedRiskAreasId: Optional[str]=None
+    BoostSuggestionsId: Optional[str]=None
+
+    
+    
+class BreakDownByDomainCreate(BaseModel):
+    userId:str
+    Technical:float
+    Creative:float
+    Strategy:float
+    Collaboration:float
+    
+    
+class BreakDownByDomainUpdate(BaseModel):
+    
+    Technical:Optional[float]=None
+    Creative:Optional[float]=None
+    Strategy:Optional[float]=None
+    Collaboration:Optional[float]=None
+
+    
+class FlaggedRiskAreasCreate(BaseModel):
+    userId:str
+    risk_areas:List[str]
+    
+class FlaggedRiskAreasUpdate(BaseModel):
+
+    risk_areas:List[str]
+    
+    
+class BoostSuggestionsCreate(BaseModel):
+
+    boost_suggestions:List[str]
+   
+
+    
+class BoostSuggestionsUpdate(BaseModel):
+
+    boost_suggestions:List[str]
+   
+
+
+class UserResilienceScoreOut(UserResilienceScoreCreate):
+    _id: Optional[ObjectId]=None  # Make sure _id can be Optional
+    id:Optional[str]=None
+    # To convert MongoDB ObjectId to string
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+    # Custom validator to handle the ObjectId conversion if needed
+    @model_validator(mode='before')
+    def handle_objectid(cls, values):
+        if '_id' in values and isinstance(values['_id'], ObjectId):
+            values['id'] = str(values['_id'])  # Convert ObjectId to string
+        return values
+    
+class BreakDownByDomainOut(BreakDownByDomainCreate):
+    _id: Optional[ObjectId]=None  # Make sure _id can be Optional
+    id:Optional[str]=None
+    # To convert MongoDB ObjectId to string
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+    # Custom validator to handle the ObjectId conversion if needed
+    @model_validator(mode='before')
+    def handle_objectid(cls, values):
+        if '_id' in values and isinstance(values['_id'], ObjectId):
+            values['id'] = str(values['_id'])  # Convert ObjectId to string
+        return values
+    
+class FlaggedRiskAreasOut(FlaggedRiskAreasCreate):
+    _id: Optional[ObjectId]=None  # Make sure _id can be Optional
+    id:Optional[str]=None
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+    # Custom validator to handle the ObjectId conversion if needed
+    @model_validator(mode='before')
+    def handle_objectid(cls, values):
+        if '_id' in values and isinstance(values['_id'], ObjectId):
+            values['id'] = str(values['_id'])  # Convert ObjectId to string
+        return values
+class BoostSuggestionsOut(BoostSuggestionsCreate):
+    _id: Optional[ObjectId]=None  # Make sure _id can be Optional
+    id:Optional[str]=None
+    class Config:
+        json_encoders = {
+            ObjectId: str
+        }
+
+    # Custom validator to handle the ObjectId conversion if needed
+    @model_validator(mode='before')
+    def handle_objectid(cls, values):
+        if '_id' in values and isinstance(values['_id'], ObjectId):
+            values['id'] = str(values['_id'])  # Convert ObjectId to string
+        return values

Ars/repositories.py

@@ -0,0 +1,407 @@
+from Ars.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
+
+
+async def create_user_resilience(  data: UserResilienceScoreCreate) -> UserResilienceScoreOut:
+    """
+    Create a new UserResilienceScore in the database.
+
+    Args:
+        db: The MongoDB database instance.
+        data: A Pydantic object containing the fields to create.
+
+    Returns:
+        The newly created object.
+    """
+    result = await db.user_resilience.insert_one(data.model_dump())
+    created = await db.user_resilience.find_one({"_id": result.inserted_id})
+    out = UserResilienceScoreOut(**created)
+    return out
+
+
+async def get_user_resilience(  object_id: str) -> Optional[UserResilienceScoreOut]:
+    """
+    Retrieve a UserResilienceScore by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to retrieve.
+
+    Returns:
+        An bject, or raises 404 if not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.user_resilience.find_one({"_id": ObjectId(object_id)})
+    
+    if result is None:
+        raise HTTPException(status_code=404, detail="Object not found")
+    out =UserResilienceScoreOut(**result)
+    return out
+
+
+async def update_user_resilience(  object_id: str, data: UserResilienceScoreUpdate) -> UserResilienceScoreOut:
+    """
+    Update a UserResilienceScore by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to update.
+        data: A Pydantic object with the updated fields.
+
+    Returns:
+        The updated object dictionary.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    update_data = {k: v for k, v in data.dict().items() if v is not None}
+    result = await db.user_resilience.update_one(
+        {"_id": ObjectId(object_id)},
+        {"$set": update_data}
+    )
+
+    if result.matched_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    updateresult =await db.user_resilience.find_one({"_id": ObjectId(object_id)})
+    out = UserResilienceScoreOut(**updateresult)
+    return out
+    
+
+
+async def delete_user_resilience(  object_id: str) -> dict:
+    """
+    Delete a UserResilienceScore by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to delete.
+
+    Returns:
+        A confirmation message or raises 404 if object is not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.user_resilience.delete_one({"_id": ObjectId(object_id)})
+
+    if result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    return {"message": "Object deleted successfully"}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async def create_breakdown_by_domain(  data:  BreakDownByDomainCreate) ->  BreakDownByDomainOut:
+    """
+    Create a new  BreakDownByDomain in the database.
+
+    Args:
+        db: The MongoDB database instance.
+        data: A Pydantic object containing the fields to create.
+
+    Returns:
+        A dictionary representing the newly created object.
+    """
+    result = await db.breakdown_by_domain.insert_one(data.dict())
+    created = await db.breakdown_by_domain.find_one({"_id": result.inserted_id})
+    out =  BreakDownByDomainOut(**created)
+    return out
+
+
+async def get_breakdown_by_domain(  object_id: str) -> Optional[ BreakDownByDomainOut]:
+    """
+    Retrieve a  BreakDownByDomain by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to retrieve.
+
+    Returns:
+        A dictionary of the found object, or raises 404 if not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.breakdown_by_domain.find_one({"_id": ObjectId(object_id)})
+    
+    if result is None:
+        raise HTTPException(status_code=404, detail="Object not found")
+    out = BreakDownByDomainOut(**result)
+    return out
+
+
+async def update_breakdown_by_domain(  object_id: str, data:  BreakDownByDomainUpdate) ->  BreakDownByDomainOut:
+    """
+    Update a  BreakDownByDomain by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to update.
+        data: A Pydantic object with the updated fields.
+
+    Returns:
+        The updated object dictionary.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    update_data = {k: v for k, v in data.dict().items() if v is not None}
+    result = await db.breakdown_by_domain.update_one(
+        {"_id": ObjectId(object_id)},
+        {"$set": update_data}
+    )
+
+    if result.matched_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    updateresult =await db. breakdown_by_domain.find_one({"_id": ObjectId(object_id)})
+    out =  BreakDownByDomainOut(**updateresult)
+    return out
+    
+
+
+async def delete_breakdown_by_domain(  object_id: str) -> dict:
+    """
+    Delete a  BreakDownByDomain by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to delete.
+
+    Returns:
+        A confirmation message or raises 404 if object is not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.breakdown_by_domain.delete_one({"_id": ObjectId(object_id)})
+
+    if result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    return {"message": "Object deleted successfully"}
+
+
+
+
+
+
+
+
+
+async def create_flagged_risk_areas(  data:  FlaggedRiskAreasCreate) ->  FlaggedRiskAreasOut:
+    """
+    Create a new  BreakDownByDomain in the database.
+
+    Args:
+        db: The MongoDB database instance.
+        data: A Pydantic object containing the fields to create.
+
+    Returns:
+        A dictionary representing the newly created object.
+    """
+    result = await db.flagged_risk_areas.insert_one(data.dict())
+    created = await db.flagged_risk_areas.find_one({"_id": result.inserted_id})
+    out = FlaggedRiskAreasOut(**created)
+    return out
+
+
+async def get_flagged_risk_areas(  object_id: str) -> Optional[FlaggedRiskAreasOut]:
+    """
+    Retrieve a FlaggedRiskAreas by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to retrieve.
+
+    Returns:
+        A dictionary of the found object, or raises 404 if not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.flagged_risk_areas.find_one({"_id": ObjectId(object_id)})
+    
+    if result is None:
+        raise HTTPException(status_code=404, detail="Object not found")
+    out =FlaggedRiskAreasOut(**result)
+    return out
+
+
+async def update_flagged_risk_areas(  object_id: str, data: FlaggedRiskAreasUpdate) -> FlaggedRiskAreasOut:
+    """
+    Update a FlaggedRiskAreas by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to update.
+        data: A Pydantic object with the updated fields.
+
+    Returns:
+        The updated object dictionary.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    update_data = {k: v for k, v in data.dict().items() if v is not None}
+    result = await db.flagged_risk_areas.update_one(
+        {"_id": ObjectId(object_id)},
+        {"$set": update_data}
+    )
+
+    if result.matched_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    updateresult =await db.flagged_risk_areas.find_one({"_id": ObjectId(object_id)})
+    out = FlaggedRiskAreasOut(**updateresult)
+    return out
+    
+
+
+async def delete_flagged_risk_areas(  object_id: str) -> dict:
+    """
+    Delete a FlaggedRiskAreas by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to delete.
+
+    Returns:
+        A confirmation message or raises 404 if object is not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.flagged_risk_areas.delete_one({"_id": ObjectId(object_id)})
+
+    if result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    return {"message": "Object deleted successfully"}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async def create_boost_suggestions(  data: BoostSuggestionsCreate) -> BoostSuggestionsOut:
+    """
+    Create a new BoostSuggestions in the database.
+
+    Args:
+        db: The MongoDB database instance.
+        data: A Pydantic object containing the fields to create.
+
+    Returns:
+        A dictionary representing the newly created object.
+    """
+    result = await db.boost_suggestions.insert_one(data.dict())
+    created = await db.boost_suggestions.find_one({"_id": result.inserted_id})
+    out = BoostSuggestionsOut(**created)
+    return out
+
+
+async def get_boost_suggestions(  object_id: str) -> Optional[BoostSuggestionsOut]:
+    """
+    Retrieve a BoostSuggestions by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to retrieve.
+
+    Returns:
+        A dictionary of the found object, or raises 404 if not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.boost_suggestions.find_one({"_id": ObjectId(object_id)})
+    
+    if result is None:
+        raise HTTPException(status_code=404, detail="Object not found")
+    out =BoostSuggestionsOut(**result)
+    return out
+
+
+async def update_boost_suggestions(  object_id: str, data: BoostSuggestionsUpdate) -> BoostSuggestionsOut:
+    """
+    Update a BoostSuggestions by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to update.
+        data: A Pydantic object with the updated fields.
+
+    Returns:
+        The updated object dictionary.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    update_data = {k: v for k, v in data.dict().items() if v is not None}
+    result = await db.boost_suggestions.update_one(
+        {"_id": ObjectId(object_id)},
+        {"$set": update_data}
+    )
+
+    if result.matched_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    updateresult =await db.boost_suggestions.find_one({"_id": ObjectId(object_id)})
+    out = BoostSuggestionsOut(**updateresult)
+    return out
+    
+
+
+async def delete_boost_suggestions(  object_id: str) -> dict:
+    """
+    Delete a BoostSuggestions by its ID.
+
+    Args:
+        db: The MongoDB database instance.
+        object_id: The ID of the object to delete.
+
+    Returns:
+        A confirmation message or raises 404 if object is not found.
+    """
+    if not ObjectId.is_valid(object_id):
+        raise HTTPException(status_code=400, detail="Invalid ID format")
+
+    result = await db.boost_suggestions.delete_one({"_id": ObjectId(object_id)})
+
+    if result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="Object not found")
+
+    return {"message": "Object deleted successfully"}

README.md

@@ -8,3 +8,4 @@ pinned: false
 license: apache-2.0
 ---
 
+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

gamification/pointLogic.py

@@ -93,14 +93,15 @@ def get_all_simple_points_func(userId) -> SimpleIndividualUserLevel:
     db = client[db_name]
     collection = db[collection_name]
     dreamJob = get_dream_job(userId=userId)
-    
+    print(dreamJob)
     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(particularLevelInfo)
         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

@@ -2,6 +2,7 @@ fastapi[all]
 requests
 python-dotenv
 pymupdf
+motor
 pinecone
 sentence-transformers
 einops