Plan.md

Here’s a detailed plan and file structure for your YouTube Shorts creation system using Hugging Face and Streamlit, with credentials stored in a `.env` file:

### **File Structure:**

```
youtube_shorts/
│
├── streamlit_app/
│   └── app.py
│
├── scripts/
│   ├── fetch_content.py
│   ├── fetch_videos.py
│   ├── process_videos.py
│   └── color_correction.py
│
├── reference/
│   └── reference_image.jpg
│
├── videos/
│   └── final_videos/
│
├── .env
├── requirements.txt
└── README.md
```

### **Scripts Overview:**

1. **`fetch_content.py`**: Uses the ChatGPT API from Hugging Face to generate trending content and extract keywords.
2. **`fetch_videos.py`**: Uses the Pexels API to fetch stock videos based on the keywords.
3. **`process_videos.py`**: Trims videos to 3 seconds and applies color correction from the reference image.
4. **`color_correction.py`**: Handles the color correction based on the reference image.

### **Streamlit App:**

- **`app.py`**: Streamlit app to interact with the entire process, including fetching content, videos, processing, and displaying the results.

### **Credentials File:**

- **`.env`**: Stores API keys and sensitive information.

### **Google Colab Notebook Prompt:**

```markdown
# YouTube Shorts Automation with Streamlit

## Overview
This notebook automates the creation of YouTube Shorts by leveraging trending content generated via the Hugging Face API, fetching stock videos from the Pexels API, and applying color correction based on a reference image. The final videos are trimmed to 3 seconds and saved in a specified directory. The Streamlit app facilitates interaction with this system.

## Setup
1. **Install Required Libraries**
    - Install required Python packages including `requests`, `Pillow`, `moviepy`, `opencv-python`, `python-dotenv`, and `streamlit`.

2. **Import Necessary Modules**
    - Import modules from `fetch_content`, `fetch_videos`, `process_videos`, and `color_correction`.

3. **Configure Environment Variables**
    - Ensure the `.env` file contains your API keys for Hugging Face and Pexels.

## Steps

### 1. Fetch Trending Content
- Use the `fetch_content.py` script to interact with the Hugging Face API.
- Generate trending content and extract relevant keywords.

```python
!python3 scripts/fetch_content.py
```

### 2. Fetch Stock Videos
- Use the `fetch_videos.py` script to fetch videos from Pexels based on the keywords.
- Ensure that no video exceeds 3 seconds. If necessary, trim longer videos.

```python
!python3 scripts/fetch_videos.py
```

### 3. Process Videos
- Use the `process_videos.py` script to trim videos to 3 seconds.
- Apply color correction based on the `reference/` directory’s `reference_image.jpg`.

```python
!python3 scripts/process_videos.py
```

### 4. Save Final Videos
- Save all processed videos in the `videos/final_videos/` directory.

```python
!python3 scripts/save_videos.py
```

### 5. Run Streamlit App
- Start the Streamlit app to interact with the entire process.

```python
!streamlit run streamlit_app/app.py
```

## Notes
- Ensure API keys are correctly set in the `.env` file.
- Check the `requirements.txt` for necessary package installations.

## Conclusion
Run each script in the specified order to automate the creation of engaging YouTube Shorts content. Use the Streamlit app to interact with the process and view results in the `videos/final_videos/` directory.
```

### **Scripts Details:**

#### **`fetch_content.py`**

```python
import requests
import os
from dotenv import load_dotenv

load_dotenv()

def fetch_trending_content():
    api_key = os.getenv('HUGGINGFACE_API_KEY')
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": "gpt-4",
        "prompt": "Generate trending content and keywords for YouTube Shorts.",
        "max_tokens": 150
    }
    response = requests.post("https://api.huggingface.co/v1/models/gpt-4/completions", headers=headers, json=data)
    content = response.json()
    return content["choices"][0]["text"].strip()
```

#### **`fetch_videos.py`**

```python
import requests
import os
from dotenv import load_dotenv

load_dotenv()

def fetch_videos(keywords):
    api_key = os.getenv('PEXELS_API_KEY')
    url = "https://api.pexels.com/v1/search"
    headers = {
        "Authorization": api_key
    }
    params = {
        "query": keywords,
        "per_page": 20
    }
    response = requests.get(url, headers=headers, params=params)
    videos = response.json()
    return videos["videos"]
```

#### **`process_videos.py`**

```python
from moviepy.editor import VideoFileClip
import os
from color_correction import apply_color_correction

def trim_and_correct_videos(video_folder, output_folder, reference_image):
    for video_file in os.listdir(video_folder):
        if video_file.endswith(".mp4"):
            video_path = os.path.join(video_folder, video_file)
            output_path = os.path.join(output_folder, video_file)

            clip = VideoFileClip(video_path)
            if clip.duration > 3:
                clip = clip.subclip(0, 3)
            clip = apply_color_correction(clip, reference_image)
            clip.write_videofile(output_path, codec="libx264")
```

#### **`color_correction.py`**

```python
from PIL import Image
import numpy as np
import cv2

def apply_color_correction(video_clip, reference_image_path):
    reference_image = Image.open(reference_image_path)
    reference_array = np.array(reference_image)
    
    def process_frame(frame):
        frame_array = np.array(frame)
        # Apply color correction here (simple example: adjust brightness)
        corrected_frame = cv2.add(frame_array, np.array([10, 10, 10]))
        return Image.fromarray(corrected_frame)

    return video_clip.fl_image(process_frame)
```

#### **`requirements.txt`**

```
requests
Pillow
moviepy
opencv-python
python-dotenv
streamlit
```

#### **`README.md`**

Include instructions on how to set up the environment, obtain API keys, and run each script and the Streamlit app.

This setup will automate the process of creating engaging YouTube Shorts with trending content and processed videos.