@feat : storage for resume repo created.

.gitignore

@@ -0,0 +1,8 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+venv/
+env/

app/api/routes.py

@@ -4,6 +4,14 @@ from app.services.generator import generate_cover_letter
 from app.services.pdf_creator import save_pdf
 from app.services.resume_parser import extract_text_from_resume
 from app.utils.file_utils import generate_unique_filename
+from fastapi import FastAPI, UploadFile, File
+from app.services.hf_storage_service import HuggingFaceStorageService
+import os
+
+
+HF_REPO_ID = "zarsyeda/resume-parser-storage"  # Your repo ID
+HF_TOKEN = os.getenv("HF_TOKEN")
+storage_service = HuggingFaceStorageService(HF_REPO_ID, HF_TOKEN)
 
 router = APIRouter()
 
@@ -22,3 +30,27 @@ async def generate_cover_letter_api(data: GenerateRequest):
         )
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/upload-resume")
+async def upload_resume(resume: UploadFile = File(...)):
+    try:
+        # Read resume content
+        resume_content = await resume.read()
+        
+        # Upload to HuggingFace Hub
+        resume_url = storage_service.upload_resume(
+            file_content=resume_content,
+            filename=resume.filename
+        )
+        
+        return {
+            "success": True,
+            "url": resume_url
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }

app/services/generator.py

@@ -3,6 +3,8 @@ import torch
 from app.models.schema import GenerateRequest
 import os
 from fastapi import FastAPI, HTTPException
+import os
+from datetime import datetime
 
 
 os.environ["TRANSFORMERS_CACHE"] = "/code/backend/transformers_cache"
@@ -26,68 +28,40 @@ model = model.to(device)
 
 
 def generate_cover_letter(data: GenerateRequest, resume_text: str) -> str:
+# Updated prompt to explicitly request markdown format
     prompt = f"""
-AI Cover Letter Writer Bot Prompt
-
-You are an expert cover letter writer that creates personalized, human-written cover letters based on job descriptions and CV information. Your goal is to craft authentic letters that sound like they're written by a Pakistani professional with 6.5 IELTS band score - natural, clear, but not overly sophisticated or AI-generated.
-
-Input Requirements
-
-- **Job Details:** Complete job posting with requirements, responsibilities, and company information
-Job Details: {data.job_details}
-
-- **CV/Resume:** Tailored resume specifically prepared for the target role
-Resume Text: {resume_text}
-
-Output Format Required:
-Dear [Hiring Team or Company Name extracted from Job Details if present in job details],
-
-[Paragraph 1: Position + why interested in company]
-[Paragraph 2: Relevant experience + skills matching job requirements]  
-[Paragraph 3: Value you bring + enthusiasm to join]
-
-Best regards,
-- Name of user extract from resume
-
-**Do not include the following data from resume:**
-
-- Header with personal contact information
-- Date
-- Subject line
-- Closing signature
-- Any formatting beyond the basic greeting and paragraphs
-
-Rules:
-- 3 paragraphs only (50-80 words each)
-- Total: 200-300 words
-- Sound natural, not AI-written
-- Match resume skills to job requirements
-- Mention specific technologies/companies from inputs
-- Use simple language, avoid: robust, leverage, utilize, optimal, innovative
-
-**Missing Skills? Say: "I am eager to learn [skill] and have quickly mastered [example] before"
-**Less Experience? Focus on quality: "My experience with [skill] includes [specific achievement]"
-
-Before finalizing, ensure the cover letter:
-
-- [ ] Addresses the specific role and company by name
-- [ ] Highlights 2-3 most relevant experiences from the CV
-- [ ] Addresses any obvious skill gaps with learning commitment
-- [ ] Uses natural, varied language (avoiding the banned word list)
-- [ ] Uses simple, clear language that sounds human-written (not AI-generated)
-- [ ] Avoids overly sophisticated vocabulary or complex sentence structures
-- [ ] Includes a clear call to action
-- [ ] Stays within 3-4 paragraph limit
-
-Remember: Your goal is to write a cover letter that sounds like it was written by a real person with good English skills, not by AI. Keep it natural, straightforward, and genuine.
-"""
+    Please generate a professional cover letter in **markdown format** based on the following information:
+
+    **Job Details:**
+    {data.job_details}
+
+    **Resume Content:**
+    {resume_text}
+
+
+    **Important:** 
+    - Format the output as proper markdown
+    - Use appropriate headers (# ## ###)
+    - Use **bold** for emphasis where appropriate
+    - Use bullet points or numbered lists where relevant
+    - Include proper spacing and line breaks
+    - Start with the applicant's contact information as a header
+    - Include date and employer information
+    - Structure it as a professional business letter in markdown format
+
+    Please ensure the cover letter is:
+    1. Tailored specifically to the job requirements
+    2. Highlights relevant experience from the resume
+    3. Professional and engaging tone
+    4. Proper markdown formatting throughout
+    """
+    
     try:
         
         messages = [
-    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful AI covert letter bot."},
-    {"role": "user", "content": prompt}
-]
-
+        {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful AI cover letter bot that generates professional cover letters in markdown format. Always respond with properly formatted markdown."},
+        {"role": "user", "content": prompt}
+        ]
         # Apply chat template
         text = tokenizer.apply_chat_template(
             messages,
@@ -104,16 +78,17 @@ Remember: Your goal is to write a cover letter that sounds like it was written b
             max_length=2048
         ).to(model.device)
 
-        # Generate with better parameters
+            # Generate with parameters optimized for markdown
         generated_ids = model.generate(
             **model_inputs,
-            max_new_tokens=512,
-            do_sample=True,           # sampling enabled for more natural output
-            temperature=0.7,          # control creativity
-            top_p=0.9,                # nucleus sampling
-            top_k=50,                 # top-k sampling
-            repetition_penalty=1.1,   # reduce repetition
-            eos_token_id=tokenizer.eos_token_id
+            max_new_tokens=800,           # Increased for longer markdown content
+            do_sample=True,
+            temperature=0.6,              # Slightly lower for more consistent formatting
+            top_p=0.9,
+            top_k=50,
+            repetition_penalty=1.15,      # Higher to avoid repetitive formatting
+            eos_token_id=tokenizer.eos_token_id,
+            pad_token_id=tokenizer.pad_token_id
         )
         
         generated_only_ids = generated_ids[:, model_inputs.input_ids.shape[1]:]
@@ -125,7 +100,7 @@ Remember: Your goal is to write a cover letter that sounds like it was written b
             skip_special_tokens=True
         )
 
-        return response
+        return response.strip()
 
 
 

app/services/hf_storage_service.py

@@ -0,0 +1,86 @@
+from huggingface_hub import HfApi, upload_file
+import os
+import uuid
+from datetime import datetime
+import tempfile
+
+class HuggingFaceStorageService:
+    def __init__(self, repo_id: str, token: str):
+        """
+        Initialize HuggingFace storage service
+        
+        Args:
+            repo_id: Your HuggingFace repository ID (e.g., "username/cover-letter-storage")
+            token: Your HuggingFace access token
+        """
+        self.repo_id = repo_id
+        self.token = token
+        self.api = HfApi()
+        
+        # Repository should already exist
+    
+    def upload_resume(self, file_content, filename: str = None) -> str:
+        """
+        Upload resume to HuggingFace Hub
+        
+        Args:
+            file_content: File content (bytes)
+            filename: Original filename (optional)
+        
+        Returns:
+            str: Public URL to the uploaded file
+        """
+        if filename is None:
+            filename = f"resume_{uuid.uuid4().hex}.txt"
+        
+        # Create a unique path with timestamp
+        timestamp = datetime.now().strftime("%Y/%m/%d")
+        file_path = f"resumes/{timestamp}/{filename}"
+        
+        # Save bytes to temporary file for upload
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.txt') as temp_file:
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Upload to HuggingFace Hub
+            upload_file(
+                path_or_fileobj=temp_file_path,
+                path_in_repo=file_path,
+                repo_id=self.repo_id,
+                token=self.token,
+                repo_type="dataset"
+            )
+            
+            # Return the public URL
+            return f"https://huggingface.co/datasets/{self.repo_id}/resolve/main/{file_path}"
+        
+        except Exception as e:
+            raise Exception(f"Failed to upload resume: {str(e)}")
+        finally:
+            # Clean up temporary file
+            os.unlink(temp_file_path)
+    
+    # Removed cover letter upload method since we only store resumes
+    
+    def delete_file(self, file_path: str) -> bool:
+        """
+        Delete a file from HuggingFace Hub
+        
+        Args:
+            file_path: Path to file in the repository
+        
+        Returns:
+            bool: Success status
+        """
+        try:
+            self.api.delete_file(
+                path_in_repo=file_path,
+                repo_id=self.repo_id,
+                token=self.token,
+                repo_type="dataset"
+            )
+            return True
+        except Exception as e:
+            print(f"Failed to delete file: {str(e)}")
+            return False

requirements.txt

@@ -5,4 +5,7 @@ torch
 fpdf
 pdfplumber
 accelerate
-safetensors
+safetensors
+python-multipart
+huggingface_hub
+python-dotenv