Added ARS (#1)

- initial commit (66ceaab066d0ebf7b2b7016d40d54d1fe19afd65)
- Create requirements.txt (de33359dd9db20b1a5220f54f94499db83ee4400)
- Create app.py (a459994d80cab3676a0784225f33ce8ee807bf46)
- Create Dockerfile (0b94fdd7d4a103dd8f14ab99a1fd27d8570fa952)
- Create utils.py (e3884a1638689f48e57cff92937e1b2117418535)
- Update requirements.txt (c36320979d66a8b4c08d365746223f2010283b33)
- Update requirements.txt (6d9386f3f4618dcfd06337740ca3674f0e670912)
- Update app.py (fe28cb295fdf32c2d5cb32546d9bb2617806684e)
- Update app.py (c12efb0fc478f222e913bc60e015082df6e2ec70)
- connected stuff (1bb6f096a2f7b8f9b6c8b2ca3be91d658a866dac)
- changed .env (1f1ff083964e7ba2bfe7905f486bada5ed3bf1aa)
- removed pycache (66a875b92f3de7e31494703e26ef1ed0e888bc36)
- app.py updated (3e286b70c8540b34d56c4e86694f8c5b09cb21f9)
- deleted file (ca1717f8945c27fe4a6604428a90c8b044506274)
- added stuff (1a41961c0f49ccef85fe3f9ac550b856268b05d6)
- updated.py (2026af211aa1e2f8faf804a209845aabcd242027)
- added some stuff (1abc2753eb6b31cd4ab9a56dd63b652d43d5ef65)
- added some stuff (c4073a5a04aa9ec7ecdee64aa6b9225de6724245)
- added some stuff (4cd1ffd1352bcacbe91347d1b8444790edcac164)
- added more stuff (6ba5f500be5004e03820dfd7a04f3d805e847237)
- added jwt auth (26a8b59f87b0e656d4768bfaeb067f857689f7c2)
- added streaks feature (756ed25f5c7a8853c5a610da3e3a2ff827dcfc71)
- changed db up a bit (54b7518c7cfdc7128521023acaf38bf3d3911b79)
- very scripted (8382c943e322dfd4eac3dc652ab03bfcb813d8ff)
- added logout (ba7b47505c09469c56dfb64e0d87c7385a56c1b0)
- changed up something for jwt (0dceb1e95c0489889149296967eaa7a435f869fe)
- changed up something for jwt (936d31ee6555b0af6d2ab2868285cb6c3ff2a06f)
- added logout (d8149f4a80cc9b8aff86ec3d49133e30b47706f4)
- added http 226 error (ec44a32881eb42ee4cf2aedd2d8b82b6ef5466ff)
- added user details (5818dbbacf34d5bedef6cfa1e0dae49b4e06c7af)
- hopefully doesn't crash (f9ab8e5b1bbd0bf9234c7049c7c66bbe9405aaed)
- added dream role and fixed interem role bug (e692eccad884bff8c45c27806b01d14b7480e23b)
- added questionaire to the user details (2128dedf2eb30e4f265b834ed2ae6bcf73277ab9)
- added dream role and fixed interem role bug (c43a9826b7d30564d6612d5cbb5207347ef01b26)
- added dream role and fixed interem role bug (c4c7ccc42d7654a99dd41271465b536f76afadfb)
- fixed questionaire retrieval (5142863f09b619e922aec68ed749521636f80b14)
- fixed updating questionaire (83338db95cab796fe5dc0c58ec1ae4a84dd1a3f1)
- completed this shit (80d2e7b7d4d7c6bc8dfb744f4ae367cbdfe7a0cc)
- login stuff (995533c4da23fefc7bcedac8c447150f9d2002dd)
- HOP (d46a40ec686260dab05748b2228820ca78922c17)
- added provider (398210d72dc645f110c51e4ff99ed310541b3f69)
- changed 0 to 1 (cf203377de703160ff234ab241686d303761b45a)
- added a new data type (73371fd5625a8d6be23cb8bfb6ebd1e2b207e90f)
- made the object less strict (0c276d34853fc789bd61ae121431ae3462429032)
- added userCourse stuff (441685320d5827ac57061ad01f4d769beaa2fbf6)
- fixed verification for refresh token (06533adec92074da1fd5b4e6e1aa3f4dc18377a9)
- added course link (ef82ce661b2485092253cf818107b9871ed31046)
- updated util.py (1060ca882e8dbe7c691ea70893dfdd088b69ae1e)
- fixed streaks issue (8f2e112bdf80fdfd3ecf5cbc30239d48c93c31ab)
- added a new streaks feature (c38f2344cb9151733e8d9dc815f5d9afd9cc9340)
- removed testes.py (5d4fab2eb76ab5e8b86eb63885668ca19ef9823a)
- added some routes (323b3570d37d797a278c36a594ab193ba45a5b16)
- put in the customer rate (32d2a84afc19d7a441f7551fc25e62a1fb3da76a)
- changed testing parameters to stable parameters (aa8143aa91809f595238076b8fdd231db10f57fd)
- added most features (f1b601bf9a32ceb99c318737d02a897617570476)
- added index (8159bdee32b01b8091e05bcbf795306dc36ef4b1)
- updated stream (90bab231aeba71101e6690719818c4579eb49ef7)
- fixed weekend warrior pointing not working (82124ef6be18af0b53420fd7489c12831ea51fb3)
- added total Point to float (ca1bfdd7969f9b6ea94614ae2cc16591e3dde8ed)
- removed int response (a76a90cd34e674c245b02c7a314001941505d39f)
- removed int response (dbebc697ab2f2a03b2fcf09ae396106037442bc1)
- made it production grade (161667a95596eb917d533337909c171af5b131b3)
- removed the returning levels (0d5781045e2e69697f43fada26336a51c9a61ae4)
- removed the returning levels (578e7e0d52ce14b9659ed51f8563440f74975c48)
- added the ability for leaderboard to be recalculated upon every new point, which may slow down performance so I will make it a background process (b8596d51f0ecefc5c14465f45272b43d0c37e4d7)
- changed some stuff I can't remember no need for background processes (1225834a1f805048df83dafcaae0eb2b14a9b7a8)
- added badge url as part of return for rankers (07ffd862cf5c61e01373f48ff4aece5532806fbf)
- added a fix to leaderboard (9bb2f7cc4c1be1c60c90fdd83c585f367a015de1)
- hot fix for leaderboard (d6b9f3da4b60f331556e71e0ba6b1c2435da0812)
- refactored codebase (9f571c04077337b986a1325b165c59a8766ef975)
- updated codebase to make it faster (9f13856d0db8ce88f0824536439fe8b9ba82b2e8)
- added .env.example (0b04c95f3b76a9231af0f1308f251005e2d3229a)
- redis addd to requirements (560381218fd289d3432b440fd72be29c8d35a414)
- cryptography added to requirements (35852be5b10b4f896180be9c62b00871002b8898)
- fixed the refresh token incorrect token error (0197cb38c358ec91a0ff325ddfa19a0f920d60f1)
- fixed byte12 error (58d4afb077be8b27f9d7f62a28613419cd67735c)
- changed name (4238535596edd98310a8e25b3e5a742cc6ebcfe8)
- updated get levels (b37e48c96dbb8a22a788b209b8d4661d5a7dcb29)
- updated get levels (2b9a22d22e0309e20d0d4daa97016e733ad6141d)
- updated get levels (9186c0c7df7fdb539f4929004031c912e5fc9ce0)
- added star url (c74fe081c2e6c12a9683afa2d6f00908ad851aa0)
- fixed error (f9371dab78067b9e9d57699df1314bdfdd17d337)
- fixed error (752266eda903a150c6970f9799d4886842cf4342)
- fixed star url not changing (d9c224e559e244df502b942e4e51f40b2e7dc1b8)
- ars (4eab69a9f03b414e40eecc6f40fb55c1bf6bb4b4)
- stage 1 for ARS (1e531e2133dd12d2ddff48ce04fd72cca732f458)
- added ars route (1aa5032c5dcce62618f8ca891f8c500385563076)
- fixed merge conflict (103cfcd37fd3266b1396516d241c41b998383332)

Ars/ai_functions.py

@@ -0,0 +1,316 @@
+from pdfminer.high_level import extract_text_to_fp
+from io import BytesIO
+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(upload_file:UploadFile) -> ResumeData:
+    contents = await upload_file.read()
+    resume = extract_text_from_bytes(pdf_bytes=contents)
+    if resume:
+        prompt = f"""
+        You are an AI resume parser. Read the following resume and extract the following structured information from the resume below if any was found:
+
+        1. Work experience details: job titles and descriptions.(max3)
+        2. List of technical skills (technologies, tools, platforms, etc.).(max4)
+        3. Soft and transferable skills: 
+            - Leadership and collaboration
+            - Critical thinking and problem-solving
+            - Communication skills
+            - Cross-functional/interdisciplinary experience
+            - Initiative and adaptability
+        4. Career path details:
+            - Current or intended role/field
+            - Industry and sector context
+            - Career trajectory trends
+        5. Project experience (if any): project titles, descriptions, role.(max3)
+        6. Evidence of upskilling (optional): certifications, courses, learning projects, hackathons.
+
+        Return the extracted data as a JSON object that matches this schema:
+
+        Here is the resume:
+
+        {resume}
+        """
+        result =ai.chat(prompt=prompt,output_schema=ResumeData)
+        return result
+
+
+
+
+
+def calculate_automation_risk(resume:ResumeData):
+    def generate_real_world_data(resume:ResumeData):
+        prompt=f"Generata a search query using the resume details below I want to check some text that has data on future jobs reports using semantic searches  Here is the resume data: {resume} "
+        result = ai.chat(prompt=prompt,output_schema=RealWorldQuestion)
+        search_result =search_pinecone_text(query_text=result.question)
+
+        return search_result
+
+    real_world_data=generate_real_world_data(resume=resume)
+    prompt = f"""
+    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.
+
+    For each of the following factors, please evaluate on a scale from 0 to 5, where:
+
+    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
+
+
+
+def calculate_skill_depth(resume:ResumeData):
+
+
+    prompt = f"""
+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}
+)
+"""
+
+    result=ai.chat(prompt=prompt,output_schema=SkillDepthInput)
+    return result
+
+
+
+def calculate_Ai_collab_readiness(resume:ResumeData):
+
+
+    prompt = f"""
+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.
+
+Score the user on the following 10 readiness traits, each on a scale from 0 to 5:
+
+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
+
+
+
+
+
+
+def generate_domain_breakdown(resume:ResumeData,**helpful_key_data):
+
+
+    prompt = f"""
+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
+
+
+
+
+
+def generate_flagged_risk_areas(resume:ResumeData,**helpful_key_data):
+
+
+    prompt = f"""
+
+**You are an AI Resume Risk Evaluator.**
+Your job is to review the following resume and flag potential *career resilience risks*. Focus strictly on:
+
+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)
+
+For each issue identified, return **a concise 1–2 sentence explanation** with clear language.
+
+**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}**
+
+"""
+    result=ai.chat(prompt=prompt,output_schema=FlaggedRiskAreasUpdate)
+    return result
+
+
+
+
+def generate_boost_suggestion(resume:ResumeData,**helpful_key_data):
+
+
+    prompt = f"""
+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 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**:
+- "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."
+
+**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.
+
+Resume to analyze:
+
+({resume})
+**Analysis data to aid  evaluation**:
+**{helpful_key_data}**
+"""
+
+    result=ai.chat(prompt=prompt,output_schema=BoostSuggestionsUpdate)
+    return result
+
+

Ars/controllers.py

@@ -0,0 +1,19 @@
+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,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/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/embedDoc.py

@@ -0,0 +1,109 @@
+from pinecone import Pinecone
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+import os
+from dotenv import load_dotenv
+import time
+
+load_dotenv()
+def chunk_list(lst, chunk_size):
+    """Yield successive chunks of size `chunk_size` from list."""
+    for i in range(0, len(lst), chunk_size):
+        yield lst[i:i + chunk_size]
+        
+def upsert_text_with_chunks(
+    text: str,
+    *,
+    index_host: str = "https://resume-42eo81u.svc.aped-4627-b74a.pinecone.io",
+    namespace: str = "default",
+    chunk_size: int = 1000,
+    chunk_overlap: int = 200
+) -> None:
+    """
+    Splits a long text into overlapping chunks and upserts them directly into a Pinecone index
+    that has integrated embedding enabled.
+
+    Args:
+        text (str): The full text document to embed.
+        index_host (str): Pinecone index host URL.
+        namespace (str): Pinecone namespace to upsert into.
+        chunk_size (int): Max characters per chunk.
+        chunk_overlap (int): Overlap in characters between chunks.
+    """
+    api_key = os.getenv("PINECONE_API_KEY")
+    if not api_key:
+        raise EnvironmentError("Set PINECONE_API_KEY in environment")
+
+    pc = Pinecone(api_key=api_key)
+    index = pc.Index(host=index_host)
+
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        length_function=len,
+        is_separator_regex=False
+    )
+    chunks = splitter.split_text(text)
+    if not chunks:
+        print("No chunks generated — exiting.")
+        return
+
+    records = [
+        {
+            "_id": f"chunk-{i}",
+            "text": chunk
+        }
+        for i, chunk in enumerate(chunks)
+    ]
+
+    for batch in chunk_list(records, 50):
+        print("Inserting")
+        index.upsert_records(records=batch, namespace=namespace)
+        time.sleep(60)
+        print("resting")
+    print(f"✅ Upserted {len(records)} valid chunks (out of {len(chunks)}) into namespace '{namespace}'.")
+
+
+
+
+    
+from pinecone import Pinecone
+from typing import List, Dict
+
+def search_pinecone_text(
+    query_text: str,
+    index_host: str = "https://resume-42eo81u.svc.aped-4627-b74a.pinecone.io",
+    namespace: str = "default",
+    top_k: int = 2,
+    fields: List[str] = ["category", "text"]
+) -> List[Dict]:
+    """
+    Search a Pinecone index using a text query.
+
+    Args:
+        api_key (str): Your Pinecone API key.
+        index_host (str): The specific index host URL.
+        namespace (str): The namespace to search within.
+        query_text (str): The input text to search for.
+        top_k (int): Number of top results to return.
+        fields (List[str]): Metadata fields to include in the response.
+
+    Returns:
+        List[Dict]: The top matching results.
+    """
+    api_key = os.getenv("PINECONE_API_KEY")
+    pc = Pinecone(api_key=api_key)
+    index = pc.Index(host=index_host)
+
+    results = index.search(
+        namespace=namespace,
+        query={"inputs": {"text": query_text}, "top_k": top_k},
+        fields=fields
+    )
+    print()
+    hits =results.result['hits']
+    result=[]
+    for hit in hits:
+        text = hit['fields']['text']
+        score = hit['_score']
+        result.append({"text":text,"score":score})
+    return   result

Ars/objects.py

@@ -0,0 +1,415 @@
+from datetime import datetime
+from pydantic import Field, model_validator, BaseModel
+from typing import List, Optional, Union,Type, TypeVar
+from bson import ObjectId
+import openai
+from google import genai
+from google.genai import types
+import os
+from dotenv import load_dotenv
+load_dotenv()
+GOOGLE_API_KEY=os.getenv("GEMINI_API_KEY")
+OPENAI_API_KEY=os.getenv("OPENAI_API_KEY")
+T = TypeVar("T", bound=BaseModel)
+class AIWrapper:
+    def __init__(self, provider='openai'):
+        self.provider = provider.lower()
+
+        if self.provider == 'openai':
+            openai.api_key = OPENAI_API_KEY
+        elif self.provider == 'gemini':
+            self.gemini_client = genai.Client(
+    api_key=GOOGLE_API_KEY,
+    http_options=types.HttpOptions(api_version='v1alpha')
+)
+        else:
+            raise ValueError("Provider must be 'openai' or 'gemini'")
+
+    def chat(self, prompt: str,output_schema:Type[T]) -> T:
+        """
+        Generate a response from the AI provider and return it parsed into the specified schema.
+
+        Args:
+            prompt (str): The input prompt.
+            output_schema (Type[T]): A Pydantic model representing the output schema.
+
+        Returns:
+            T: Parsed AI response as an instance of the output_schema.
+        """
+        if self.provider == 'openai':
+            return self._openai_chat(prompt)
+        elif self.provider == 'gemini':
+            return self._gemini_chat(prompt,output_schema=output_schema)
+
+    def _openai_chat(self, prompt: str) -> str:
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[
+                {"role": "user", "content": prompt}
+            ]
+        )
+        return response['choices'][0]['message']['content']
+
+    def _gemini_chat(self, prompt: str, output_schema: Type[T]) -> T:
+        response = self.gemini_client.models.generate_content(
+    model='gemini-2.0-flash-001',
+    contents=prompt,
+    config=types.GenerateContentConfig(
+        response_mime_type='application/json',
+        response_schema=output_schema,
+    ),
+)
+
+        return response.parsed
+    
+    
+ai = AIWrapper(provider='gemini')
+
+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:Optional[List[str]]=None
+    
+    
+class BoostSuggestionsCreate(BaseModel):
+
+    boost_suggestions:List[str]
+   
+   
+
+class ProjectExperienceDetails(BaseModel):
+    ProjectTitles: str = Field(..., description="The title(s) of the project(s) involved in.")
+    descriptions: str = Field(..., description="Detailed description of the project and what it entailed.")
+    RoleInTheProject: str = Field(..., description="The specific role played within the project.")
+
+class WorkExperienceDetails(BaseModel):
+    JobTitles: str = Field(..., description="The job titles held in past employment.")
+    JobDescriptions: str = Field(..., description="Summary of responsibilities and duties in these jobs.")
+
+class SoftTransferableSkills(BaseModel):
+    LeadershipAndCollaborationIndicators: str = Field(..., description="Evidence or examples demonstrating leadership and teamwork.")
+    CriticalThinkingOrProblemSolvingVerb: str = Field(..., description="Examples of critical thinking or problem solving performed.")
+    CommunicationSkills: str = Field(None, description="Description of communication skills and contexts.")
+    CrossFunctionalOrInterdisciplinaryExperience: str = Field(..., description="Experience working across teams or disciplines.")
+    InitiativeAndAdaptabilityLanguage: str = Field(..., description="Examples of taking initiative and adapting to change.")
+
+class CareerPathInformation(BaseModel):
+    CurrentOrIntendedRoleOrField: str = Field(..., description="Current or intended professional role or field of work.")
+    IndustryAndSectorContext: str = Field(..., description="Context about the industry and sector related to the career path.")
+    CareerTrajectoryTrends: str = Field(..., description="Observed or expected trends in the career trajectory or sector.")
+
+class EvidenceOfUpskillingAndLifelongLearning(BaseModel):
+    CertificationsCoursesOrBootcampsListed: Optional[List[str]] = Field(None, description="List of certifications, courses, or bootcamps completed.")
+    SelfInitiatedLearningProjectsOrNonDegreeEducationalAchievements: Optional[List[str]] = Field(None, description="List of personal projects or non-degree achievements.")
+    ParticipationInHackathonsClubsOrProfessionalCommunities: Optional[List[str]] = Field(None, description="Involvement in hackathons, clubs, or professional groups.")
+
+class AIRelatedKeywords(BaseModel):
+    AiToolsAndTechnologies: Optional[List[str]] = Field(
+        None,
+        description="List of AI tools and technologies mentioned in the resume, e.g., ChatGPT, TensorFlow."
+    )
+    conceptsAndTechniques: Optional[List[str]] = Field(
+        None,
+        description="AI concepts or techniques like NLP, computer vision, or reinforcement learning."
+    )
+    aiIntegratedProjectsMentioned: Optional[List[str]] = Field(
+        None,
+        description="Names or descriptions of projects where AI was applied."
+    )
+    usageContextDescriptions: Optional[List[str]] = Field(
+        None,
+        description="Sentences or phrases describing how AI was used in projects or tasks."
+    )
+
+class ResumeData(BaseModel):
+    workExperienceDetails:Optional[List[WorkExperienceDetails]]=None
+    listOfExplicitTechnicalSkills:Optional[List[str]]=None
+    softTransferableSkills:List[SoftTransferableSkills]
+    projectExperienceDetails:Optional[List[ProjectExperienceDetails]]=None
+    careerPathInformation:CareerPathInformation
+    evidenceOfUpskillingAndLifelongLearning:Optional[EvidenceOfUpskillingAndLifelongLearning]=None
+    aiRelatedKeywords:AIRelatedKeywords
+
+class RealWorldQuestion(BaseModel):
+    question:str
+
+    
+    
+
+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
+
+    
+    
+    
+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 core import db
+from bson import ObjectId
+from fastapi import HTTPException
+from typing import Optional, List
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from 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"}

Ars/routes.py

@@ -0,0 +1,15 @@
+import base64
+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(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)
+    return ResilienceScore
+
+
+    

README.md

@@ -8,3 +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

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)
 
 
 

gamification/pointLogic.py

@@ -93,6 +93,7 @@ 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:
@@ -101,6 +102,17 @@ def get_all_simple_points_func(userId) -> SimpleIndividualUserLevel:
         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:
+        points_list = list(point_cursor)
+        
+        totalPoints = sum([point['numOfPoints'] for point in points_list])
+        
+        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

@@ -2,6 +2,10 @@ fastapi[all]
 requests
 python-dotenv
 pymupdf
+<<<<<<< HEAD
+=======
+motor
+>>>>>>> master
 pinecone
 sentence-transformers
 einops