added ars route

Ars/ai_functions.py

@@ -1,6 +1,6 @@
 from pdfminer.high_level import extract_text_to_fp
 from io import BytesIO
-from objects import ai,ResumeData,AutomationRiskResult,RealWorldQuestion,SkillDepthResult,BreakDownByDomainUpdate,FlaggedRiskAreasUpdate,BoostSuggestionsUpdate
+from objects import ai,ResumeData,AutomationRiskResult,AutomationRiskInput,RealWorldQuestion,SkillDepthResult,SkillDepthInput,BreakDownByDomainUpdate,FlaggedRiskAreasUpdate,BoostSuggestionsUpdate,AICollabReadinessInput
 from embedDoc import search_pinecone_text
 from fastapi import UploadFile
 
@@ -56,26 +56,52 @@ def calculate_automation_risk(resume:ResumeData):
 
     real_world_data=generate_real_world_data(resume=resume)
     prompt = f"""
-            You are an Automation Risk Calculator. Read the following resume Data and estimate How easily you can automate the skills and job titles of the user persona some real world data would be given to you the data may or may not provide help with your estimation:
+    You are an Automation Risk Calculator AI. Your task is to analyze the user's resume and any provided real-world data to estimate how automatable their skills and job titles are.
 
-            Here is the resume:
+    For each of the following factors, please evaluate on a scale from 0 to 5, where:
 
-            (
-                {resume}
-            )
-            
-            Here is the data:
-            
-            (
-                {real_world_data}
-            )
-            
-            Return Just Numbers MAX (100) MIN (0)Automation Risk is inverted (lower risk = higher score)
-            """
-    result=ai.chat(prompt=prompt,output_schema=AutomationRiskResult)
-    return result
+    0 = Not present or irrelevant  
+    1 = Very low presence or impact  
+    2 = Low presence or impact  
+    3 = Moderate presence or impact  
+    4 = High presence or impact  
+    5 = Very high presence or impact
+
+    Factors to score:
+
+    - repetitiveness of tasks  
+    - creativity required  
+    - emotional intelligence needed  
+    - reliance on data-driven tasks  
+    - physical/manual work involved  
+    - level of autonomous decision-making  
+    - need for strategic thinking  
+    - importance of collaboration  
+    - current use of AI tools in the role  
+    - recent upskilling or adaptability  
 
+    The real-world data may contain labor market trends, automation probabilities, or other relevant insights — use it if helpful.
 
+    After scoring all factors, calculate an overall automation risk score between 0 and 100, where:  
+    - 100 means very low automation risk (skills are highly resilient to automation),  
+    - 0 means very high automation risk (skills are highly automatable).
+
+    Return only the final integer risk score (0 to 100) — no explanations or extra text.
+
+    Here is the resume:
+
+    (
+    {resume}
+    )
+
+    Here is the real-world data:
+
+    (
+    {real_world_data}
+    )
+    """
+    result = ai.chat(prompt=prompt, output_schema=AutomationRiskInput)
+    return result
 
 
 
@@ -83,17 +109,50 @@ def calculate_skill_depth(resume:ResumeData):
 
 
     prompt = f"""
-            You are an Skill Depth Calculator. Read the following resume Data and Score based on number of years per skill, seniority of roles, certification presence:
-
-            Here is the resume:
+You are a Skill Depth Calculator AI. Your task is to analyze the user's resume data and score various skill-related factors.
+
+For each of the following factors, please score on a scale from 0 to 5, where:
+
+0 = Not present or no depth  
+1 = Very shallow experience or presence  
+2 = Basic or limited experience  
+3 = Moderate experience or involvement  
+4 = Strong experience or senior level  
+5 = Expert or highly advanced experience  
+
+Factors to score include (but are not limited to):
+
+- Years of experience per skill  
+- Seniority level in roles held  
+- Number and relevance of certifications  
+- Breadth of skills (variety and diversity)  
+- Depth in core technical skills  
+- Depth in leadership or management skills  
+- Involvement in complex projects  
+- Contributions to strategic initiatives  
+- Frequency of skill usage in recent roles  
+- Evidence of continuous learning or upskilling  
+- Cross-functional collaboration skills  
+- Recognition or awards related to skills  
+- Public speaking or training experience  
+- Publications or patents (if any)  
+- Industry-specific expertise depth  
+- Mentoring or coaching experience  
+- Ability to innovate using skills  
+- Adaptability to new technologies  
+- Problem-solving skills depth  
+- Communication skills related to technical content  
+
+
+
+Here is the resume:
+
+(
+{resume}
+)
+"""
 
-            (
-                {resume}
-            )
-            
-            Return Just Numbers MAX (100) MIN (0)
-            """
-    result=ai.chat(prompt=prompt,output_schema=SkillDepthResult)
+    result=ai.chat(prompt=prompt,output_schema=SkillDepthInput)
     return result
 
 
@@ -102,20 +161,39 @@ def calculate_Ai_collab_readiness(resume:ResumeData):
 
 
     prompt = f"""
-            You are an AI Collab Readiness Calculator. Read the following resume Data and Score based How ready are they to use AI, not just compete with it?- Based on:
-    - Mention of AI tools (ChatGPT, Copilot, etc.)
-    - Stated openness to automation
-    - How do they currently use AI tools in your work or studies?”:
+You are an AI Collaboration Readiness Calculator. Your task is to read the following resume and assess how ready the individual is to **collaborate with AI tools**, not just compete against them.
 
-            Here is the resume:
+Score the user on the following 10 readiness traits, each on a scale from 0 to 5:
 
-            (
-                {resume}
-            )
-            
-            Return Just Numbers MAX (100) MIN (0)
-            """
-    result=ai.chat(prompt=prompt,output_schema=SkillDepthResult)
+0 = Not mentioned or no evidence  
+1 = Very minimal evidence or weak relevance  
+2 = Some mention, limited depth  
+3 = Moderate use or awareness  
+4 = Strong use or understanding  
+5 = Expert use or deep integration
+
+Traits to evaluate:
+
+- Mention of AI tools (e.g., ChatGPT, GitHub Copilot, Midjourney, etc.)
+- Adaptability to AI-enhanced workflows
+- Willingness to learn and adopt AI tools
+- Understanding of AI ethics and responsible use
+- Demonstrated collaboration with AI (not just use)
+- Use of AI for problem-solving
+- Creativity in applying AI to new tasks or contexts
+- Speed in learning and applying new AI technologies
+- Communication skills related to explaining or using AI
+- Integration of AI into work/study processes
+
+
+Here is the resume:
+
+(
+{resume}
+)
+"""
+
+    result=ai.chat(prompt=prompt,output_schema=AICollabReadinessInput)
     return result
 
 
@@ -123,25 +201,42 @@ def calculate_Ai_collab_readiness(resume:ResumeData):
 
 
 
-def generate_domain_breakdown(resume:ResumeData):
+def generate_domain_breakdown(resume:ResumeData,**helpful_key_data):
 
 
     prompt = f"""
-            You currently have only one important task and that is to generate_domain_breakdown. Read the following resume Data and Classify skills/domains using taxonomy (e.g., "Software Development", "Marketing", "Data Science"):
-    - **Breakdown by Domain EXAMPLE**:
-    - Technical: 65
-    - Creative: 80
-    - Strategy: 75
-    - Collaboration: 60:
-
-            Here is the resume:
-
-            (
-                {resume}
-            )
-            
-            Return Proper values Numbers MAX (100) MIN (0)
-            """
+You have one clear objective: analyze the following resume and produce a domain skills breakdown based on the taxonomy below.
+
+**Task:**  
+Classify and score the candidate’s skills/domains on a scale from 0 to 100, where 0 means no proficiency and 100 means expert-level proficiency.
+
+**Example output format:**  
+- Technical: 65  
+- Creative: 80  
+- Strategy: 75  
+- Collaboration: 60
+
+**Domains to consider (but not limited to):**  
+- Technical (e.g., software development, programming)  
+- Creative (e.g., design, content creation)  
+- Strategy (e.g., planning, business analysis)  
+- Collaboration (e.g., teamwork, communication)  
+
+**Requirements:**  
+- Return only the domain names and their scores as shown in the example.  
+- Scores must be integers between 0 and 100.  
+- Provide 4–6 domain categories relevant to the resume content.  
+- Use your best judgment based on the resume to assign scores reflecting demonstrated skills and experience.
+
+Here is the resume to analyze:
+
+({resume})
+
+
+**Analysis data to aid  evaluation**:
+**{helpful_key_data}**
+"""
+
     result=ai.chat(prompt=prompt,output_schema=BreakDownByDomainUpdate)
     return result
 
@@ -149,26 +244,35 @@ def generate_domain_breakdown(resume:ResumeData):
 
 
 
-def generate_flagged_risk_areas(resume:ResumeData):
+def generate_flagged_risk_areas(resume:ResumeData,**helpful_key_data):
 
 
     prompt = f"""
-You are a Resume Evaluation AI. Your task is to analyze the provided resume and identify potential risk areas based on the content. Focus on:
 
-1. Missing recent certifications
-2. Lack of AI tool usage
-3. Overreliance on automatable tasks (e.g., data entry, spreadsheets)
+**You are an AI Resume Risk Evaluator.**
+Your job is to review the following resume and flag potential *career resilience risks*. Focus strictly on:
 
-For each risk area, return:
-- A clear explanation (1–2 sentences MAX)
+1. **Missing recent/up-to-date certifications**
+2. **Lack of AI or automation tool usage**
+3. **Dependence on easily automatable tasks** (e.g., repetitive data entry, basic spreadsheets)
 
-**Example Output Format**:
-- "risk_areas: Your spreadsheet skills are highly automatable."
-- "risk_areas: Your portfolio lacks AI-integrated work." 
+For each issue identified, return **a concise 1–2 sentence explanation** with clear language.
 
-Here is the resume to evaluate:
+**Response Format (Examples)**:
+
+* "Heavy reliance on spreadsheet tasks, which are easily automated."
+* "No evidence of recent certifications to stay current in the field."
+* "Resume lacks any mention of AI or automation tools."
+
+**Resume to evaluate**:
+
+```
+({resume})  
+```
+
+**Analysis data to aid  evaluation**:
+**{helpful_key_data}**
 
-({resume})
 """
     result=ai.chat(prompt=prompt,output_schema=FlaggedRiskAreasUpdate)
     return result
@@ -176,32 +280,34 @@ Here is the resume to evaluate:
 
 
 
-def generate_boost_suggestion(resume:ResumeData):
+def generate_boost_suggestion(resume:ResumeData,**helpful_key_data):
 
 
     prompt = f"""
-You are a Resume Enhancement AI. Based on the resume provided below, generate clear, AI-assisted improvement suggestions to help the user strengthen weak areas.
+You are a Resume Enhancement AI. Analyze the resume below and generate 2 to 4 clear, actionable suggestions to help the user strengthen their profile by addressing skill or experience gaps.
 
-Focus on identifying skill or experience gaps and suggest practical next steps, such as:
-- Learning relevant AI tools
-- Enrolling in advanced courses
-- Expanding project depth
-- Gaining certifications
+Focus on practical, AI-driven improvements such as:
+- Mastering relevant AI tools
+- Enrolling in advanced or specialized courses
+- Expanding the complexity or impact of projects
+- Obtaining up-to-date certifications
 
-**Examples of Suggestions**:
-- "Consider learning ChatGPT to enhance your coding workflow."
-- "Deepen your skill in Python with an advanced online course."
-- "Add recent certifications to show ongoing learning."
-- "Incorporate AI tools into your portfolio projects."
+**Examples**:
+- "Learn ChatGPT to boost your coding efficiency."
+- "Enhance your Python skills through an advanced course."
+- "Add recent certifications to demonstrate continuous growth."
+- "Integrate AI tools into your project portfolio."
 
-**Rules**:
-- Be specific and relevant to the resume.
-- Each suggestion should be 1–2 sentences.
-- Return 2–4 actionable suggestions.
+**Guidelines**:
+- Suggestions must be specific, relevant, and directly tied to the resume content.
+- Keep each suggestion concise (1–2 sentences).
+- Avoid generic advice; prioritize actionable, targeted improvements.
 
-Here is the resume to analyze:
+Resume to analyze:
 
 ({resume})
+**Analysis data to aid  evaluation**:
+**{helpful_key_data}**
 """
 
     result=ai.chat(prompt=prompt,output_schema=BoostSuggestionsUpdate)

Ars/controllers.py

@@ -2,17 +2,18 @@ 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 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)
-    boost_suggestion = generate_boost_suggestion(resume=resume)
-    domain_breakdown = generate_domain_breakdown(resume=resume)
-    print("flagged_risk",flagged_risk)
-    print("boost_suggestion",boost_suggestion)
-    print("domain_breakdown",domain_breakdown)
-    return {"overall score": ResilienceScore,"flagged Risk": flagged_risk,"boost suggestion":boost_suggestion,"domain breakdown":domain_breakdown,"resume":resume}
+    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)
+
+    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/objects.py

@@ -104,7 +104,7 @@ class FlaggedRiskAreasCreate(BaseModel):
     
 class FlaggedRiskAreasUpdate(BaseModel):
 
-    risk_areas:List[str]
+    risk_areas:Optional[List[str]]=None
     
     
 class BoostSuggestionsCreate(BaseModel):
@@ -171,19 +171,179 @@ class RealWorldQuestion(BaseModel):
 
     
     
-class AutomationRiskResult(BaseModel):
-    result: int = Field(...,description="The result of an automation risk estimation done using realword data and resume data of a user")
-    
-    
 
-class SkillDepthResult(BaseModel):
-    result: int = Field(...,description="Score based on number of years per skill, seniority of roles, certification presence")
-    
-    
-class AICollabReadiness(BaseModel):
-    result: int = Field(...,description="Score based on How ready are they to use AI, not just compete with it?")
+class AutomationRiskInput(BaseModel):
+    # Resume background fields
+    job_title: str = Field(..., description="Most recent job title")
+    industry: str = Field(..., description="Industry sector (e.g., finance, education, manufacturing)")
+    years_experience: int = Field(..., ge=0, description="Years of professional experience")
+    education_level: str = Field(..., description="Highest education level (e.g., Bachelors, Masters, PhD)")
+
+    technical_skills: List[str] = Field(default_factory=list, description="List of technical skills")
+    soft_skills: List[str] = Field(default_factory=list, description="List of soft skills")
+    managerial_experience: bool = Field(..., description="Has managed teams or projects")
+    customer_facing_roles: bool = Field(..., description="Has held customer-facing roles")
+    domain_specialization: Optional[str] = Field(None, description="Specialized domain (e.g., legal, medical)")
+    recent_certifications: List[str] = Field(default_factory=list, description="Certifications obtained recently")
+
+    # Scored traits (all int 0-5)
+    repetitiveness_score: int = Field(..., ge=0, le=5, description="Repetitiveness of the tasks performed")
+    creativity_score: int = Field(..., ge=0, le=5, description="Creativity required in the role")
+    emotional_intelligence_score: int = Field(..., ge=0, le=5, description="Importance of emotional intelligence")
+    data_driven_tasks_score: int = Field(..., ge=0, le=5, description="Dependence on data-driven tasks")
+    physical_task_score: int = Field(..., ge=0, le=5, description="Amount of physical/manual work")
+    decision_making_level: int = Field(..., ge=0, le=5, description="Level of autonomous decision-making")
+    strategic_thinking_score: int = Field(..., ge=0, le=5, description="Need for strategic thinking")
+    collaboration_score: int = Field(..., ge=0, le=5, description="Collaboration required in the role")
+    ai_dependency_score: int = Field(..., ge=0, le=5, description="How much AI tools are already used")
+    upskilling_index: int = Field(..., ge=0, le=5, description="Recent evidence of upskilling/adaptability")
+
+
+class AutomationRiskResult(AutomationRiskInput):
+    result: Optional[int] =0
+    @model_validator(mode='after')
+    def calculate_result(self,cls) -> int:
+        """
+        Calculate the overall automation risk score (0-100)
+        based on the scored traits.
+        """
+
+        # Weights for each scored trait (example weights; you can tune these)
+        weights = {
+            "repetitiveness_score": 15,
+            "creativity_score": -10,
+            "emotional_intelligence_score": -10,
+            "data_driven_tasks_score": 10,
+            "physical_task_score": 10,
+            "decision_making_level": -10,
+            "strategic_thinking_score": -10,
+            "collaboration_score": -5,
+            "ai_dependency_score": 5,
+            "upskilling_index": -5,
+        }
+
+        # Sum weighted scores
+        score = 0
+        for field, weight in weights.items():
+            value = getattr(self, field)
+            score += value * weight
+
+        # Normalize score to 0-100 range
+        # Minimum possible score
+        min_score = sum(0 * w for w in weights.values())
+        # Maximum possible score
+        max_score = sum(5 * w if w > 0 else 0 for w in weights.values()) + \
+                    sum(0 * w if w < 0 else 0 for w in weights.values())
+
+        # Because some weights are negative, min/max can be tricky.
+        # Let's compute min and max more precisely:
+
+        min_score = sum(0 * w if w > 0 else 5 * w for w in weights.values())
+        max_score = sum(5 * w if w > 0 else 0 * w for w in weights.values())
+
+        # Clamp the score between min and max
+        score = max(min_score, min(max_score, score))
+
+        # Map score linearly to 0-100
+        normalized_score = int((score - min_score) / (max_score - min_score) * 100)
+
+        self.result = normalized_score
+        return self
+
     
+
+
+
+class SkillDepthInput(BaseModel):
+    # Core scoring fields (all 0-5 integers)
+    years_experience_per_skill: int = Field(..., ge=0, le=5, description="Depth of years experience per skill")
+    seniority_level: int = Field(..., ge=0, le=5, description="Seniority level in roles held")
+    certification_presence: int = Field(..., ge=0, le=5, description="Number and relevance of certifications")
+    breadth_of_skills: int = Field(..., ge=0, le=5, description="Variety and diversity of skills")
+    technical_skill_depth: int = Field(..., ge=0, le=5, description="Depth in core technical skills")
+    leadership_skill_depth: int = Field(..., ge=0, le=5, description="Depth in leadership or management skills")
+    complex_projects_involvement: int = Field(..., ge=0, le=5, description="Involvement in complex projects")
+    strategic_initiatives_contribution: int = Field(..., ge=0, le=5, description="Contributions to strategic initiatives")
+    recent_skill_usage_frequency: int = Field(..., ge=0, le=5, description="Frequency of skill usage in recent roles")
+    continuous_learning_evidence: int = Field(..., ge=0, le=5, description="Evidence of continuous learning or upskilling")
+    cross_functional_collaboration: int = Field(..., ge=0, le=5, description="Cross-functional collaboration skills")
+    recognition_awards: int = Field(..., ge=0, le=5, description="Recognition or awards related to skills")
+    public_speaking_training: int = Field(..., ge=0, le=5, description="Public speaking or training experience")
+    publications_patents: int = Field(..., ge=0, le=5, description="Publications or patents (if any)")
+    industry_expertise_depth: int = Field(..., ge=0, le=5, description="Industry-specific expertise depth")
+    mentoring_coaching_experience: int = Field(..., ge=0, le=5, description="Mentoring or coaching experience")
+    innovation_ability: int = Field(..., ge=0, le=5, description="Ability to innovate using skills")
+    adaptability_to_technologies: int = Field(..., ge=0, le=5, description="Adaptability to new technologies")
+    problem_solving_depth: int = Field(..., ge=0, le=5, description="Problem-solving skills depth")
+    technical_communication_skills: int = Field(..., ge=0, le=5, description="Communication skills related to technical content")
+
+
+class SkillDepthResult(SkillDepthInput):
+    result: Optional[int] =0
+    @model_validator(mode='after')
+    def calculate_result(self) -> None:
+        fields = [
+            self.years_experience_per_skill,
+            self.seniority_level,
+            self.certification_presence,
+            self.breadth_of_skills,
+            self.technical_skill_depth,
+            self.leadership_skill_depth,
+            self.complex_projects_involvement,
+            self.strategic_initiatives_contribution,
+            self.recent_skill_usage_frequency,
+            self.continuous_learning_evidence,
+            self.cross_functional_collaboration,
+            self.recognition_awards,
+            self.public_speaking_training,
+            self.publications_patents,
+            self.industry_expertise_depth,
+            self.mentoring_coaching_experience,
+            self.innovation_ability,
+            self.adaptability_to_technologies,
+            self.problem_solving_depth,
+            self.technical_communication_skills,
+        ]
+
+        max_total = 5 * len(fields)
+        total_score = sum(fields)
+        self.result = int((total_score / max_total) * 100)
+        return self
+
     
+class AICollabReadinessInput(BaseModel):
+    ai_tool_familiarity: int = Field(..., ge=0, le=5, description="Familiarity with AI tools and platforms")
+    adaptability_to_ai_workflows: int = Field(..., ge=0, le=5, description="Ability to adapt to AI-enhanced workflows")
+    willingness_to_learn_ai_skills: int = Field(..., ge=0, le=5, description="Motivation and willingness to learn AI skills")
+    ai_ethics_understanding: int = Field(..., ge=0, le=5, description="Understanding of AI ethics and responsible use")
+    collaboration_with_ai: int = Field(..., ge=0, le=5, description="Experience or mindset to collaborate effectively with AI systems")
+    problem_solving_with_ai: int = Field(..., ge=0, le=5, description="Skill in using AI to solve complex problems")
+    creativity_in_ai_use: int = Field(..., ge=0, le=5, description="Creativity in leveraging AI capabilities")
+    ai_learning_speed: int = Field(..., ge=0, le=5, description="Speed of learning new AI technologies")
+    communication_about_ai: int = Field(..., ge=0, le=5, description="Ability to communicate AI concepts effectively")
+    ai_tool_integration: int = Field(..., ge=0, le=5, description="Skill in integrating AI tools into existing workflows")
+
+class AICollabReadiness(AICollabReadinessInput):
+    result: Optional[int] =0
+    @model_validator(mode='after')
+    def calculate_result(self) -> None:
+        fields = [
+            self.ai_tool_familiarity,
+            self.adaptability_to_ai_workflows,
+            self.willingness_to_learn_ai_skills,
+            self.ai_ethics_understanding,
+            self.collaboration_with_ai,
+            self.problem_solving_with_ai,
+            self.creativity_in_ai_use,
+            self.ai_learning_speed,
+            self.communication_about_ai,
+            self.ai_tool_integration,
+        ]
+        max_total = 5 * len(fields)
+        total_score = sum(fields)
+        self.result = int((total_score / max_total) * 100)
+        return self
+
     
     
     

app.py

@@ -2,11 +2,13 @@ from controller.imports import *
 
 import logging
 from datetime import datetime
+from Ars.routes import ARS
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 app.mount('/gamification',gamification)
+app.mount('/Ars',ARS)