# Project export: Enterview

This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small.

## Project metadata

- Hackathon: Cal Hacks 10.0
- Tagline: Interview training app that provides feedback based on the perceived emotions of the interviewee.
- Devpost: https://devpost.com/software/enterview
- GitHub: https://github.com/kavehhm/enterview.git
- Video: https://www.youtube.com/embed/zlf7CpujidY?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent
- Team: 3 GitHub contributor(s) — wuavonft (26 commits), Peyton Duong (17 commits), Solomon Mithra (1 commits)

## Devpost submission (written by the team)

### Inspiration

In today's fast-paced world, effective communication is more crucial than ever. Whether it's acing a job interview, delivering a compelling speech, or simply making a persuasive argument, the way we present ourselves can make all the difference. However, the lack of real-time, comprehensive feedback often hinders individuals from realizing their full potential. This inspired us to create Enterview, a tool designed to provide immediate, actionable insights into your emotional and verbal delivery.

### What it does

Enterview is an app that allows users to upload or record a video of themselves speaking. Using Hume AI developer tool, the app analyzes the user's facial expressions and voice to identify various emotions. It then processes this data and serves it as a prompt to OpenAI, which generates personalized feedback. The app also provides a detailed breakdown of the user's emotional shifts, tonal shifts, dominant emotions at various points, and other key metrics. This comprehensive feedback aims to help users identify areas for improvement, whether they are preparing for job interviews, public speaking, or any other situation requiring effective communication.

### How we built it

We used Next.js for full-stack development and used Flask, additionally, for back-end. We then integrated it with Hume's emotion and text recognition API and OpenAI's GPT-3. The architecture is designed to first record and send the video data to Hume, receive the emotion and text metrics on the server side, and then forward this processed data to OpenAI for generating insightful feedback.

### Challenges we ran into

API Integration: Ensuring seamless interaction between Hume and OpenAI was initially challenging due to data transfer and formatting issues. Accuracy: We found that emotion recognition could include large amounts of data that may not be useful to the user, which led us to explore ways to define certain interpretations of the data and try and manipulate it in a way that would give us the best possible feedback.

### Accomplishments we're proud of

Holistic Feedback: Successfully integrating Hume and OpenAI to provide a 360-degree view of a user's performance. User Experience: Creating an intuitive, user-friendly interface that even those who are not tech-savvy can navigate easily.

### What we learned

Interdisciplinary Integration: The importance of combining different technologies to create a more comprehensive solution. Data Processing: How to determine the usefulness of certain types of data and interpret them in a more efficient way. Ethical Considerations: TODO

### What's next

Real-Time Analysis: We plan to introduce a real-time feedback feature that provides insights as the user is speaking. Feedback customization Features: Adding options to check for specific types of emotions, and tones and make the feedback more customizable. Expanded Use Cases: We aim to extend the app's utility to other domains like therapy and education.

## README (from the GitHub repository)

## Inspiration
In today's fast-paced world, effective communication is more crucial than ever. Whether it's acing a job interview, delivering a compelling speech, or simply making a persuasive argument, the way we present ourselves can make all the difference. However, the lack of real-time, comprehensive feedback often hinders individuals from realizing their full potential. This inspired us to create Enterview, a tool designed to provide immediate, actionable insights into your emotional and verbal delivery.

## What it does
Enterview is an app that allows users to upload or record a video of themselves speaking. Using Hume AI developer tool, the app analyzes the user's facial expressions and voice to identify various emotions. It then processes this data and serves it as a prompt to OpenAI, which generates personalized feedback. The app also provides a detailed breakdown of the user's emotional shifts, tonal shifts, dominant emotions at various points, and other key metrics. This comprehensive feedback aims to help users identify areas for improvement, whether they are preparing for job interviews, public speaking, or any other situation requiring effective communication.

## How we built it
We used Next.js for full-stack development and used Flask, additionally, for back-end. We then integrated it with Hume's emotion and text recognition API and OpenAI's GPT-3. The architecture is designed to first record and send the video data to Hume, receive the emotion and text metrics on the server side, and then forward this processed data to OpenAI for generating insightful feedback.

## Challenges we ran into
 - API Integration: Ensuring seamless interaction between Hume and OpenAI was initially challenging due to data transfer and formatting issues.
 - Accuracy: We found that emotion recognition could include large amounts of data that may not be useful to the user, which led us to explore ways to define certain interpretations of the data and try and manipulate it in a way that would give us the best possible feedback.

## Accomplishments that we're proud of
 - Holistic Feedback: Successfully integrating Hume and OpenAI to provide a 360-degree view of a user's performance.
 - User Experience: Creating an intuitive, user-friendly interface that even those who are not tech-savvy can navigate easily.
## What we learned
 - Interdisciplinary Integration: The importance of combining different technologies to create a more comprehensive solution.
 - Data Processing: How to determine the usefulness of certain types of data and interpret them in a more efficient way.

## What's next for Enterview
 - Real-Time Analysis: We plan to introduce a real-time feedback feature that provides insights as the user is speaking.
 - Feedback customization Features: Adding options to check for specific types of emotions, and tones and make the feedback more customizable.
 - Expanded Use Cases: We aim to extend the app's utility to other domains like therapy and education.


## Detected evidence (automated analysis)

Indexed codebase: 21 recognized source files, 41 KB.
- CSS (language) — detected in the code
- Flask (technology) — detected in the code
- JavaScript (language) — detected in the code
- Next.js (technology) — detected in the code
- OpenAI (technology) — detected in the code
- Python (language) — detected in the code
- React (technology) — detected in the code
- Tailwind CSS (technology) — detected in the code

## Codebase structure (from repository index)

### Files (26 of 26)

```
.eslintrc.json
.gitignore
flask_api/app.py
flask_api/old.py
flask_api/requirements.txt
jsconfig.json
next.config.js
package.json
postcss.config.js
README.md
src/components/Camera.js
src/components/form.js
src/components/Record.js
src/components/RecordView.js
src/components/results.js
src/components/Step2.js
src/components/Step3.js
src/Context.js
src/pages/_app.js
src/pages/_document.js
src/pages/api/hello.js
src/pages/index.js
src/pages/test.js
src/pages/videos.js
src/styles/globals.css
tailwind.config.js
```

### Dependencies

- flask_api/requirements.txt: asgiref@==3.7.2, blinker@==1.6.3, certifi@==2023.7.22, charset-normalizer@==3.3.1, click@==8.1.7, colorama@==0.4.6, Flask@==3.0.0, Flask-Cors@==4.0.0, hume@==0.4.1, idna@==3.4, imageio-ffmpeg@==0.4.9, itsdangerous@==2.1.2, Jinja2@==3.1.2, MarkupSafe@==2.1.3, requests@==2.31.0, setuptools@==68.2.2, typing_extensions@==4.8.0, urllib3@==2.0.7, websockets@==10.4, Werkzeug@==3.0.1
- package.json: @heroicons/react@^2.0.18, @mdn/browser-compat-data@^5.3.27, @tailwindcss/forms@^0.5.6, autoprefixer@^10, axios@^1.6.0, eslint@^8, eslint-config-next@13.5.6, next@13.5.6, openai@^4.14.1, postcss@^8, react@^18, react-dom@^18, react-hot-toast@^2.4.1, react-media-recorder@^1.6.5, tailwindcss@^3

### Recent commits (newest first)

- Update README.md
- ain
- ain
- ain
- ain
- new json
- ain
- Create requirements.txt
- video corruption fixed
- Merge branch 'main' of https://github.com/kavehhm/enterview
- Merge branch 'main' of https://github.com/kavehhm/enterview
- ain
- ain
- ain
- sdk
- ain
- video upload
- ain
- ain
- ain

## Key source files (fetched from GitHub, selected and truncated for size)

### package.json

```
{
  "name": "humenext",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "next lint"
  },
  "dependencies": {
    "@heroicons/react": "^2.0.18",
    "@mdn/browser-compat-data": "^5.3.27",
    "axios": "^1.6.0",
    "next": "13.5.6",
    "openai": "^4.14.1",
    "react": "^18",
    "react-dom": "^18",
    "react-hot-toast": "^2.4.1",
    "react-media-recorder": "^1.6.5"
  },
  "devDependencies": {
    "@tailwindcss/forms": "^0.5.6",
    "autoprefixer": "^10",
    "eslint": "^8",
    "eslint-config-next": "13.5.6",
    "postcss": "^8",
    "tailwindcss": "^3"
  }
}

```

### flask_api/requirements.txt

```
asgiref==3.7.2
blinker==1.6.3
certifi==2023.7.22
charset-normalizer==3.3.1
click==8.1.7
colorama==0.4.6
Flask==3.0.0
Flask-Cors==4.0.0
hume==0.4.1
idna==3.4
imageio-ffmpeg==0.4.9
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
requests==2.31.0
setuptools==68.2.2
typing_extensions==4.8.0
urllib3==2.0.7
websockets==10.4
Werkzeug==3.0.1
```

### flask_api/app.py

```python
from flask import Flask, request, session, jsonify
from hume import HumeBatchClient
from hume.models.config import LanguageConfig
from hume.models.config import FaceConfig
from hume.models.config import BurstConfig
from hume.models.config import ProsodyConfig
import requests
import json
from flask_cors import CORS,cross_origin
import imageio_ffmpeg as ffmpeg
import os
import subprocess

app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "http://localhost:3000"}})
#CORS(app)

def find_stretches(json_data):
    print("entered")
    stretches = []
    current_stretch = []
    last_dominant = None

    predictions = json_data[0]['results']['predictions'][0]['models']['face']['grouped_predictions'][0]['predictions']
    for pred in predictions:
        time = pred['time']
        dominant_emotions = find_dominant_emotions(pred['emotions'])

        if last_dominant is None:
            last_dominant = dominant_emotions
            current_stretch.append((time, dominant_emotions))
        else:
            common_emotions = last_dominant.intersection(dominant_emotions)
            if common_emotions:
                current_stretch.append((time, dominant_emotions))
                last_dominant = common_emotions
            else:
                if len(current_stretch) >= 5:
                    print("ebtered len")
                    stretches.append({
                        'emotions': list(last_dominant),
                        'first_time': current_stretch[0][0],
                        'last_time': current_stretch[-1][0],
                        'length': current_stretch[-1][0] - current_stretch[0][0]
                    })
                current_stretch = [(time, dominant_emotions)]
                print(current_stretch)
                last_dominant = dominant_emotions

    if len(current_stretch) >= 5:
        stretches.append({
            'emotions': list(last_dominant),
            'first_frame': current_stretch[0][0],
            'last_frame': current_stretch[-1][0],
            'length': current_stretch[-1][0] - current_stretch[0][0]
        })

    return stretches

def find_dominant_emotions(emotions):
    # print("Debug: Emotions received:", emotions)  # Debugging line

    emotions = sorted(emotions, key=lambda x: x.get('score', 0), reverse=True)
    top_emotion_score = emotions[0].get('score')
    print("top = " + str(top_emotion_score))
    dominant_emotions = [e['name'] for e in emotions if e['score'] >= top_emotion_score - 0.02]
    return set(dominant_emotions[:3])

@app.route('/', methods=["GET", "POST"])
@cross_origin()
def index():

    # url = "https://api.hume.ai/v0/batch/jobs"

    # files = { "file": ("flask_api\\WIN_20231028_11_07_20_Pro.mp4", open("flask_api\\WIN_20231028_11_07_20_Pro.mp4", "rb"), "video/mp4") }
    # payload = { "json": "{}" }
    # headers = {
    #     "accept": "application/json",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = requests.post(url, data=payload, files=files, headers=headers)

    # print(response.text)
    # result = ""
    # client = HumeStreamClient("jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r")
    # config = FaceConfig(identify_faces=True)
    # async with client.connect([config]) as socket:
    #     #result = await socket.send_file("flask_api\\WIN_20231028_11_07_20_Pro.mp4")
    #     #result = await socket.send_file("flask_api\\WIN_20231028_13_32_11_Pro.jpg")
    #     result = await socket.send_file("blob:http://localhost:3000/fa82b32d-6a8b-4ef6-8be7-56639235342d")
    #     print(result)
    # return response.text

    content = request.files['file']
    print(content.content_type)
    content.save("flask_api/input.webm")

    try:
        command = 'ffmpeg -i flask_api/input.webm flask_api/test2.mp4 -y'
        subprocess.run(command)
    except Exception as e: 
        print(e)
    

    # try:
    #     print(content)
    #     return {"content" : content.filename}
    # except Exception as e:
    #     print(e)
    #     return {"connection": e}
    url = "https://api.hume.ai/v0/batch/jobs"

    # files = { "file": (f"{content}", open(f"{content}", "rb"), "video/mp4") }
    # files = { "file": ("test.mp4", open("flask_api/test.mp4", "rb"), "video/mp4") }

    # payload = { "json": "{}" }
    # headers = {
    #     "accept": "application/json",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = json.loads((requests.post(url, data=payload, files=files, headers=headers)).text)

    # print(response['job_id'])

    # url = f"https://api.hume.ai/v0/batch/jobs/{response['job_id']}/predictions"

    
    # headers = {
    #     "accept": "application/json; charset=utf-8",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = json.loads((requests.get(url, headers=headers)).text)

    # print(type(response))

    # # response_dict = json.loads(response.text)

    # # print(response_dict)

    
    # while type(response) != type(["a", "b"]):
    #     response = json.loads((requests.get(url, headers=headers)).text)
    #     print(type(response))

    #print (type(response))

    client = HumeBatchClient("jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r", timeout=300)

    files = ["flask_api/test2.mp4"]
    burst_config = BurstConfig()
    prosody_config = ProsodyConfig()
    face_config = FaceConfig()
    lang_config = LanguageConfig(granularity='conversational_turn')

    job = client.submit_job([], [burst_config, face_config], files=files)

    print("Running...", job)
    job.await_complete()
    predictions = job.get_predictions()
    #prediction = predictions[0]['results']['predictions'][0]['models']['face']['grouped_predictions'][0]['predictions']

    stretches = find_stretches(predictions)
    print(predictions)


    
    try:
        return predictions
    except Exception as e:
        print(e)
        return {"connection": e}

@app.
[truncated — 1070 more characters]
```

### src/pages/index.js

```javascript
//index.js

import Image from "next/image";
import { Inter } from "next/font/google";
import Form from "@/components/form";
import { useState } from "react";
import { LoaderIcon } from "react-hot-toast";
import Camera from "@/components/Camera";
import Step2 from "@/components/Step2";
import Step3 from "@/components/Step3";
import { useAppContext } from "@/Context";
import { OpenAI } from "openai";
import Record from "@/components/Record";
import Results from "@/components/results";
// import readline from "readline";
// import rl from "readline-promise";
const inter = Inter({ subsets: ["latin"] });

export default function Home() {
  const { step, setStep, setQuestions } = useAppContext();
  const [loading, setLoading] = useState(false);
  const [promptQuestion, setPrompt] = useState("");

  const handleSendToLLM = async (role, job) => {
    setLoading(true);
    console.log(role, job);
    //api call to llm
    
    const prompt = `You're playing the role of an interviewer at ${job} and you're interviewing a person applying as a ${role}, now provide 5 questions in a single string format ie. ["1question", "2question", "3question", "4question", "5question"]. Stricly only array with questions no other text or explanation required`
    
    console.log(prompt)

    // const readline = rl.default;
    // i have removed the api key, so add the api key before running
    const openai = new OpenAI({apiKey: '', dangerouslyAllowBrowser: true});


 const completion = await openai.chat.completions.create({
    model:"gpt-3.5-turbo",
    messages:[{role:"user", content:prompt}]
})
const promptResponse = JSON.parse(completion.choices[0].message.content);
setQuestions(promptResponse)


    setLoading(false);
    setStep(2);
  };


  const handleBeginRecord = () => {
    setLoading(true);

    console.log(loading);
    // After 3 seconds, set startLoading back to false
    setTimeout(() => {
      setLoading(false);
    }, 3000); // 3

    setStep(3);
  };

  console.log(loading);

  if (loading) {
    return (
      <div className="w-full min-h-screen flex-col gap-4 flex items-center justify-center">
        <LoaderIcon style={{ width: "100px", height: "100px" }} />
        <p>Generating questions...</p>
      </div>
    );
  } else {
    return (
      <main className="w-full min-h-screen flex flex=col items-center justify-center">
        {step === 1 && <Form handleSendToLLM={handleSendToLLM} />}
        {step === 2 && <Record handleBeginRecord={handleBeginRecord} />}
        {step === 3 && <Results />}
      </main>
    );
  }
}

```

### postcss.config.js

```javascript
module.exports = {
  plugins: {
    tailwindcss: {},
    autoprefixer: {},
  },
}

```

### tailwind.config.js

```javascript
/** @type {import('tailwindcss').Config} */
module.exports = {
  darkMode: '',
  content: [
    './src/pages/**/*.{js,ts,jsx,tsx,mdx}',
    './src/components/**/*.{js,ts,jsx,tsx,mdx}',
    './src/app/**/*.{js,ts,jsx,tsx,mdx}',
  ],
  theme: {
    extend: {
      backgroundImage: {
        'gradient-radial': 'radial-gradient(var(--tw-gradient-stops))',
        'gradient-conic':
          'conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))',
      },
    },
  },
  plugins: [
    require('@tailwindcss/forms'),

  ],
}

```

### next.config.js

```javascript
/** @type {import('next').NextConfig} */
const nextConfig = {
  reactStrictMode: true,
  async headers() {
    return [
      {
        // Routes this applies to
        source: "/api/(.*)",
        // Headers
        headers: [
          // Allow for specific domains to have access or * for all
          {
            key: "Access-Control-Allow-Origin",
            value: "*",
            // DOES NOT WORK
            // value: process.env.ALLOWED_ORIGIN,
          },
          // Allows for specific methods accepted
          {
            key: "Access-Control-Allow-Methods",
            value: "GET, POST, PUT, DELETE, OPTIONS",
          },
          // Allows for specific headers accepted (These are a few standard ones)
          {
            key: "Access-Control-Allow-Headers",
            value: "Content-Type, Authorization",
          },
        ],
      },
    ];
  },
};

module.exports = nextConfig;
```

### src/Context.js

```javascript
import { createContext, useContext, useState } from 'react';

const AppContext = createContext();

export function useAppContext() {
  return useContext(AppContext);
}

export function AppProvider({ children }) {
  const [step, setStep] = useState(1);
  const [videos, setVideos] = useState([])
  const [questions, setQuestions] = useState(["placeholder1", "placeholder2", "placeholder3"])
  const [loading, setLoading] = useState(false)
  const [results, setResults] = useState("")

  // Define functions that modify globalState here

  
 

  const contextValue = {
    step,
    setStep,
    videos,
    setVideos,
    questions,
    setQuestions,
    loading,
    setLoading,
    results,
    setResults



    // Add your functions here
  };

  return <AppContext.Provider value={contextValue}>{children}</AppContext.Provider>;
}

```

### flask_api/old.py

```python
from flask import Flask, request, session, jsonify
from hume import HumeBatchClient
from hume.models.config import LanguageConfig
from hume.models.config import FaceConfig
from hume.models.config import BurstConfig
from hume.models.config import ProsodyConfig
import requests
import json
from flask_cors import CORS,cross_origin
import imageio_ffmpeg as ffmpeg
import os
import subprocess

app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "http://localhost:3000"}})
#CORS(app)

@app.route('/', methods=["GET", "POST"])
@cross_origin()
def index():

    # url = "https://api.hume.ai/v0/batch/jobs"

    # files = { "file": ("flask_api\\WIN_20231028_11_07_20_Pro.mp4", open("flask_api\\WIN_20231028_11_07_20_Pro.mp4", "rb"), "video/mp4") }
    # payload = { "json": "{}" }
    # headers = {
    #     "accept": "application/json",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = requests.post(url, data=payload, files=files, headers=headers)

    # print(response.text)
    # result = ""
    # client = HumeStreamClient("jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r")
    # config = FaceConfig(identify_faces=True)
    # async with client.connect([config]) as socket:
    #     #result = await socket.send_file("flask_api\\WIN_20231028_11_07_20_Pro.mp4")
    #     #result = await socket.send_file("flask_api\\WIN_20231028_13_32_11_Pro.jpg")
    #     result = await socket.send_file("blob:http://localhost:3000/fa82b32d-6a8b-4ef6-8be7-56639235342d")
    #     print(result)
    # return response.text

    content = request.files['file']
    print(content.content_type)
    content.save("flask_api/input.webm")

    try:
        command = 'ffmpeg -i flask_api/input.webm flask_api/test2.mp4 -y'
        subprocess.run(command)
    except Exception as e: 
        print(e)
    

    # try:
    #     print(content)
    #     return {"content" : content.filename}
    # except Exception as e:
    #     print(e)
    #     return {"connection": e}
    url = "https://api.hume.ai/v0/batch/jobs"

    # files = { "file": (f"{content}", open(f"{content}", "rb"), "video/mp4") }
    # files = { "file": ("test.mp4", open("flask_api/test.mp4", "rb"), "video/mp4") }

    # payload = { "json": "{}" }
    # headers = {
    #     "accept": "application/json",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = json.loads((requests.post(url, data=payload, files=files, headers=headers)).text)

    # print(response['job_id'])

    # url = f"https://api.hume.ai/v0/batch/jobs/{response['job_id']}/predictions"

    
    # headers = {
    #     "accept": "application/json; charset=utf-8",
    #     "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    # }

    # response = json.loads((requests.get(url, headers=headers)).text)

    # print(type(response))

    # # response_dict = json.loads(response.text)

    # # print(response_dict)

    
    # while type(response) != type(["a", "b"]):
    #     response = json.loads((requests.get(url, headers=headers)).text)
    #     print(type(response))

    #print (type(response))

    client = HumeBatchClient("jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r", timeout=300)

    files = ["flask_api/test2.mp4"]
    burst_config = BurstConfig()
    prosody_config = ProsodyConfig()
    face_config = FaceConfig()

    job = client.submit_job([], [burst_config, face_config], files=files)

    print("Running...", job)
    job.await_complete()
    predictions = job.get_predictions()
    print(predictions)
    
    try:
        return predictions
    except Exception as e:
        print(e)
        return {"connection": e}

@app.route("/face/", methods=["GET", "POST"])
def face():
    content = request.files['file']

    url = "https://api.hume.ai/v0/batch/jobs"

    files = { "file": (f"{content}", open(f"{content}", "rb"), "video/mp4") }
    payload = { "json": "{}" }
    headers = {
        "accept": "application/json",
        "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    }

    response = requests.post(url, data=payload, files=files, headers=headers)

    print(response)

    url = "https://api.hume.ai/v0/batch/jobs/34705d25-1a4a-407c-9d4b-54aa50e827bc/predictions"

    
    headers = {
        "accept": "application/json; charset=utf-8",
        "X-Hume-Api-Key": "jsmfWNtGidQg4kV9Y6AyP7kw0V5AzGp8vLxApbGbzDFawM7r"
    }

    response = requests.get(url, headers=headers)

    print(response.text)

    response_dict = json.loads(response.text)
    #print (type(response))
    
    try:
        return response_dict
    except Exception as e:
        print(e)
        return {"connection": e}

if __name__ == "__main__":
    app.run(debug=True,port=5000)
```

### src/styles/globals.css

```css
@tailwind base;
@tailwind components;
@tailwind utilities;

```

[12 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]