Upload 9 files

app.py

@@ -0,0 +1,275 @@
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+import google.generativeai as genai
+import urllib.parse
+from models import UserSchema
+from flask_bcrypt import Bcrypt
+from flask_jwt_extended import JWTManager, create_access_token
+from middleware.authUser import auth_user
+from datetime import timedelta 
+from controllers.demo import get_initial_data
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = Flask(__name__)
+
+
+
+bcrypt = Bcrypt(app)
+jwt = JWTManager(app)
+
+app.config['JWT_SECRET_KEY'] = os.getenv('JWT_SECRET')
+
+# MongoDB configuration
+username = urllib.parse.quote_plus(os.getenv('MONGO_USERNAME'))
+password = urllib.parse.quote_plus(os.getenv('MONGO_PASSWORD'))
+restUri = os.getenv('REST_URI')
+
+uri = f'mongodb+srv://{username}:{password}@cluster0.iidzcbc.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0'
+
+client = MongoClient(uri)
+db = client.GenUpNexus
+users_collection = db["users3"]
+
+# Send a ping to confirm a successful connection
+try:
+    client.admin.command('ping')
+    print("Pinged your deployment. You successfully connected to MongoDB!")
+except Exception as e:
+    print(e)
+
+
+GOOGLE_API_KEY=os.getenv('GOOGLE_API_KEY')
+
+genai.configure(api_key=GOOGLE_API_KEY)
+model = genai.GenerativeModel('gemini-pro')
+
+@app.route('/')
+def index():
+    return "Server is Running..."
+
+@app.route('/tree', methods=["POST", "GET"])
+def tree():
+    if request.method == 'POST':
+        data = request.get_json()
+        query = data.get('query')
+        print(query)
+        response = model.generate_content('''I will give you a topic and you have to generate an explanation of the topic and respond with JSON structure as follows as i want to use this json are Nodes & Edges and visualise this using ReactFlow library, the json structure will be :
+        nodes = [
+            {
+                id: "1",
+                type: "input",
+                data: {
+                label: "Input Node",
+                },
+                position: { x: 250, y: 0 },
+            },
+            {
+                id: "2",
+                data: {
+                label: "Default Node",
+                },
+                position: { x: 100, y: 100 },
+            },
+            {
+                id: "3",
+                type: "output",
+                data: {
+                label: "Output Node",
+                },
+                position: { x: 400, y: 100 },
+            },
+            {
+                id: "4",
+                type: "custom",
+                position: { x: 100, y: 200 },
+                data: {
+                selects: {
+                    "handle-0": "smoothstep",
+                    "handle-1": "smoothstep",
+                },
+                },
+            },
+            {
+                id: "5",
+                type: "output",
+                data: {
+                label: "custom style",
+                },
+                className: "circle",
+                style: {
+                background: "#2B6CB0",
+                color: "white",
+                },
+                position: { x: 400, y: 200 },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+            },
+            {
+                id: "6",
+                type: "output",
+                style: {
+                background: "#63B3ED",
+                color: "white",
+                width: 100,
+                },
+                data: {
+                label: "Node",
+                },
+                position: { x: 400, y: 325 },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+            },
+            {
+                id: "7",
+                type: "default",
+                className: "annotation",
+                data: {
+                label: (
+                    <>
+                    On the bottom left you see the <strong>Controls</strong> and the
+                    bottom right the <strong>MiniMap</strong>. This is also just a node 🥳
+                    </>
+                ),
+                },
+                draggable: false,
+                selectable: false,
+                position: { x: 150, y: 400 },
+            },
+            ];
+
+            edges = [
+                { id: "e1-2", source: "1", target: "2", label: "this is an edge label" },
+                { id: "e1-3", source: "1", target: "3", animated: true },
+                {
+                    id: "e4-5",
+                    source: "4",
+                    target: "5",
+                    type: "smoothstep",
+                    sourceHandle: "handle-0",
+                    data: {
+                    selectIndex: 0,
+                    },
+                    markerEnd: {
+                    type: MarkerType.ArrowClosed,
+                    },
+                },
+                {
+                    id: "e4-6",
+                    source: "4",
+                    target: "6",
+                    type: "smoothstep",
+                    sourceHandle: "handle-1",
+                    data: {
+                    selectIndex: 1,
+                    },
+                    markerEnd: {
+                    type: MarkerType.ArrowClosed,
+                    },
+                },
+            ];
+            Topic is: ''' + query)
+        
+        # print(response.text)
+        return jsonify({'success': True, 'data': response.text})
+        # return temp 
+
+@app.route('/interview', methods=["POST", "GET"])
+def interview():
+    if request.method == 'POST':
+        data = request.get_json()
+        if data.get('from') == 'client':
+            return "Success"
+        elif data.get('from') == 'gradio':
+            print(data)
+            return "Success"
+
+
+# User Routes
+@app.route('/user/signup', methods=['POST'])
+def signup():
+    data = request.json
+    name = data.get('name')
+    email = data.get('email')
+    password = data.get('password')
+
+    if not email:
+        return jsonify({"error": "Invalid email"}), 400
+
+    existing_user = users_collection.find_one({"email": email})
+
+    if existing_user:
+        return jsonify({"message": "User already exists"}), 404
+
+    hashed_password = bcrypt.generate_password_hash(password).decode('utf-8')
+
+    result = users_collection.insert_one({
+        "name": name,
+        "email": email,
+        "password": hashed_password
+    })
+
+    print(result);
+
+    expires = timedelta(days=7)
+    access_token = create_access_token(identity={"email": email, "id": str(result.inserted_id)}, expires_delta=expires)
+
+    res = {"name": name, "email": email}
+    
+    return jsonify({"result": res, "token": access_token}), 201
+
+@app.route('/user/signin', methods=['POST'])
+def signin():
+    data = request.json
+    email = data.get('email')
+    password = data.get('password')
+
+    user = users_collection.find_one({"email": email})
+
+    if not user:
+        return jsonify({"message": "User doesn't exist"}), 404
+
+    if not bcrypt.check_password_hash(user['password'], password):
+        return jsonify({"message": "Invalid Credentials"}), 404
+
+    expires = timedelta(days=7)
+    access_token = create_access_token(identity={"email": user['email'], "id": str(user['_id'])}, expires_delta=expires)
+
+    res = {"name": user['name'], "email": user['email']}
+
+    return jsonify({"result": res, "token": access_token}), 200
+
+#protected route wiht auth_user middleware
+@app.route('/user/delete', methods=['POST'])
+@auth_user
+def delete_account():
+    email = request.email
+    print(email)
+    try:
+        result = users_collection.delete_one({"email": email})
+        if result.deleted_count == 1:
+            return jsonify({"result": True}), 200
+        else:
+            return jsonify({"result": False, "message": "User not found"}), 404
+    except Exception as e:
+        print(e)
+        return jsonify({"message": "Something went wrong"}), 500
+
+@app.route('/mindmap/demo', methods=['POST'])
+def mindmapDemo():
+    data = request.json
+    print(data)
+    return get_initial_data(), 200
+
+
+
+
+CORS(app)
+
+if __name__ == '__main__':
+    app.run(debug=True)

body_language.pkl

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

controllers/demo.py

@@ -0,0 +1,49 @@
+from flask import jsonify
+
+def get_initial_data():
+    initial_nodes = [
+        {
+            "id": "data-input",
+            "position": {"x": 0, "y": 0},
+            "data": {"label": "Data Input"}
+        },
+        {
+            "id": "data-preprocessing",
+            "position": {"x": 200, "y": 0},
+            "data": {"label": "Data Preprocessing"}
+        },
+        {
+            "id": "model-training",
+            "position": {"x": 400, "y": 0},
+            "data": {"label": "Model Training"}
+        },
+        {
+            "id": "model-evaluation",
+            "position": {"x": 0, "y": 200},
+            "data": {"label": "Model Evaluation"}
+        },
+        {
+            "id": "prediction",
+            "position": {"x": 200, "y": 200},
+            "data": {"label": "Prediction"}
+        },
+        {
+            "id": "data-visualization",
+            "position": {"x": 400, "y": 200},
+            "data": {"label": "Data Visualization"}
+        },
+    ]
+
+    initial_edges = [
+        {"id": "data-input-to-preprocessing", "source": "data-input", "target": "data-preprocessing"},
+        {"id": "preprocessing-to-training", "source": "data-preprocessing", "target": "model-training"},
+        {"id": "training-to-evaluation", "source": "model-training", "target": "model-evaluation"},
+        {"id": "training-to-prediction", "source": "model-training", "target": "prediction"},
+        {"id": "evaluation-to-visualization", "source": "model-evaluation", "target": "data-visualization"},
+        {"id": "prediction-to-visualization", "source": "prediction", "target": "data-visualization"}
+    ]
+
+    return jsonify({
+        "initialNodes": initial_nodes,
+        "initialEdges": initial_edges
+    })

middleware/authUser.py

@@ -0,0 +1,35 @@
+from flask import request, jsonify
+import jwt
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+def auth_user(next_function):
+    def middleware_function(*args, **kwargs):
+        try:
+            token = request.headers.get('Authorization', '').split(" ")[1]
+            is_custom_auth = len(token) < 500
+            decoded_data = None
+
+            if token and is_custom_auth:
+                secret_key = os.getenv('JWT_SECRET')
+                decoded_data = jwt.decode(token, secret_key, algorithms=["HS256"])
+                print(decoded_data)
+                dat = decoded_data.get('sub')
+                request.email = dat.get('email')
+                request.userId = dat.get('id')
+            else:
+                #google auth
+                decoded_data = jwt.decode(token)
+                request.email = decoded_data.get('email')
+                request.userId = decoded_data.get('sub')
+
+            return next_function(*args, **kwargs)
+
+        except Exception as e:
+            print(e)  # Log the error if needed
+            return jsonify({"error": "Unauthorized"}), 401
+
+    return middleware_function

models.py

@@ -0,0 +1,33 @@
+from marshmallow import Schema, fields
+
+class UserSchema(Schema):
+    name = fields.Str(required=True)
+    email = fields.Email(required=True)
+    password = fields.Str(required=True)
+    resume = fields.Str()  
+    dp = fields.Str()  
+
+class DashboardSchema(Schema):
+    uniq_path_id = fields.Str(required=True)
+    name = fields.Str(required=True)
+    current_role = fields.Str()
+    desired_company = fields.Str()
+    learning_path_progress = fields.Dict()
+    recent_mindmaps = fields.Dict()
+    recent_interviews = fields.Dict()
+
+class LearningPathSchema(Schema):
+    uniq_path_id = fields.Str(required=True)
+    data = fields.Dict() 
+    total_path_tuples = fields.Int()
+    current_progress_tuples = fields.Int()
+
+class MindmapSchema(Schema):
+    uniq_map_id = fields.Str(required=True)
+    data = fields.Dict()  
+
+class InterviewSchema(Schema):
+    uniq_interview_id = fields.Str(required=True)
+    data = fields.Dict()
+
+

requirements.txt

@@ -0,0 +1,19 @@
+gradio==4.22.0
+opencv-python==4.9.0.80
+transformers==4.38.2
+pydub==0.25.1
+faster_whisper==1.0.1
+joblib==1.3.2
+mediapipe==0.10.11
+numpy==1.26.4
+pandas==2.2.1
+moviepy==1.0.3
+flask==3.0.2
+Werkzeug==3.0.1
+Flask-Cors==4.0.0
+google-generativeai==0.4.1
+python-dotenv==1.0.1
+pymongo[srv]
+marshmallow
+flask_bcrypt 
+flask_jwt_extended