Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+bfg-1.15.0.jar filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.env\nCareerCrafter/.env

CareerCrafter1.0.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

Dockerfile

@@ -0,0 +1,20 @@
+# Use the official Python image as the base image
+FROM python:3.12-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt ./
+
+# Install the dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 5000
+
+# Command to run the application
+CMD ["python", "app.py"]

Procfile.txt

@@ -0,0 +1 @@
+web: gunicorn app:app --bind 0.0.0.0:$PORT

README.md

@@ -1,10 +1,3 @@
----
-title: Cc
-emoji: 🦀
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CareerCraft
+
+CareerCraft is a comprehensive job management platform designed to streamline the job application process and enhance career growth. With features like resume uploads, job tracking, and preparation tools, CareerCraft empowers users to craft their career paths effectively.

app.py

@@ -0,0 +1,387 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, Response
+from flask_sqlalchemy import SQLAlchemy
+import os
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy import or_
+import pandas as pd
+import openai, sys  # Import OpenAI library
+from dotenv import load_dotenv
+from flask_migrate import Migrate
+from openai import OpenAI
+from datetime import datetime, timedelta
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Set your OpenAI API key from the .env file
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Configure logging with rotating file handler
+handler = RotatingFileHandler('app.log', maxBytes=10000000, backupCount=5)
+handler.setFormatter(logging.Formatter(
+    '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
+))
+logging.basicConfig(
+    level=logging.DEBUG,
+    handlers=[handler]
+)
+
+# Add logger to Flask app
+app = Flask("Career Crafter")
+app.logger.addHandler(handler)
+
+app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///jobs.db'
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+app.secret_key = 'your_secret_key_here'
+
+db = SQLAlchemy(app)
+
+# Initialize Flask-Migrate
+migrate = Migrate(app, db)
+
+class Job(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    company = db.Column(db.String(100), nullable=False)
+    position = db.Column(db.String(200), nullable=False)
+    resume_used = db.Column(db.String(200))
+    date_applied = db.Column(db.String(20))
+    status = db.Column(db.String(50))
+    interview_details = db.Column(db.Text)
+    comments = db.Column(db.Text)
+    link = db.Column(db.String(300))
+    job_description = db.Column(db.Text)  # New field for job description
+
+    def __repr__(self):
+        return f"<Job {self.company} - {self.position}>"
+
+# Add logging to track application flow
+logging.info("Starting Flask application")
+
+def convert_excel_serial_dates():
+    """Convert any numeric Excel date serials in date_applied to ISO date strings."""
+    updated = False
+    for job in Job.query.all():
+        da = job.date_applied
+        if da and isinstance(da, (str,)) and da.isdigit():
+            try:
+                serial = int(da)
+                dt = datetime(1899, 12, 30) + timedelta(days=serial)
+                job.date_applied = dt.strftime('%Y-%m-%d')
+                updated = True
+            except ValueError:
+                continue
+    if updated:
+        db.session.commit()
+        app.logger.info('Converted Excel serial dates to ISO strings in database')
+
+@app.route('/')
+def index():
+    return redirect('/jobs')
+
+@app.route('/jobs', methods=['GET', 'POST'])
+def jobs():
+    try:
+        if request.method == 'POST':
+            app.logger.info("Received POST request to add a new job", extra={
+                'company': request.form['company'],
+                'position': request.form['position']
+            })
+            new_job = Job(
+                company=request.form['company'],
+                position=request.form['position'],
+                resume_used=request.form.get('resume_used'),
+                date_applied=request.form.get('date_applied'),
+                status=request.form.get('status'),
+                interview_details=request.form.get('interview_details'),
+                comments=request.form.get('comments'),
+                link=request.form.get('link')
+            )
+            db.session.add(new_job)
+            db.session.commit()
+            app.logger.info("Successfully added new job", extra={
+                'job_id': new_job.id,
+                'company': new_job.company,
+                'position': new_job.position
+            })
+            return redirect(url_for('jobs'))
+
+        app.logger.debug("Fetching jobs from database")
+        search_query = request.args.get('search', '').strip()
+        sort_by = request.args.get('sort', '').strip()
+        direction = request.args.get('direction', 'asc')
+        # Read status filter from query args
+        status_filter = request.args.get('status_filter', '').strip()
+        # Build base query
+        jobs_query = Job.query
+        # Apply search filter
+        if search_query:
+            filter_cond = or_(
+                Job.company.ilike(f"%{search_query}%"),
+                Job.position.ilike(f"%{search_query}%"),
+                Job.status.ilike(f"%{search_query}%")
+            )
+            jobs_query = jobs_query.filter(filter_cond)
+            app.logger.info(f"Filtering jobs with search '{search_query}'", extra={'search_query': search_query})
+        # Apply status filter
+        valid_statuses = {'Applied', 'Rejected', 'Interviewing'}
+        if status_filter in valid_statuses:
+            jobs_query = jobs_query.filter_by(status=status_filter)
+            app.logger.info(f"Filtering jobs by status '{status_filter}'", extra={'status_filter': status_filter})
+        # Apply sorting with direction
+        valid_sorts = {'position', 'date_applied', 'status'}
+        if sort_by in valid_sorts:
+            col = getattr(Job, sort_by)
+            if direction == 'desc':
+                jobs_query = jobs_query.order_by(col.desc())
+            else:
+                jobs_query = jobs_query.order_by(col.asc())
+            app.logger.info(f"Sorting jobs by '{sort_by}' {direction}", extra={'sort_by': sort_by, 'direction': direction})
+        # Execute query
+        jobs_list = jobs_query.all()
+        app.logger.info(f"Retrieved {len(jobs_list)} jobs", extra={ 'job_count': len(jobs_list), 'search_query': search_query, 'sort_by': sort_by })
+        
+        # Compute counts for Applied, Rejected, Interviewing
+        applied_count = Job.query.filter_by(status='Applied').count()
+        rejected_count = Job.query.filter_by(status='Rejected').count()
+        interviewing_count = Job.query.filter_by(status='Interviewing').count()
+        return render_template('jobs.html', jobs=jobs_list, search_query=search_query,
+                               applied_count=applied_count,
+                               rejected_count=rejected_count,
+                               interviewing_count=interviewing_count,
+                               sort_by=sort_by,
+                               direction=direction,
+                               status_filter=status_filter)
+    except SQLAlchemyError as e:
+        app.logger.error("Database error in jobs route", exc_info=True, extra={
+            'error': str(e)
+        })
+        flash(f"Database error: {e}")
+        return render_template('jobs.html', jobs=[], search_query='',
+                               applied_count=0, rejected_count=0, interviewing_count=0,
+                               sort_by='', direction='asc', status_filter='')
+
+@app.route('/edit_job/<int:job_id>', methods=['GET', 'POST'])
+def edit_job(job_id):
+    job = Job.query.get_or_404(job_id)
+    app.logger.info("Accessing job for edit", extra={
+        'job_id': job_id,
+        'company': job.company,
+        'position': job.position
+    })
+
+    if request.method == 'POST':
+        app.logger.info("Updating job details", extra={
+            'job_id': job_id,
+            'old_status': job.status,
+            'new_status': request.form.get('status')
+        })
+        
+        # Update the job details
+        job.company = request.form['company']
+        job.position = request.form['position']
+        job.resume_used = request.form.get('resume_used')
+        job.date_applied = request.form.get('date_applied')
+        job.status = request.form.get('status')
+        job.interview_details = request.form.get('interview_details')
+        job.comments = request.form.get('comments')
+        job.link = request.form.get('link')
+        job.job_description = request.form.get('job_description')
+
+        try:
+            db.session.commit()
+            app.logger.info("Successfully updated job", extra={
+                'job_id': job_id,
+                'company': job.company
+            })
+            
+            if job.job_description:
+                app.logger.debug("Generating interview plan")
+                interview_plan = generate_interview_plan(job.job_description)
+                flash(f"Interview Plan: {interview_plan}")
+
+            return redirect(url_for('jobs'))
+        except SQLAlchemyError as e:
+            app.logger.error("Failed to update job", exc_info=True, extra={
+                'job_id': job_id,
+                'error': str(e)
+            })
+            flash(f"Error updating job: {e}")
+            db.session.rollback()
+
+    return render_template('jobs.html', jobs=Job.query.all(), edit_job=job)
+
+# Function to generate an interview plan using OpenAI's GPT model
+def generate_interview_plan(job_description):
+    import os, sys
+    from openai import OpenAI
+
+    # Sanity check
+    print("Python exe:", sys.executable)
+    import openai as _oa
+    print("OpenAI version:", _oa.__version__)
+    print("OpenAI path:", _oa.__file__)
+
+    # Instantiate the client
+    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+    try:
+        resp = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": f"Create an interview plan for the following job description. Highlight key skills and requirements:\n{job_description}"},
+            ],
+            max_tokens=150
+        )
+
+        # Extract and return the generated text
+        return resp.choices[0].message.content.strip()
+
+    except Exception as e:
+        # This will catch everything, including rate‑limit/quota errors
+        print(f"Error ({type(e).__name__}): {e}")
+        # Optionally, if it’s a JSON‑style API error you can introspect:
+        try:
+            err = e.error if hasattr(e, "error") else None
+            print("Error details:", err)
+        except:
+            pass
+        return "Error generating interview plan. Please try again later."
+
+@app.route('/delete_job/<int:job_id>', methods=['POST'])
+def delete_job(job_id):
+    job = Job.query.get_or_404(job_id)
+    app.logger.info("Deleting job", extra={
+        'job_id': job_id,
+        'company': job.company,
+        'position': job.position
+    })
+    
+    try:
+        db.session.delete(job)
+        db.session.commit()
+        app.logger.info("Successfully deleted job", extra={
+            'job_id': job_id
+        })
+    except SQLAlchemyError as e:
+        app.logger.error("Failed to delete job", exc_info=True, extra={
+            'job_id': job_id,
+            'error': str(e)
+        })
+        db.session.rollback()
+        flash(f"Error deleting job: {e}")
+        
+    return redirect(url_for('jobs'))
+
+@app.route('/api/chat', methods=['POST'])
+def api_chat():
+    logging.info("[PrepMe] Received chat request")
+    data = request.get_json() or {}
+    user_msg = data.get('message', '').strip()
+    
+    logging.info(f"[PrepMe] User message: {user_msg}")
+    
+    if not user_msg:
+        logging.warning("[PrepMe] Empty message received")
+        return jsonify(response="Please type something!")
+
+    try:
+        # You can preload system/context messages here as needed
+        messages = [
+            {"role": "system", "content": "You are a helpful career coach."},
+            {"role": "user", "content": user_msg}
+        ]
+
+        logging.info("[PrepMe] Calling OpenAI API")
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+        chat = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            max_tokens=150
+        )
+        reply = chat.choices[0].message.content.strip()
+        logging.info(f"[PrepMe] OpenAI response: {reply}")
+        
+        return jsonify(response=reply)
+        
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        logging.error(f"[PrepMe] Chat error: {error_msg}")
+        return jsonify(response=error_msg)
+
+@app.route('/prepme/<int:job_id>', methods=['GET'])
+def prepme(job_id):
+    job = Job.query.get_or_404(job_id)
+
+    # Load the resume from the uploads directory
+    resume_path = os.path.join('uploads', 'resume.docx')
+    resume_content = ""
+    if os.path.exists(resume_path):
+        import docx
+        doc = docx.Document(resume_path)
+        resume_content = "\n".join([paragraph.text for paragraph in doc.paragraphs])
+
+    # Initial context for the chatbot
+    initial_context = f"Job Description:\n{job.job_description}\n\nResume:\n{resume_content}"
+
+    # Generate initial LLM response
+    try:
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        #logging.info(f"Initial context for OpenAI API: {initial_context}")
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are a career coach."},
+                {"role": "user", "content": f"Based on the following context, provide an initial response to help the user prepare for this job:\n{initial_context}"},
+            ],
+            max_tokens=150
+        )
+        initial_response = response.choices[0].message.content.strip()
+    except Exception as e:
+        logging.error(f"Error generating response from OpenAI API: {e}")
+        initial_response = "Error generating response. Please try again later."
+
+    return render_template('prepme.html', job=job, initial_context=initial_context, initial_response=initial_response)
+
+# Endpoint to download jobs as CSV
+@app.route('/download')
+def download_jobs():
+    search_query = request.args.get('search', '').strip()
+    if search_query:
+        filter_cond = or_(
+            Job.company.ilike(f"%{search_query}%"),
+            Job.position.ilike(f"%{search_query}%"),
+            Job.status.ilike(f"%{search_query}%")
+        )
+        jobs_list = Job.query.filter(filter_cond).all()
+    else:
+        jobs_list = Job.query.all()
+    # Prepare data for CSV
+    data = [
+        {'Company': job.company,
+         'Position': job.position,
+         'Resume Used': job.resume_used,
+         'Date Applied': job.date_applied,
+         'Status': job.status,
+         'Interview Details': job.interview_details,
+         'Comments': job.comments,
+         'Link': job.link,
+         'Job Description': job.job_description}
+        for job in jobs_list
+    ]
+    df = pd.DataFrame(data)
+    csv_data = df.to_csv(index=False)
+    return Response(
+        csv_data,
+        mimetype='text/csv',
+        headers={"Content-Disposition": "attachment;filename=jobs.csv"}
+    )
+
+if __name__ == "__main__":
+    # Convert Excel serial dates before first request
+    with app.app_context():
+        convert_excel_serial_dates()
+    app.run(host="0.0.0.0", port=5000, debug=True)

bfg-1.15.0.jar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfe2885adc2916379093f02a80181200536856c9a987bf21c492e452adefef7a
+size 14721936

myfirstcode.py

@@ -0,0 +1,32 @@
+from flask import Flask, request, jsonify
+
+app = Flask(__name__)
+
+# Define the addition function
+def add_numbers(a, b):
+    return a + b
+
+# Create an API route
+@app.route('/add', methods=['POST'])
+def add():
+    data = request.get_json()  # get JSON data from the request
+    a = data.get('a')
+    b = data.get('b')
+    
+    # Check if both a and b are provided
+    if a is None or b is None:
+        return jsonify({"error": "Please provide both 'a' and 'b' numbers."}), 400
+    
+    try:
+        a = float(a)
+        b = float(b)
+    except ValueError:
+        return jsonify({"error": "Inputs must be numbers."}), 400
+
+    result = add_numbers(a, b)
+    
+    return jsonify({"sum": result})
+
+# Run the app
+if __name__ == '__main__':
+    app.run(debug=True)

requirements.txt

@@ -0,0 +1,9 @@
+Flask>=2.2.0
+Flask-SQLAlchemy>=3.0.0
+Flask-Migrate>=4.0.0
+SQLAlchemy>=1.4.0
+python-dotenv>=0.21.0
+openai>=0.27.0
+pandas>=1.3.0
+python-docx>=0.8.10
+requests>=2.28.0

test.py

@@ -0,0 +1,32 @@
+import os, sys
+from openai import OpenAI
+
+# Sanity check
+print("Python exe:", sys.executable)
+import openai as _oa
+print("OpenAI version:", _oa.__version__)
+print("OpenAI path:", _oa.__file__)
+
+# Instantiate the client
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+try:
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a career coach."},
+            {"role": "user",   "content": "Hi there! How can I improve my resume?"}
+        ],
+        max_tokens=50
+    )
+    print("Assistant:", resp.choices[0].message.content.strip())
+
+except Exception as e:
+    # This will catch everything, including rate‑limit/quota errors
+    print(f"Error ({type(e).__name__}): {e}")
+    # Optionally, if it’s a JSON‑style API error you can introspect:
+    try:
+        err = e.error if hasattr(e, "error") else None
+        print("Error details:", err)
+    except:
+        pass