Upload folder using huggingface_hub

.env

@@ -0,0 +1,4 @@
+GEMINI_API_KEY=AIzaSyC4rLyiP8_JbDRX9MxAoyfRbDuNSC0yWx8
+DATABASE_URL=postgres://default:iVbwf9nhs6pO@ep-floral-rice-a4pxkfqr-pooler.us-east-1.aws.neon.tech:5432/verceldb
+PORT=8760
+STRIPE_API_KEY=sk_test_51P9eeaBmFqxDim26JnTtosYT9IThGXNOxcqfWP77hsv6Jfkgh3FGndLErvQMxk1ugO1hcKkmEQjR6qB9W1PmaiVW00qVZD64Rh

.gitattributes

@@ -33,3 +33,37 @@ 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
+venv/bin/ruff filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/.dylibs/libfreetype.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/PIL/.dylibs/libharfbuzz.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/altair/vegalite/v5/schema/__pycache__/channels.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/cryptography/hazmat/bindings/_rust.abi3.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/fontTools/misc/bezierTools.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/gradio/frpc_darwin_arm64_v0.2 filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/Index-BQLeAZ7H.js.map filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/grpc/_cython/cygrpc.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/numpy/.dylibs/libgfortran.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/numpy/.dylibs/libopenblas64_.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/numpy/core/_multiarray_umath.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pandas/_libs/algos.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pandas/_libs/groupby.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pandas/_libs/hashtable.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pandas/_libs/interval.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pandas/_libs/join.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/_compute.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/_dataset.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/_flight.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/lib.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow_acero.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow_dataset.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow_flight.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow_python.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libarrow_substrait.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pyarrow/libparquet.1601.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pydantic_core/_pydantic_core.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/pydeck/nbextension/static/index.js.map filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/uvloop/loop.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.11/site-packages/watchfiles/_rust_notify.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/share/jupyter/nbextensions/pydeck/index.js.map filter=lfs diff=lfs merge=lfs -text

BKP.index.py

@@ -0,0 +1,39 @@
+import gradio as gr
+
+def login(profile_id, profile_type, visibility):
+    # Simulated login check
+    if profile_type.lower() == 'user' and profile_id == "123":  # Assume "123" is a valid user ID
+        visibility.value = True  # Update visibility state to True if login is successful
+        return "Login Successful"
+    else:
+        visibility.value = False  # Keep the AI tab hidden if login fails
+        return "Login Failed"
+
+def gradio_interface():
+    with gr.Blocks() as app:
+        ai_tab_visibility = gr.State(False)  # State to control the visibility of the AI Interaction tab
+
+        with gr.Tabs():
+            login_tab = gr.TabItem("Login")
+            ai_tab = gr.TabItem("AI Interaction", visible=ai_tab_visibility)  # Controlled by state
+
+            with login_tab:
+                profile_id_input = gr.Textbox(label="Enter your User ID")
+                profile_type_input = gr.Radio(choices=["User", "Ninja"], label="Select Profile Type")
+                login_result = gr.Textbox(label="Login Result", interactive=False)
+                login_button = gr.Button("Login")
+
+                login_button.click(
+                    fn=login,
+                    inputs=[profile_id_input, profile_type_input, ai_tab_visibility],
+                    outputs=login_result
+                )
+
+            with ai_tab:
+                gr.Markdown("## AI Interaction Panel")
+                # Place your AI interaction components here
+
+    app.launch()
+
+if __name__ == "__main__":
+    gradio_interface()

README.md

@@ -1,12 +1,6 @@
 ---
 title: TaskNinja
-emoji: 💻
-colorFrom: gray
-colorTo: red
+app_file: index.py
 sdk: gradio
-sdk_version: 4.32.1
-app_file: app.py
-pinned: false
+sdk_version: 4.31.2
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

index.py

@@ -0,0 +1,909 @@
+import os
+import gradio as gr
+import google.generativeai as genai
+import psycopg2
+import json
+import logging
+import time
+from dotenv import load_dotenv
+import re
+import stripe
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Set up basic configuration for logging
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Configure Stripe API
+stripe.api_key = os.getenv("STRIPE_API_KEY")
+
+# Configure the Google AI model
+genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+
+# Create the model with predefined configuration
+generation_config = {
+    "temperature": 1,
+    "top_p": 0.95,
+    "top_k": 64,
+    "max_output_tokens": 8192,
+    "response_mime_type": "text/plain",
+}
+safety_settings = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+]
+
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-flash-latest",
+    safety_settings=safety_settings,
+    generation_config=generation_config,
+)
+
+# In-memory cache for profiles
+profiles_cache = {
+    "data": None,
+    "timestamp": None,
+    "cache_duration": 60 * 5  # Cache duration in seconds (5 minutes)
+}
+
+def get_database_connection():
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        logging.error("DATABASE_URL is not set in environment variables.")
+        raise ValueError("DATABASE_URL is not set in environment variables.")
+    try:
+        return psycopg2.connect(database_url)
+    except Exception as e:
+        logging.error(f"Failed to connect to the database: {e}")
+        raise
+
+def fetch_profiles():
+    global profiles_cache
+    current_time = time.time()
+    
+    # Check if cache is valid
+    if profiles_cache["data"] and (current_time - profiles_cache["timestamp"] < profiles_cache["cache_duration"]):
+        logging.info("Using cached profiles data.")
+        return profiles_cache["data"]
+
+    logging.info("Fetching profiles from database.")
+    conn = get_database_connection()
+    profiles = []
+    try:
+        with conn.cursor() as curs:
+            curs.execute("SELECT name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic FROM gig_workers")
+            for row in curs.fetchall():
+                skills = json.loads(row[2]) if isinstance(row[2], str) else row[2]
+                profile = {
+                    "Name": row[0],
+                    "About": row[1],
+                    "Skills": skills,
+                    "Rating": row[3],
+                    "Trust Score": row[4],
+                    "Ninja Level": row[5],
+                    "Task Experience": row[6],
+                    "Online Status": row[7],
+                    "Profile Pic": row[8]
+                }
+                profiles.append(profile)
+    except Exception as e:
+        logging.error(f"Error fetching profiles: {e}")
+        raise
+    finally:
+        conn.close()
+    
+    # Update cache
+    profiles_cache["data"] = profiles
+    profiles_cache["timestamp"] = current_time
+    
+    return profiles
+
+def add_person(name, about, profile_type, skills=None, rating=None, level=None):
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            if profile_type == 'User':
+                curs.execute("""
+                    INSERT INTO users (name, about, level) VALUES (%s, %s, %s) RETURNING user_id
+                """, (name, about, level))
+            else:
+                curs.execute("""
+                    INSERT INTO ninjas (name, skills, rating) VALUES (%s, %s, %s) RETURNING ninja_id
+                """, (name, json.dumps(skills.split(', ')), rating))
+            profile_id = curs.fetchone()[0]
+            conn.commit()
+        return f"{profile_type} added with ID: {profile_id}"
+    finally:
+        conn.close()
+
+# Function to fetch User or Ninja details
+def fetch_details(profile_id, profile_type):
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            if profile_type == 'User':
+                curs.execute("SELECT name, about, level FROM users WHERE user_id = %s", (profile_id,))
+            else:
+                curs.execute("SELECT name, skills, rating FROM ninjas WHERE ninja_id = %s", (profile_id,))
+            details = curs.fetchone()
+            return details if details else f"No {profile_type} found with the given ID."
+    finally:
+        conn.close()
+
+def fetch_users():
+    conn = get_database_connection()
+    users = []
+    try:
+        with conn.cursor() as curs:
+            curs.execute("SELECT user_id, name, profile_name, about, trust_score, online_status, profile_pic, level FROM users")
+            for row in curs.fetchall():
+                user = {
+                    "User ID": row[0],
+                    "Name": row[1],
+                    "Profile Name": row[2],
+                    "About": row[3],
+                    "Trust Score": row[4],
+                    "Online Status": row[5],
+                    "Profile Pic": row[6],
+                    "Level": row[7],
+                }
+                users.append(user)
+    except Exception as e:
+        logging.error(f"Error fetching users: {e}")
+        raise
+    finally:
+        conn.close()
+    
+    return users
+
+def add_user(name, profile_name, about, trust_score, online_status, profile_pic, level):
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO users (name, profile_name, about, trust_score, online_status, profile_pic, level)
+                VALUES (%s, %s, %s, %s, %s, %s, %s) RETURNING user_id
+            """, (name, profile_name, about, trust_score, online_status, profile_pic, level))
+            user_id = curs.fetchone()[0]
+            conn.commit()
+        logging.info(f"User added with ID: {user_id}")
+        return f"User added with ID: {user_id}"
+    except Exception as e:
+        logging.error(f"Error adding user: {e}")
+        conn.rollback()
+        return f"Error adding user: {e}"
+    finally:
+        conn.close()
+
+def user_exists(user_id):
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("SELECT 1 FROM users WHERE user_id = %s", (user_id,))
+            return curs.fetchone() is not None
+    except Exception as e:
+        logging.error(f"Error checking user existence: {e}")
+        return False
+    finally:
+        conn.close()
+
+def remove_markdown_bold(text):
+    return re.sub(r'\*\*(.*?)\*\*', r'\1', text)
+
+def ask_model_questions(task_description, history=None):
+    if history is None:
+        history = []
+
+    chat_session = model.start_chat(history=history)
+
+    prompt = (f"As an expert in the field related to the task description: '{task_description}', "
+              "what additional information do you need to better understand the task requirements? "
+              "Please provide your questions in the following format:\n"
+              "Question 1: [Your question here]?\n"
+              "Question 2: [Your question here]?\n"
+              "...\n"
+              "If you have enough information, please type 'Enough information'.")
+
+    response = chat_session.send_message(prompt)
+    history.append({"prompt": prompt, "response": response.text})
+
+    if "enough information" in response.text.lower():
+        return None, history
+
+    return remove_markdown_bold(response.text), history
+
+def refine_task_description(task_description, question_answers, history=None):
+    if history is None:
+        history = []
+
+    chat_session = model.start_chat(history=history)
+
+    prompt = (f"Original task description: {task_description}\n\n"
+              f"Additional information provided:\n{question_answers}\n\n"
+              "Based on the original task description and the additional information provided, "
+              "please provide a complete and refined task description.")
+
+    response = chat_session.send_message(prompt)
+    history.append({"prompt": prompt, "response": response.text})
+
+    return remove_markdown_bold(response.text), history
+
+def find_best_profile(task_description):
+    profiles = fetch_profiles()
+    chat_session = model.start_chat()
+    
+    prompt = (f"Based on the complete task description: {task_description}\n\n"
+              "Evaluate the suitability of the following gig worker profiles "
+              "and provide the name of the best-matched profile along with an explanation in the following format:\n"
+              "Name: [Best-matched profile name]\n"
+              "Why [Best-matched profile name]? [Explanation]\n\nProfiles:\n")
+    for i, profile in enumerate(profiles, start=1): 
+        prompt += (f"{i}. Name: {profile['Name']}, Skills: {', '.join(profile['Skills'])}, Experience: {profile['Task Experience']} hours, "
+                   f"Rating: {profile['Rating']}, Trust Score: {profile['Trust Score']}, Online Status: {profile['Online Status']}, Profile Pic: {profile['Profile Pic']}\n")
+
+    response = chat_session.send_message(prompt)
+    return remove_markdown_bold(response.text)
+
+# Backend Functions for Task and User Profile Management
+
+def post_task(user_id, task_description, additional_info):
+    if not user_id or not task_description:
+        logging.error("User ID and Task Description are required")
+        return "User ID and Task Description are required"
+    if not user_exists(user_id):
+        logging.error(f"User ID {user_id} does not exist")
+        return f"User ID {user_id} does not exist"
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO tasks (user_id, task_description, additional_info)
+                VALUES (%s, %s, %s) RETURNING task_id
+            """, (user_id, task_description, additional_info))
+            task_id = curs.fetchone()[0]
+            conn.commit()
+        logging.info(f"Task posted with ID: {task_id}")
+        return f"Task posted with ID: {task_id}"
+    except Exception as e:
+        logging.error(f"Error posting task: {e}")
+        conn.rollback()
+        return f"Error posting task: {e}"
+    finally:
+        conn.close()
+
+def update_task_status(task_id, status):
+    if not task_id or not status:
+        logging.error("Task ID and Status are required")
+        return "Task ID and Status are required"
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                UPDATE tasks SET status = %s, updated_at = CURRENT_TIMESTAMP WHERE task_id = %s
+            """, (status, task_id))
+            conn.commit()
+        logging.info(f"Task {task_id} status updated to {status}")
+        return f"Task {task_id} status updated to {status}"
+    except Exception as e:
+        logging.error(f"Error updating task status: {e}")
+        conn.rollback()
+        return f"Error updating task status: {e}"
+    finally:
+        conn.close()
+
+def get_task_progress(task_id):
+    if not task_id:
+        logging.error("Task ID is required")
+        return "Task ID is required"
+    
+    conn = get_database_connection()
+    progress = []
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                SELECT update_text, updated_at FROM task_progress WHERE task_id = %s ORDER BY updated_at DESC
+            """, (task_id,))
+            for row in curs.fetchall():
+                progress.append({"update_text": row[0], "updated_at": row[1]})
+    except Exception as e:
+        logging.error(f"Error fetching task progress: {e}")
+        return f"Error fetching task progress: {e}"
+    finally:
+        conn.close()
+    return progress
+
+def update_task_progress(task_id, update_text):
+    if not task_id or not update_text:
+        logging.error("Task ID and Progress Update Text are required")
+        return "Task ID and Progress Update Text are required"
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO task_progress (task_id, update_text) VALUES (%s, %s)
+            """, (task_id, update_text))
+            conn.commit()
+        logging.info(f"Progress for task {task_id} updated")
+        return f"Progress for task {task_id} updated"
+    except Exception as e:
+        logging.error(f"Error updating task progress: {e}")
+        conn.rollback()
+        return f"Error updating task progress: {e}"
+    finally:
+        conn.close()
+
+def upload_task_result(task_id, result_file):
+    if not task_id or not result_file:
+        logging.error("Task ID and Result File are required")
+        return "Task ID and Result File are required"
+
+    # Save the uploaded file to a location and get its URL
+    result_url = f"task_results/{task_id}.pdf"
+    result_file.save(result_url)
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                UPDATE tasks SET result_url = %s WHERE task_id = %s
+            """, (result_url, task_id))
+            conn.commit()
+        logging.info(f"Result for task {task_id} uploaded")
+        return f"Result for task {task_id} uploaded"
+    except Exception as e:
+        logging.error(f"Error uploading task result: {e}")
+        conn.rollback()
+        return f"Error uploading task result: {e}"
+    finally:
+        conn.close()
+
+def update_user_online_status(user_id, online_status):
+    if not user_id:
+        logging.error("User ID is required")
+        return "User ID is required"
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            # Check if user exists
+            curs.execute("SELECT 1 FROM users WHERE user_id = %s", (user_id,))
+            if curs.fetchone() is None:
+                logging.error(f"User ID {user_id} does not exist")
+                return f"User ID {user_id} does not exist"
+            
+            # Update the online status if user exists
+            curs.execute("""
+                UPDATE users SET online_status = %s WHERE user_id = %s
+            """, (online_status, user_id))
+            conn.commit()
+        logging.info(f"User {user_id} online status updated to {online_status}")
+        return f"User {user_id} online status updated to {online_status}"
+    except Exception as e:
+        logging.error(f"Error updating user online status: {e}")
+        conn.rollback()
+        return f"Error updating user online status: {e}"
+    finally:
+        conn.close()
+
+def update_user_profile_pic(user_id, profile_pic_file):
+    if not user_id or not profile_pic_file:
+        logging.error("User ID and Profile Picture File are required")
+        return "User ID and Profile Picture File are required"
+    
+    # Save the uploaded file to a location and get its URL
+    profile_pic_url = f"profile_pictures/{user_id}.png"
+    profile_pic_file.save(profile_pic_url)
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                UPDATE users SET profile_pic = %s WHERE user_id = %s
+            """, (profile_pic_url, user_id))
+            conn.commit()
+        logging.info(f"User {user_id} profile picture updated")
+        return f"User {user_id} profile picture updated"
+    except Exception as e:
+        logging.error(f"Error updating user profile picture: {e}")
+        conn.rollback()
+        return f"Error updating user profile picture: {e}"
+    finally:
+        conn.close()
+
+def add_gig_worker(name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file):
+    if not name:
+        logging.error("Name is required")
+        return "Name is required"
+
+    profile_pic_url = f"profile_pictures/{name}.png"
+    profile_pic_file.save(profile_pic_url)
+
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO gig_workers (name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s) RETURNING id 
+            """, (name, about, json.dumps(skills), rating, trust_score, ninja_level, task_experience, online_status, profile_pic_url))
+            id = curs.fetchone()[0]
+            conn.commit()
+        logging.info(f"Gig worker added with ID: {id}")
+        return f"Gig worker added with ID: {id}"
+    except Exception as e:
+        logging.error(f"Error adding gig worker: {e}")
+        conn.rollback()
+        return f"Error adding gig worker: {e}"
+    finally:
+        conn.close()
+
+def update_gig_worker(worker_id, name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file):
+    if not worker_id:
+        logging.error("Worker ID is required")
+        return "Worker ID is required"
+
+    profile_pic_url = f"profile_pictures/{worker_id}.png"
+    profile_pic_file.save(profile_pic_url)
+
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                UPDATE gig_workers
+                SET name = %s, about = %s, skills = %s, rating = %s, trust_score = %s, ninja_level = %s, task_experience = %s, online_status = %s, profile_pic = %s
+                WHERE id = %s
+            """, (name, about, json.dumps(skills), rating, trust_score, ninja_level, task_experience, online_status, profile_pic_url, worker_id))
+            conn.commit()
+        logging.info(f"Gig worker {worker_id} updated")
+        return f"Gig worker {worker_id} updated"
+    except Exception as e:
+        logging.error(f"Error updating gig worker: {e}")
+        conn.rollback()
+        return f"Error updating gig worker: {e}"
+    finally:
+        conn.close()
+
+def fetch_gig_worker(worker_id):
+    if not worker_id:
+        logging.error("Worker ID is required")
+        return {"error": "Worker ID is required"}
+
+    conn = get_database_connection()
+    worker = None
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                SELECT name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic
+                FROM gig_workers WHERE id = %s
+            """, (worker_id,))
+            row = curs.fetchone()
+            if row:
+                skills = json.loads(row[2]) if isinstance(row[2], str) else row[2]
+                worker = {
+                    "Name": row[0],
+                    "About": row[1],
+                    "Skills": skills,
+                    "Rating": row[3],
+                    "Trust Score": row[4],
+                    "Ninja Level": row[5],
+                    "Task Experience": row[6],
+                    "Online Status": row[7],
+                    "Profile Pic": row[8]
+                }
+            else:
+                return {"error": f"No worker found with ID {worker_id}"}
+    except Exception as e:
+        logging.error(f"Error fetching gig worker: {e}")
+        return {"error": f"Error fetching gig worker: {e}"}
+    finally:
+        conn.close()
+    return worker
+
+def create_payment_session(amount, currency, success_url, cancel_url):
+    try:
+        session = stripe.checkout.Session.create(
+            payment_method_types=['card'],
+            line_items=[{
+                'price_data': {
+                    'currency': currency,
+                    'product_data': {
+                        'name': 'Service Payment',
+                    },
+                    'unit_amount': int(amount * 100),  # Stripe uses the smallest currency unit
+                },
+                'quantity': 1,
+            }],
+            mode='payment',
+            success_url=success_url,
+            cancel_url=cancel_url,
+        )
+        logging.info(f"Payment session created: {session['id']}")
+        return session.url
+    except Exception as e:
+        logging.error(f"Error creating payment session: {e}")
+        return f"Error creating payment session: {e}"
+    
+def get_database_connection():
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        logging.error("DATABASE_URL is not set in environment variables.")
+        raise ValueError("DATABASE_URL is not set in environment variables.")
+    try:
+        return psycopg2.connect(database_url)
+    except Exception as e:
+        logging.error(f"Failed to connect to the database: {e}")
+        raise
+
+def fetch_user(user_id):
+    logging.debug(f"Fetching User 1: {user_id}")
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            logging.debug(f"Fetching User 2: {user_id}")
+            curs.execute("SELECT name FROM users WHERE user_id = %s", (user_id,))
+            user = curs.fetchone()
+            if user:
+                logging.debug(f"Fetched User: {user}")
+                return True, {"name": user[0], "user_id": user_id}
+            else:
+                return False, "No user found with ID: {}".format(user_id)
+    finally:
+        conn.close()
+
+def fetch_ninja(ninja_id):
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("SELECT name FROM ninjas WHERE ninja_id = %s", (ninja_id,))
+            ninja = curs.fetchone()
+            if ninja:
+                return True, {"name": ninja[0], "ninja_id": ninja_id}
+            else:
+                return False, "No ninja found with ID: {}".format(ninja_id)
+    finally:
+        conn.close()
+        
+def login(profile_id, profile_type):
+    try:
+        if profile_type.lower() == 'user':
+            success, details = fetch_user(profile_id)
+        elif profile_type.lower() == 'ninja':
+            success, details = fetch_ninja(profile_id)
+        else:
+            return "Invalid profile type", False
+
+        if success:
+            return "Login Successful", True
+        else:
+            return details, False
+    except Exception as e:
+        return str(e), False
+    
+    
+def gradio_interface():
+    logging.debug("Starting Gradio interface")
+    with gr.Blocks(css=".gradio-container {background-color: #f4f4f4}") as iface:
+        ai_tab_visibility = gr.State(False)
+        logging.debug(f"BEFORE VISIBILITY: {ai_tab_visibility.value}")
+        with gr.Tabs() as tabs:
+            # Existing tabs here...
+            
+            login_tab = gr.TabItem("Login")
+            
+
+            with login_tab:
+                profile_id_input = gr.Textbox(label="Enter your User ID")
+                profile_type_input = gr.Radio(choices=["User", "Ninja"], label="Select Profile Type")
+                login_button = gr.Button("Login")
+                login_result = gr.Textbox(label="Login Result", interactive=False)
+                ai_tab_visibility = gr.State(False)  # State to control the visibility of the AI Tab
+
+                def update_visibility(result, visible):
+                    ai_tab_visibility.value = visible  # Update the visibility based on login success
+                    return result, visible
+
+                login_button.click(
+                    fn=lambda profile_id, profile_type: update_visibility(*login(profile_id, profile_type)),
+                    inputs=[profile_id_input, profile_type_input],
+                    outputs=[login_result, ai_tab_visibility]
+                )
+                
+
+            with gr.TabItem("AI Interaction", visible=ai_tab_visibility.value) as ai_tab:
+                
+                gr.Markdown("Enter a task description and interact with the AI. Provide additional details if prompted by the AI for more information.")
+                
+                task_description = gr.Textbox(label="Enter your task description")
+                
+                with gr.Column(visible=False) as question_column:
+                    model_questions = gr.Textbox(label="Model Questions", interactive=False)
+                    question_answers = gr.Textbox(label="Your Answer", placeholder="Type your answer here...")
+                    question_submit_button = gr.Button(value="Submit", variant="primary")
+                
+                refined_task_description = gr.Textbox(label="Refined Task Description", visible=False)
+                find_button = gr.Button(value="Find", visible=False)
+                best_matched_profile = gr.Textbox(label="Best Matched Profile", visible=False)
+                reset_button = gr.Button(value="Reset", variant="secondary")
+            
+                question_history = gr.State([])
+                refine_history = gr.State([])
+                
+                def process_task_questions(task_description, question_history):
+                    logging.debug(f"Processing task questions for task description: {task_description}")
+                    questions, updated_history = ask_model_questions(task_description, question_history)
+                    
+                    if questions:
+                        logging.debug(f"Questions from AI: {questions}")
+                        return gr.update(value=questions, visible=True), gr.update(visible=True), gr.update(visible=True), updated_history
+                    else:
+                        logging.debug("No additional questions from AI.")
+                        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), updated_history
+                        
+                def process_task_refinement(task_description, question_answers, refine_history):
+                    refined_description, updated_history = refine_task_description(task_description, question_answers, refine_history)
+                    return gr.update(value=refined_description, visible=True), gr.update(visible=True), updated_history
+                        
+                def find_best_profile_event(complete_task_description):
+                    best_profile = find_best_profile(complete_task_description)
+                    return gr.update(value=best_profile, visible=True)
+                        
+                def reset_interface():
+                    return (
+                        "",
+                        gr.update(visible=False),
+                        gr.update(value="", visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        "",
+                        [],
+                        []
+                    )
+
+                task_description.submit(process_task_questions, [task_description, question_history], [model_questions, question_column, question_history])
+                question_submit_button.click(process_task_refinement, [task_description, question_answers, refine_history], [refined_task_description, find_button, refine_history])
+                find_button.click(find_best_profile_event, inputs=refined_task_description, outputs=best_matched_profile)
+                reset_button.click(reset_interface, None, [task_description, model_questions, question_column, refined_task_description, find_button, best_matched_profile, question_history, refine_history])
+            
+                # Add custom CSS styles to remove bold text in text fields
+                iface.css += """
+                    .gradio-interface .gradio-textbox {
+                        font-weight: normal;
+                    }
+                """
+            
+            with gr.TabItem("Task Management"):
+                gr.Markdown("Manage tasks.")
+        
+                # Post Task
+                post_task_user_id = gr.Number(label="User ID")
+                post_task_description = gr.Textbox(label="Task Description")
+                post_task_additional_info = gr.Textbox(label="Additional Info")
+                post_task_button = gr.Button(value="Post Task")
+                post_task_output = gr.Textbox(label="Post Task Output")
+        
+                def handle_post_task(user_id, description, additional_info):
+                    logging.debug(f"Posting task for user {user_id} with description: {description}")
+                    result = post_task(user_id, description, additional_info)
+                    logging.debug(f"Post task result: {result}")
+                    return result
+        
+                post_task_button.click(handle_post_task, inputs=[post_task_user_id, post_task_description, post_task_additional_info], outputs=post_task_output)
+        
+                # Update Task Status
+                update_task_id = gr.Number(label="Task ID")
+                update_task_status_input = gr.Textbox(label="Status")
+                update_task_status_button = gr.Button(value="Update Task Status")
+                update_task_status_output = gr.Textbox(label="Update Task Status Output")
+        
+                def handle_update_task_status(task_id, status):
+                    logging.debug(f"Updating task status for task {task_id} to {status}")
+                    result = update_task_status(task_id, status)
+                    logging.debug(f"Update task status result: {result}")
+                    return result
+        
+                update_task_status_button.click(handle_update_task_status, inputs=[update_task_id, update_task_status_input], outputs=update_task_status_output)
+        
+                # Get Task Progress
+                get_progress_task_id = gr.Number(label="Task ID")
+                get_progress_button = gr.Button(value="Get Task Progress")
+                get_progress_output = gr.JSON(label="Task Progress Output")
+        
+                def handle_get_task_progress(task_id):
+                    logging.debug(f"Fetching task progress for task {task_id}")
+                    result = get_task_progress(task_id)
+                    logging.debug(f"Task progress: {result}")
+                    return result
+        
+                get_progress_button.click(handle_get_task_progress, inputs=get_progress_task_id, outputs=get_progress_output)
+        
+                # Update Task Progress
+                update_progress_task_id = gr.Number(label="Task ID")
+                update_progress_text = gr.Textbox(label="Update Text")
+                update_progress_button = gr.Button(value="Update Task Progress")
+                update_progress_output = gr.Textbox(label="Update Task Progress Output")
+        
+                def handle_update_task_progress(task_id, update_text):
+                    logging.debug(f"Updating task progress for task {task_id} with text: {update_text}")
+                    result = update_task_progress(task_id, update_text)
+                    logging.debug(f"Update task progress result: {result}")
+                    return result
+        
+                update_progress_button.click(handle_update_task_progress, inputs=[update_progress_task_id, update_progress_text], outputs=update_progress_output)
+
+                # Upload Task Result
+                upload_result_task_id = gr.Number(label="Task ID")
+                upload_result_file = gr.File(label="Task Result")
+                upload_result_button = gr.Button(value="Upload Task Result")
+                upload_result_output = gr.Textbox(label="Upload Task Result Output")
+        
+                def handle_upload_task_result(task_id, result_file):
+                    logging.debug(f"Uploading task result for task {task_id}")
+                    result = upload_task_result(task_id, result_file)
+                    logging.debug(f"Upload task result: {result}")
+                    return result
+        
+                upload_result_button.click(handle_upload_task_result, inputs=[upload_result_task_id, upload_result_file], outputs=upload_result_output)
+            
+            with gr.TabItem("User Management"):
+                gr.Markdown("Manage user profiles.")
+                
+
+                # Add User
+                level_options = ["Academy Student", "Genin Requester", "Chunin Requester", "Jonin Requester", "Kage Requester"]
+                trust_score_options = list(range(1, 11))  # Generates numbers from 1 to 10
+                
+                # Add User
+                add_user_name = gr.Textbox(label="Name")
+                add_user_profile_name = gr.Textbox(label="Profile Name")
+                add_user_about = gr.Textbox(label="About")
+                add_user_level = gr.Dropdown(label="Level", choices=level_options)
+                add_user_trust_score = gr.Dropdown(label="Trust Score", choices=trust_score_options)
+                add_user_online_status = gr.Checkbox(label="Online Status")
+                add_user_profile_pic = gr.File(label="Profile Picture")
+                add_user_button = gr.Button(value="Add User")
+                add_user_output = gr.Textbox(label="Add User Output")
+        
+                def handle_add_user(name, profile_name, about, trust_score, online_status, profile_pic_file, level):
+                    logging.debug(f"Adding user: {name}")
+                    result = add_user(name, profile_name, about, trust_score, online_status, profile_pic_file, level)
+                    logging.debug(f"Add user result: {result}")
+                    return result
+        
+                add_user_button.click(handle_add_user, inputs=[
+                    add_user_name, add_user_profile_name, add_user_about,
+                    add_user_trust_score, add_user_online_status,
+                    add_user_profile_pic, add_user_level], outputs=add_user_output)
+
+                # Fetch Users
+                fetch_users_button = gr.Button(value="Fetch Users")
+                fetch_users_output = gr.JSON(label="Fetch Users Output")
+
+                def handle_fetch_users():
+                    logging.debug("Fetching all users")
+                    result = fetch_users()
+                    logging.debug(f"Fetched users: {result}")
+                    return result
+        
+                fetch_users_button.click(handle_fetch_users, outputs=fetch_users_output)
+
+                # Update User Online Status
+                update_online_status_user_id = gr.Number(label="User ID")
+                update_online_status = gr.Checkbox(label="Online Status")
+                update_online_status_button = gr.Button(value="Update Online Status")
+                update_online_status_output = gr.Textbox(label="Update Online Status Output")
+        
+                def handle_update_online_status(user_id, online_status):
+                    logging.debug(f"Updating online status for user {user_id} to {online_status}")
+                    result = update_user_online_status(user_id, online_status)
+                    logging.debug(f"Update online status result: {result}")
+                    return result
+        
+                update_online_status_button.click(handle_update_online_status, inputs=[update_online_status_user_id, update_online_status], outputs=update_online_status_output)
+        
+                # Update User Profile Picture
+                update_profile_pic_user_id = gr.Number(label="User ID")
+                update_profile_pic_file = gr.File(label="Profile Picture")
+                update_profile_pic_button = gr.Button(value="Update Profile Picture")
+                update_profile_pic_output = gr.Textbox(label="Update Profile Picture Output")
+        
+                def handle_update_profile_pic(user_id, profile_pic_file):
+                    logging.debug(f"Updating profile picture for user {user_id}")
+                    result = update_user_profile_pic(user_id, profile_pic_file)
+                    logging.debug(f"Update profile picture result: {result}")
+                    return result
+        
+                update_profile_pic_button.click(handle_update_profile_pic, inputs=[update_profile_pic_user_id, update_profile_pic_file], outputs=update_profile_pic_output)
+
+            with gr.TabItem("Gig Worker Management"):
+                gr.Markdown("Manage gig worker profiles.")
+                
+                level_options = ["Genin", "Chunin", "Jonin", "ANBU", "Kage", "Sage"]
+                rating_score_options = list(range(1, 6))
+                trust_score_options = list(range(1, 11))  # Generates numbers from 1 to 10
+                # Add Gig Worker
+                add_worker_name = gr.Textbox(label="Name")
+                add_worker_about = gr.Textbox(label="About")
+                add_worker_skills = gr.Textbox(label="Skills (comma-separated)")
+                add_worker_rating = gr.Dropdown(label="Rating", choices=rating_score_options)
+                add_worker_trust_score = gr.Dropdown(label="Trust Score", choices=trust_score_options)
+                add_worker_ninja_level = gr.Dropdown(label="Ninja Level", choices=level_options)
+                add_worker_task_experience = gr.Number(label="Task Experience")
+                add_worker_online_status = gr.Checkbox(label="Online Status")
+                add_worker_profile_pic = gr.File(label="Profile Picture")
+                add_worker_button = gr.Button(value="Add Worker")
+                add_worker_output = gr.Textbox(label="Add Worker Output")
+        
+                def handle_add_worker(name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file):
+                    skills_list = skills.split(",") if skills else []
+                    logging.debug(f"Adding gig worker: {name}")
+                    result = add_gig_worker(name, about, skills_list, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file)
+                    logging.debug(f"Add gig worker result: {result}")
+                    return result
+        
+                add_worker_button.click(handle_add_worker, inputs=[add_worker_name, add_worker_about, add_worker_skills, add_worker_rating, add_worker_trust_score, add_worker_ninja_level, add_worker_task_experience, add_worker_online_status, add_worker_profile_pic], outputs=add_worker_output)
+        
+                # Update Gig Worker
+                update_worker_id = gr.Number(label="Worker ID")
+                update_worker_name = gr.Textbox(label="Name")
+                update_worker_about = gr.Textbox(label="About")
+                update_worker_skills = gr.Textbox(label="Skills (comma-separated)")
+                update_worker_rating = gr.Number(label="Rating")
+                update_worker_trust_score = gr.Number(label="Trust Score")
+                update_worker_ninja_level = gr.Number(label="Ninja Level")
+                update_worker_task_experience = gr.Number(label="Task Experience")
+                update_worker_online_status = gr.Checkbox(label="Online Status")
+                update_worker_profile_pic = gr.File(label="Profile Picture")
+                update_worker_button = gr.Button(value="Update Worker")
+                update_worker_output = gr.Textbox(label="Update Worker Output")
+        
+                def handle_update_worker(worker_id, name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file):
+                    skills_list = skills.split(",") if skills else []
+                    logging.debug(f"Updating gig worker: {worker_id}")
+                    result = update_gig_worker(worker_id, name, about, skills_list, rating, trust_score, ninja_level, task_experience, online_status, profile_pic_file)
+                    logging.debug(f"Update gig worker result: {result}")
+                    return result
+        
+                update_worker_button.click(handle_update_worker, inputs=[update_worker_id, update_worker_name, update_worker_about, update_worker_skills, update_worker_rating, update_worker_trust_score, update_worker_ninja_level, update_worker_task_experience, update_worker_online_status, update_worker_profile_pic], outputs=update_worker_output)
+        
+                # Fetch Gig Worker
+                fetch_worker_id = gr.Number(label="Worker ID")
+                fetch_worker_button = gr.Button(value="Fetch Worker")
+                fetch_worker_output = gr.JSON(label="Fetch Worker Output")
+        
+                def handle_fetch_worker(worker_id):
+                    logging.debug(f"Fetching gig worker: {worker_id}")
+                    result = fetch_gig_worker(worker_id)
+                    logging.debug(f"Fetched gig worker: {result}")
+                    return result
+        
+                fetch_worker_button.click(handle_fetch_worker, inputs=fetch_worker_id, outputs=fetch_worker_output)
+            
+            with gr.TabItem("Payment Management"):
+                gr.Markdown("Manage payments using Stripe.")
+                
+                payment_amount = gr.Number(label="Amount")
+                payment_currency = gr.Textbox(label="Currency", value="usd")
+                payment_success_url = gr.Textbox(label="Success URL")
+                payment_cancel_url = gr.Textbox(label="Cancel URL")
+                create_payment_button = gr.Button(value="Create Payment Session")
+                payment_session_output = gr.Textbox(label="Payment Session URL")
+        
+                def handle_create_payment_session(amount, currency, success_url, cancel_url):
+                    logging.debug(f"Creating payment session for amount: {amount} {currency}")
+                    result = create_payment_session(amount, currency, success_url, cancel_url)
+                    logging.debug(f"Created payment session: {result}")
+                    return result
+        
+                create_payment_button.click(handle_create_payment_session, inputs=[payment_amount, payment_currency, payment_success_url, payment_cancel_url], outputs=payment_session_output)
+    
+    iface.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)), share=True)
+
+
+
+if __name__ == "__main__":
+    gradio_interface()

insertGigWorkersIntoDB.py

@@ -0,0 +1,77 @@
+import csv
+import psycopg2
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get database connection
+def get_database_connection():
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        raise ValueError("DATABASE_URL is not set in environment variables.")
+    return psycopg2.connect(database_url)
+
+# Verify data
+def verify_data(row):
+    # Check if necessary fields are present
+    required_fields = ["Name", "About (description after screening)", "Skills (after screening)", "Rating", "Trust Score", "Ninja level(chunin ,join ,kage )", "Task Experience", "Online or not or schedule at this time each day"]
+    for field in required_fields:
+        if field not in row or not row[field]:
+            return False
+    
+    # Check if rating and trust_score are within valid ranges
+    try:
+        rating = float(row["Rating"])
+        if rating < 0 or rating > 5:
+            return False
+    except ValueError:
+        return False
+    
+    try:
+        trust_score = int(row["Trust Score"])
+        if trust_score < 0 or trust_score > 100:
+            return False
+    except ValueError:
+        return False
+    
+    return True
+
+# Insert data into database
+def insert_data(row):
+    skills_array = row["Skills (after screening)"].split(",")
+    skills_array = [skill.strip() for skill in skills_array]
+    ninja_level = row["Ninja level(chunin ,join ,kage )"]
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO gig_workers (name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+                RETURNING id
+            """, (row["Name"], row["About (description after screening)"], skills_array, row["Rating"], row["Trust Score"], ninja_level, row["Task Experience"], row["Online or not or schedule at this time each day"], ''))
+            worker_id = curs.fetchone()[0]
+            conn.commit()
+        print(f"Gig worker added with ID: {worker_id}")
+    except Exception as e:
+        conn.rollback()
+        print(f"Error adding gig worker: {e}")
+    finally:
+        conn.close()
+
+# Main function
+def main():
+    file_path = '/Users/vishal/WORK/DATA_GEN/synthetic_profiles_1000.csv'
+    
+    with open(file_path, newline='', encoding='utf-8') as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            if verify_data(row):
+                insert_data(row)
+            else:
+                print(f"Invalid data: {row}")
+
+if __name__ == "__main__":
+    main()

insertUsersIntoDB.py

@@ -0,0 +1,59 @@
+import psycopg2
+import json
+from faker import Faker
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Set up Faker for generating fake user data
+fake = Faker()
+
+# Get database connection
+def get_database_connection():
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        raise ValueError("DATABASE_URL is not set in environment variables.")
+    return psycopg2.connect(database_url)
+
+# Function to insert a single user into the database
+def insert_user(name, profile_name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic, is_pro):
+    skills_json = json.dumps(skills)
+    
+    conn = get_database_connection()
+    try:
+        with conn.cursor() as curs:
+            curs.execute("""
+                INSERT INTO users (name, profile_name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic, is_pro)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+                RETURNING user_id
+            """, (name, profile_name, about, skills_json, rating, trust_score, ninja_level, task_experience, online_status, profile_pic, is_pro))
+            user_id = curs.fetchone()[0]
+            conn.commit()
+        print(f"User added with ID: {user_id}")
+    except Exception as e:
+        conn.rollback()
+        print(f"Error adding user: {e}")
+    finally:
+        conn.close()
+
+# Function to generate and insert 5 unique users
+def insert_unique_users():
+    for _ in range(5):
+        name = fake.name()
+        profile_name = fake.user_name()
+        about = fake.text()
+        skills = [fake.job() for _ in range(5)]
+        rating = round(min(fake.random.uniform(0, 5.00), 5.00), 2)  # Ensure rating is within 0.00 to 5.00
+        trust_score = round(min(fake.random.uniform(0, 5.00), 5.00), 2)  # Ensure trust_score is within 0.00 to 5.00
+        ninja_level = fake.random.randint(1, 10)
+        task_experience = fake.random.randint(0, 1000)
+        online_status = fake.boolean()
+        profile_pic = fake.image_url()
+        is_pro = fake.boolean()
+        
+        insert_user(name, profile_name, about, skills, rating, trust_score, ninja_level, task_experience, online_status, profile_pic, is_pro)
+
+if __name__ == "__main__":
+    insert_unique_users()

requirements.txt

@@ -0,0 +1,113 @@
+flask>=2.0.3
+python-dotenv>=0.19.2
+authlib>=1.0
+requests>=2.27.1
+aiofiles==23.2.1
+aiohttp==3.9.5
+aiosignal==1.3.1
+alpha-vantage==2.3.1
+altair==5.3.0
+annotated-types==0.6.0
+anyio==4.3.0
+attrs==23.2.0
+beautifulsoup4==4.12.3
+cachetools==5.3.3
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+cloudscraper==1.2.71
+contourpy==1.2.1
+cycler==0.12.1
+dnspython==2.6.1
+email_validator==2.1.1
+Faker==25.2.0
+fastapi==0.111.0
+fastapi-cli==0.0.3
+ffmpy==0.3.2
+filelock==3.14.0
+fonttools==4.51.0
+frozenlist==1.4.1
+fsspec==2024.3.1
+google-ai-generativelanguage==0.6.3
+google-api-core==2.19.0
+google-api-python-client==2.129.0
+google-auth==2.29.0
+google-auth-httplib2==0.2.0
+google-generativeai==0.5.3
+googleapis-common-protos==1.63.0
+gradio==4.31.2
+gradio_client==0.16.3
+grpcio==1.63.0
+grpcio-status==1.62.2
+h11==0.14.0
+httpcore==1.0.5
+httplib2==0.22.0
+httptools==0.6.1
+httpx==0.27.0
+huggingface-hub==0.23.0
+idna==3.7
+importlib_resources==6.4.0
+Jinja2==3.1.4
+jsonschema==4.22.0
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.8.4
+mdurl==0.1.2
+multidict==6.0.5
+numpy==1.26.4
+oauthlib==3.2.2
+orjson==3.10.3
+packaging==24.0
+pandas==2.2.2
+pillow==10.3.0
+praw==7.7.1
+prawcore==2.4.0
+proto-plus==1.23.0
+protobuf==4.25.3
+psycopg2==2.9.9
+pyasn1==0.6.0
+pyasn1_modules==0.4.0
+pydantic==2.7.1
+pydantic_core==2.18.2
+pydub==0.25.1
+Pygments==2.18.0
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.1
+referencing==0.35.1
+requests==2.31.0
+requests-oauthlib==1.3.1
+requests-toolbelt==1.0.0
+rich==13.7.1
+rpds-py==0.18.1
+rsa==4.9
+ruff==0.4.4
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+soupsieve==2.5
+starlette==0.37.2
+stripe==9.8.0
+tomlkit==0.12.0
+toolz==0.12.1
+tqdm==4.66.4
+tweepy==4.14.0
+typer==0.12.3
+typing_extensions==4.11.0
+tzdata==2024.1
+ujson==5.10.0
+update-checker==0.18.0
+uritemplate==4.1.1
+urllib3==2.2.1
+uvicorn==0.29.0
+uvloop==0.19.0
+watchfiles==0.21.0
+websocket-client==1.8.0
+websockets==11.0.3
+yarl==1.9.4

venv/.gitignore

@@ -0,0 +1,2 @@
+# created by virtualenv automatically
+*

venv/bin/activate

@@ -0,0 +1,87 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+
+if [ "${BASH_SOURCE-}" = "$0" ]; then
+    echo "You must source this script: \$ source $0" >&2
+    exit 33
+fi
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1 || true
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # The hash command must be called to get it to forget past
+    # commands. Without forgetting past commands the $PATH changes
+    # we made may not be respected
+    hash -r 2>/dev/null
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV='/Users/vishal/WORK/TaskNinja/venv'
+if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then
+    VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+if [ "x" != x ] ; then
+    VIRTUAL_ENV_PROMPT=""
+else
+    VIRTUAL_ENV_PROMPT=$(basename "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1-}"
+    PS1="(${VIRTUAL_ENV_PROMPT}) ${PS1-}"
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# The hash command must be called to get it to forget past
+# commands. Without forgetting past commands the $PATH changes
+# we made may not be respected
+hash -r 2>/dev/null || true

venv/bin/activate.csh

@@ -0,0 +1,55 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+
+set newline='\
+'
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV '/Users/vishal/WORK/TaskNinja/venv'
+
+set _OLD_VIRTUAL_PATH="$PATH:q"
+setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q"
+
+
+
+if ('' != "") then
+    setenv VIRTUAL_ENV_PROMPT ''
+else
+    setenv VIRTUAL_ENV_PROMPT "$VIRTUAL_ENV:t:q"
+endif
+
+if ( $?VIRTUAL_ENV_DISABLE_PROMPT ) then
+    if ( $VIRTUAL_ENV_DISABLE_PROMPT == "" ) then
+        set do_prompt = "1"
+    else
+        set do_prompt = "0"
+    endif
+else
+    set do_prompt = "1"
+endif
+
+if ( $do_prompt == "1" ) then
+    # Could be in a non-interactive environment,
+    # in which case, $prompt is undefined and we wouldn't
+    # care about the prompt anyway.
+    if ( $?prompt ) then
+        set _OLD_VIRTUAL_PROMPT="$prompt:q"
+        if ( "$prompt:q" =~ *"$newline:q"* ) then
+            :
+        else
+            set prompt = '('"$VIRTUAL_ENV_PROMPT:q"') '"$prompt:q"
+        endif
+    endif
+endif
+
+unset env_name
+unset do_prompt
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,103 @@
+# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*.
+# Do not run it directly.
+
+function _bashify_path -d "Converts a fish path to something bash can recognize"
+    set fishy_path $argv
+    set bashy_path $fishy_path[1]
+    for path_part in $fishy_path[2..-1]
+        set bashy_path "$bashy_path:$path_part"
+    end
+    echo $bashy_path
+end
+
+function _fishify_path -d "Converts a bash path to something fish can recognize"
+    echo $argv | tr ':' '\n'
+end
+
+function deactivate -d 'Exit virtualenv mode and return to the normal environment.'
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        # https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+        if test (echo $FISH_VERSION | head -c 1) -lt 3
+            set -gx PATH (_fishify_path "$_OLD_VIRTUAL_PATH")
+        else
+            set -gx PATH $_OLD_VIRTUAL_PATH
+        end
+        set -e _OLD_VIRTUAL_PATH
+    end
+
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME "$_OLD_VIRTUAL_PYTHONHOME"
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+       and functions -q _old_fish_prompt
+        # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`.
+        set -l fish_function_path
+
+        # Erase virtualenv's `fish_prompt` and restore the original.
+        functions -e fish_prompt
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+
+    if test "$argv[1]" != 'nondestructive'
+        # Self-destruct!
+        functions -e pydoc
+        functions -e deactivate
+        functions -e _bashify_path
+        functions -e _fishify_path
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV '/Users/vishal/WORK/TaskNinja/venv'
+
+# https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+if test (echo $FISH_VERSION | head -c 1) -lt 3
+    set -gx _OLD_VIRTUAL_PATH (_bashify_path $PATH)
+else
+    set -gx _OLD_VIRTUAL_PATH $PATH
+end
+set -gx PATH "$VIRTUAL_ENV"'/bin' $PATH
+
+# Prompt override provided?
+# If not, just use the environment name.
+if test -n ''
+    set -gx VIRTUAL_ENV_PROMPT ''
+else
+    set -gx VIRTUAL_ENV_PROMPT (basename "$VIRTUAL_ENV")
+end
+
+# Unset `$PYTHONHOME` if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+function pydoc
+    python -m pydoc $argv
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # Copy the current `fish_prompt` function as `_old_fish_prompt`.
+    functions -c fish_prompt _old_fish_prompt
+
+    function fish_prompt
+        # Run the user's prompt first; it might depend on (pipe)status.
+        set -l prompt (_old_fish_prompt)
+
+        printf '(%s) ' $VIRTUAL_ENV_PROMPT
+
+        string join -- \n $prompt # handle multi-line prompts
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

venv/bin/activate.nu

@@ -0,0 +1,96 @@
+# virtualenv activation module
+# Activate with `overlay use activate.nu`
+# Deactivate with `deactivate`, as usual
+#
+# To customize the overlay name, you can call `overlay use activate.nu as foo`,
+# but then simply `deactivate` won't work because it is just an alias to hide
+# the "activate" overlay. You'd need to call `overlay hide foo` manually.
+
+export-env {
+    def is-string [x] {
+        ($x | describe) == 'string'
+    }
+
+    def has-env [...names] {
+        $names | each {|n|
+            $n in $env
+        } | all {|i| $i == true}
+    }
+
+    # Emulates a `test -z`, but btter as it handles e.g 'false'
+    def is-env-true [name: string] {
+      if (has-env $name) {
+        # Try to parse 'true', '0', '1', and fail if not convertible
+        let parsed = (do -i { $env | get $name | into bool })
+        if ($parsed | describe) == 'bool' {
+          $parsed
+        } else {
+          not ($env | get -i $name | is-empty)
+        }
+      } else {
+        false
+      }
+    }
+
+    let virtual_env = '/Users/vishal/WORK/TaskNinja/venv'
+    let bin = 'bin'
+
+    let is_windows = ($nu.os-info.family) == 'windows'
+    let path_name = (if (has-env 'Path') {
+            'Path'
+        } else {
+            'PATH'
+        }
+    )
+
+    let venv_path = ([$virtual_env $bin] | path join)
+    let new_path = ($env | get $path_name | prepend $venv_path)
+
+    # If there is no default prompt, then use the env name instead
+    let virtual_env_prompt = (if ('' | is-empty) {
+        ($virtual_env | path basename)
+    } else {
+        ''
+    })
+
+    let new_env = {
+        $path_name         : $new_path
+        VIRTUAL_ENV        : $virtual_env
+        VIRTUAL_ENV_PROMPT : $virtual_env_prompt
+    }
+
+    let new_env = (if (is-env-true 'VIRTUAL_ENV_DISABLE_PROMPT') {
+      $new_env
+    } else {
+      # Creating the new prompt for the session
+      let virtual_prefix = $'(char lparen)($virtual_env_prompt)(char rparen) '
+
+      # Back up the old prompt builder
+      let old_prompt_command = (if (has-env 'PROMPT_COMMAND') {
+              $env.PROMPT_COMMAND
+          } else {
+              ''
+        })
+
+      let new_prompt = (if (has-env 'PROMPT_COMMAND') {
+          if 'closure' in ($old_prompt_command | describe) {
+              {|| $'($virtual_prefix)(do $old_prompt_command)' }
+          } else {
+              {|| $'($virtual_prefix)($old_prompt_command)' }
+          }
+      } else {
+          {|| $'($virtual_prefix)' }
+      })
+
+      $new_env | merge {
+        PROMPT_COMMAND      : $new_prompt
+        VIRTUAL_PREFIX      : $virtual_prefix
+      }
+    })
+
+    # Environment variables that will be loaded as the virtual env
+    load-env $new_env
+}
+
+export alias pydoc = python -m pydoc
+export alias deactivate = overlay hide activate

venv/bin/activate.ps1

@@ -0,0 +1,61 @@
+$script:THIS_PATH = $myinvocation.mycommand.path
+$script:BASE_DIR = Split-Path (Resolve-Path "$THIS_PATH/..") -Parent
+
+function global:deactivate([switch] $NonDestructive) {
+    if (Test-Path variable:_OLD_VIRTUAL_PATH) {
+        $env:PATH = $variable:_OLD_VIRTUAL_PATH
+        Remove-Variable "_OLD_VIRTUAL_PATH" -Scope global
+    }
+
+    if (Test-Path function:_old_virtual_prompt) {
+        $function:prompt = $function:_old_virtual_prompt
+        Remove-Item function:\_old_virtual_prompt
+    }
+
+    if ($env:VIRTUAL_ENV) {
+        Remove-Item env:VIRTUAL_ENV -ErrorAction SilentlyContinue
+    }
+
+    if ($env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item env:VIRTUAL_ENV_PROMPT -ErrorAction SilentlyContinue
+    }
+
+    if (!$NonDestructive) {
+        # Self destruct!
+        Remove-Item function:deactivate
+        Remove-Item function:pydoc
+    }
+}
+
+function global:pydoc {
+    python -m pydoc $args
+}
+
+# unset irrelevant variables
+deactivate -nondestructive
+
+$VIRTUAL_ENV = $BASE_DIR
+$env:VIRTUAL_ENV = $VIRTUAL_ENV
+
+if ("" -ne "") {
+    $env:VIRTUAL_ENV_PROMPT = ""
+}
+else {
+    $env:VIRTUAL_ENV_PROMPT = $( Split-Path $env:VIRTUAL_ENV -Leaf )
+}
+
+New-Variable -Scope global -Name _OLD_VIRTUAL_PATH -Value $env:PATH
+
+$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH
+if (!$env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    function global:_old_virtual_prompt {
+        ""
+    }
+    $function:_old_virtual_prompt = $function:prompt
+
+    function global:prompt {
+        # Add the custom prefix to the existing prompt
+        $previous_prompt_value = & $function:_old_virtual_prompt
+        ("(" + $env:VIRTUAL_ENV_PROMPT + ") " + $previous_prompt_value)
+    }
+}

venv/bin/activate_this.py

@@ -0,0 +1,38 @@
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.11/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path.decode("utf-8") if "" else path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

venv/bin/dotenv

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from dotenv.__main__ import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

venv/bin/email_validator

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from email_validator.__main__ import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/f2py

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/faker

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from faker.cli import execute_from_command_line
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(execute_from_command_line())

venv/bin/fastapi

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fastapi_cli.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/flask

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from flask.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/fonttools

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fontTools.__main__ import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/gradio

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

venv/bin/httpx

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/huggingface-cli

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/jsonschema

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from jsonschema.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/markdown-it

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from markdown_it.cli.parse import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/normalizer

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer.cli import cli_detect
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli_detect())

venv/bin/pip

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip-3.11

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3.11

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyftmerge

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fontTools.merge import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyftsubset

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fontTools.subset import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pygmentize

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pygments.cmdline import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyrsa-decrypt

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import decrypt
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(decrypt())

venv/bin/pyrsa-encrypt

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import encrypt
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(encrypt())

venv/bin/pyrsa-keygen

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import keygen
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(keygen())

venv/bin/pyrsa-priv2pub

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.util import private_to_public
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(private_to_public())

venv/bin/pyrsa-sign

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import sign
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(sign())

venv/bin/pyrsa-verify

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import verify
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(verify())

venv/bin/ruff

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

venv/bin/streamlit

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from streamlit.web.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/streamlit.cmd

@@ -0,0 +1,16 @@
+rem Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+rem
+rem Licensed under the Apache License, Version 2.0 (the "License");
+rem you may not use this file except in compliance with the License.
+rem You may obtain a copy of the License at
+rem
+rem     http://www.apache.org/licenses/LICENSE-2.0
+rem
+rem Unless required by applicable law or agreed to in writing, software
+rem distributed under the License is distributed on an "AS IS" BASIS,
+rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+rem See the License for the specific language governing permissions and
+rem limitations under the License.
+
+@echo OFF
+python -m streamlit %*

venv/bin/tqdm

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tqdm.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/ttx

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fontTools.ttx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/typer

@@ -0,0 +1,8 @@
+#!/Users/vishal/WORK/TaskNinja/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from typer.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())