UPDATE: loading the model from google drive

.gitignore

@@ -1,14 +1,65 @@
-# Python-generated files
+# Model files
+*.pth
+models/*.pth
+*.pt
+*.pkl
+*.h5
+*.onnx
+*.pb
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Python
 __pycache__/
-*.py[oc]
+*.py[cod]
+*$py.class
+*.so
+.Python
 build/
+develop-eggs/
 dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
 wheels/
-*.egg-info
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
 
 # Virtual environments
-.venv
+venv/
+env/
+ENV/
+.venv/
+.env/
 
-# model files
-*.pth
-models/*.pth
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs
+*.log
+logs/
+
+# Cache
+.cache/
+.pytest_cache/
+
+models/

app.py

@@ -10,6 +10,9 @@ import torch.nn as nn
 from torchvision import transforms, models
 import torch.nn.functional as F
 
+# Import the Google Drive model manager
+from simple_model_manager import SimpleModelManager
+
 # Page configuration
 st.set_page_config(
     page_title="Sentiment Analysis Testing Ground",
@@ -57,48 +60,39 @@ st.markdown(
 )
 
 
+# Initialize the Google Drive model manager
+@st.cache_resource
+def get_model_manager():
+    """Get the Google Drive model manager instance"""
+    try:
+        manager = SimpleModelManager()
+        return manager
+    except Exception as e:
+        st.error(f"Failed to initialize model manager: {e}")
+        return None
+
+
 # Global variables for models
 @st.cache_resource
 def load_vision_model():
-    """Load the pre-trained ResNet-50 vision sentiment model"""
+    """Load the pre-trained ResNet-50 vision sentiment model from Google Drive"""
     try:
-        # Check if model file exists
-        model_path = "models/resnet50_model.pth"
-        if not os.path.exists(model_path):
-            st.error(f"❌ Vision model file not found at: {model_path}")
-            return None
-
-        # Load the model weights first to check the architecture
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        checkpoint = torch.load(model_path, map_location=device)
-
-        # Check the number of classes from the checkpoint
-        if "fc.weight" in checkpoint:
-            num_classes = checkpoint["fc.weight"].shape[0]
-            st.info(f"📊 Model checkpoint has {num_classes} output classes")
-        else:
-            # Fallback: try to infer from the last layer
-            num_classes = 3  # Default assumption
-            st.warning(
-                "⚠️ Could not determine number of classes from checkpoint, assuming 3"
-            )
-
-        # Initialize ResNet-50 model with the correct number of classes
-        # Note: Your model was trained with RGB images, so we keep 3 channels
-        model = models.resnet50(weights=None)  # Don't load ImageNet weights
+        manager = get_model_manager()
+        if manager is None:
+            st.error("Model manager not available")
+            return None, None, None
 
-        num_ftrs = model.fc.in_features
-        model.fc = nn.Linear(num_ftrs, num_classes)  # Use actual number of classes
+        # Load the model using the Google Drive manager
+        model, device, num_classes = manager.load_vision_model()
 
-        # Load trained weights
-        model.load_state_dict(checkpoint)
-        model.to(device)
-        model.eval()
+        if model is None:
+            st.error("Failed to load vision model from Google Drive")
+            return None, None, None
 
-        st.success(f"✅ Vision model loaded successfully with {num_classes} classes!")
+        st.success(f"Vision model loaded successfully with {num_classes} classes!")
         return model, device, num_classes
     except Exception as e:
-        st.error(f"❌ Error loading vision model: {str(e)}")
+        st.error(f"Error loading vision model: {str(e)}")
         return None, None, None
 
 
@@ -154,7 +148,7 @@ def detect_and_preprocess_face(image, crop_tightness=0.05):
         )
 
         if len(faces) == 0:
-            st.warning("⚠️ No face detected in the image. Using center crop instead.")
+            st.warning("No face detected in the image. Using center crop instead.")
             # Fallback: center crop and resize
             if isinstance(image, Image.Image):
                 # Convert to RGB first
@@ -213,7 +207,7 @@ def detect_and_preprocess_face(image, crop_tightness=0.05):
 
     except ImportError:
         st.error(
-            "❌ OpenCV not installed. Please install it with: pip install opencv-python"
+            "OpenCV not installed. Please install it with: pip install opencv-python"
         )
         st.info("Falling back to basic preprocessing...")
         # Fallback: basic grayscale conversion and resize
@@ -226,7 +220,7 @@ def detect_and_preprocess_face(image, crop_tightness=0.05):
             return gray_rgb_pil
         return None
     except Exception as e:
-        st.error(f"❌ Error in face detection: {str(e)}")
+        st.error(f"Error in face detection: {str(e)}")
         st.info("Falling back to basic preprocessing...")
         # Fallback: basic grayscale conversion and resize
         if isinstance(image, Image.Image):
@@ -299,50 +293,39 @@ def predict_text_sentiment(text):
         return sentiment, confidence
 
     except ImportError:
-        st.error(
-            "❌ TextBlob not installed. Please install it with: pip install textblob"
-        )
+        st.error("TextBlob not installed. Please install it with: pip install textblob")
         return "TextBlob not available", 0.0
     except Exception as e:
-        st.error(f"❌ Error in text sentiment analysis: {str(e)}")
+        st.error(f"Error in text sentiment analysis: {str(e)}")
         return "Error occurred", 0.0
 
 
 @st.cache_resource
 def load_audio_model():
-    """Load the pre-trained Wav2Vec2 audio sentiment model"""
+    """Load the pre-trained Wav2Vec2 audio sentiment model from Google Drive"""
     try:
-        # Check if model file exists
-        model_path = "models/wav2vec2_model.pth"
-        if not os.path.exists(model_path):
-            st.error(f"❌ Audio model file not found at: {model_path}")
+        manager = get_model_manager()
+        if manager is None:
+            st.error("Model manager not available")
             return None, None, None, None
 
-        # Load the model weights first to check the architecture
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        checkpoint = torch.load(model_path, map_location=device)
+        # Load the model using the Google Drive manager
+        model, device = manager.load_audio_model()
 
-        # Check the number of classes from the checkpoint
-        if "classifier.weight" in checkpoint:
-            num_classes = checkpoint["classifier.weight"].shape[0]
-            st.info(f"📊 Audio model checkpoint has {num_classes} output classes")
-        else:
-            num_classes = 3  # Default assumption
-            st.warning(
-                "⚠️ Could not determine number of classes from checkpoint, assuming 3"
-            )
-
-        # Initialize Wav2Vec2 model with the correct number of classes
-        from transformers import AutoModelForAudioClassification
-
-        model = AutoModelForAudioClassification.from_pretrained(
-            "facebook/wav2vec2-base", num_labels=num_classes
-        )
+        if model is None:
+            st.error("Failed to load audio model from Google Drive")
+            return None, None, None, None
 
-        # Load trained weights
-        model.load_state_dict(checkpoint)
-        model.to(device)
-        model.eval()
+        # For Wav2Vec2 models, we need to determine the number of classes
+        # This is typically available in the model configuration
+        try:
+            num_classes = model.config.num_labels
+        except:
+            # Fallback: try to infer from the model
+            try:
+                num_classes = model.classifier.out_features
+            except:
+                num_classes = 3  # Default assumption
 
         # Load feature extractor
         from transformers import AutoFeatureExtractor
@@ -351,10 +334,10 @@ def load_audio_model():
             "facebook/wav2vec2-base"
         )
 
-        st.success(f"✅ Audio model loaded successfully with {num_classes} classes!")
+        st.success(f"Audio model loaded successfully with {num_classes} classes!")
         return model, device, num_classes, feature_extractor
     except Exception as e:
-        st.error(f"❌ Error loading audio model: {str(e)}")
+        st.error(f"Error loading audio model: {str(e)}")
         return None, None, None, None
 
 
@@ -430,11 +413,11 @@ def predict_audio_sentiment(audio_bytes):
             os.unlink(tmp_file_path)
 
     except ImportError as e:
-        st.error(f"❌ Required library not installed: {str(e)}")
+        st.error(f"Required library not installed: {str(e)}")
         st.info("Please install: pip install librosa transformers")
         return "Library not available", 0.0
     except Exception as e:
-        st.error(f"❌ Error in audio sentiment prediction: {str(e)}")
+        st.error(f"Error in audio sentiment prediction: {str(e)}")
         return "Error occurred", 0.0
 
 
@@ -457,7 +440,7 @@ def predict_vision_sentiment(image, crop_tightness=0.05):
 
         # Preprocess image to match FER2013 format
         st.info(
-            "🔍 Detecting face and preprocessing image to match training data format..."
+            "Detecting face and preprocessing image to match training data format..."
         )
         preprocessed_image = detect_and_preprocess_face(image, crop_tightness=0.0)
 
@@ -482,7 +465,7 @@ def predict_vision_sentiment(image, crop_tightness=0.05):
             outputs = model(image_tensor)
 
             # Debug: print output shape
-            st.info(f"🔍 Model output shape: {outputs.shape}")
+            st.info(f"Model output shape: {outputs.shape}")
 
             probabilities = F.softmax(outputs, dim=1)
             confidence, predicted = torch.max(probabilities, 1)
@@ -541,23 +524,23 @@ def predict_fused_sentiment(text=None, audio_bytes=None, image=None):
 
 
 # Sidebar navigation
-st.sidebar.title("🧠 Sentiment Analysis")
+st.sidebar.title("Sentiment Analysis")
 st.sidebar.markdown("---")
 
 # Navigation
 page = st.sidebar.selectbox(
     "Choose a page:",
     [
-        "🏠 Home",
-        "📝 Text Sentiment",
-        "🎵 Audio Sentiment",
-        "🖼️ Vision Sentiment",
-        "🔗 Fused Model",
+        "Home",
+        "Text Sentiment",
+        "Audio Sentiment",
+        "Vision Sentiment",
+        "Fused Model",
     ],
 )
 
 # Home Page
-if page == "🏠 Home":
+if page == "Home":
     st.markdown(
         '<h1 class="main-header">Sentiment Analysis Testing Ground</h1>',
         unsafe_allow_html=True,
@@ -579,8 +562,8 @@ if page == "��� Home":
         st.markdown(
             """
         <div class="model-card">
-            <h3>📝 Text Sentiment Model</h3>
-            <p>✅ <strong>READY TO USE</strong> - Analyze sentiment from text input using TextBlob</p>
+            <h3>Text Sentiment Model</h3>
+            <p>READY TO USE - Analyze sentiment from text input using TextBlob</p>
                          <ul>
                  <li>Process any text input</li>
                  <li>Get sentiment classification (Positive/Negative/Neutral)</li>
@@ -596,12 +579,12 @@ if page == "🏠 Home":
         st.markdown(
             """
         <div class="model-card">
-            <h3>🎵 Audio Sentiment Model</h3>
-            <p>✅ <strong>READY TO USE</strong> - Analyze sentiment from audio files using fine-tuned Wav2Vec2</p>
+            <h3>Audio Sentiment Model</h3>
+            <p>READY TO USE - Analyze sentiment from audio files using fine-tuned Wav2Vec2</p>
                          <ul>
                  <li>Upload audio files (.wav, .mp3, .m4a, .flac)</li>
-                 <li>🎙️ Record audio directly with microphone (max 5s)</li>
-                 <li>🔄 Automatic preprocessing: 16kHz sampling, 5s max duration (CREMA-D + RAVDESS format)</li>
+                 <li>Record audio directly with microphone (max 5s)</li>
+                 <li>Automatic preprocessing: 16kHz sampling, 5s max duration (CREMA-D + RAVDESS format)</li>
                  <li>Listen to uploaded/recorded audio</li>
                  <li>Get sentiment predictions</li>
                  <li>Real-time audio analysis</li>
@@ -615,14 +598,14 @@ if page == "🏠 Home":
         st.markdown(
             """
         <div class="model-card">
-            <h3>🖼️ Vision Sentiment Model</h3>
+            <h3>Vision Sentiment Model</h3>
             <p>Analyze sentiment from images using fine-tuned ResNet-50</p>
                          <ul>
                  <li>Upload image files (.png, .jpg, .jpeg, .bmp, .tiff)</li>
-                 <li>🔄 Automatic face detection & preprocessing</li>
-                 <li>🎯 Fixed 0% padding for tightest face crop</li>
-                 <li>📏 Convert to 224x224 grayscale → 3-channel RGB (FER2013 format)</li>
-                 <li>🎯 Transforms: Resize(224) → CenterCrop(224) → ImageNet Normalization</li>
+                 <li>Automatic face detection & preprocessing</li>
+                 <li>Fixed 0% padding for tightest face crop</li>
+                 <li>Convert to 224x224 grayscale → 3-channel RGB (FER2013 format)</li>
+                 <li>Transforms: Resize(224) → CenterCrop(224) → ImageNet Normalization</li>
                  <li>Preview original & preprocessed images</li>
                  <li>Get sentiment predictions</li>
              </ul>
@@ -634,7 +617,7 @@ if page == "🏠 Home":
     st.markdown(
         """
     <div class="model-card">
-        <h3>🔗 Fused Model</h3>
+        <h3>Fused Model</h3>
         <p>Combine predictions from all three models for enhanced accuracy</p>
         <ul>
             <li>Multi-modal input processing</li>
@@ -650,16 +633,17 @@ if page == "🏠 Home":
     st.markdown(
         """
     <div style="text-align: center; color: #666;">
-        <p><strong>Note:</strong> This application now has <strong>ALL THREE MODELS</strong> fully integrated and ready to use! 🎉</p>
+        <p><strong>Note:</strong> This application now has <strong>ALL THREE MODELS</strong> fully integrated and ready to use!</p>
         <p><strong>TextBlob</strong> (Text) + <strong>Wav2Vec2</strong> (Audio) + <strong>ResNet-50</strong> (Vision)</p>
+        <p><strong>Models are now loaded from Google Drive automatically!</strong></p>
     </div>
     """,
         unsafe_allow_html=True,
     )
 
 # Text Sentiment Page
-elif page == "📝 Text Sentiment":
-    st.title("📝 Text Sentiment Analysis")
+elif page == "Text Sentiment":
+    st.title("Text Sentiment Analysis")
     st.markdown("Analyze the sentiment of your text using our TextBlob-based model.")
 
     # Text input
@@ -670,7 +654,7 @@ elif page == "📝 Text Sentiment":
     )
 
     # Analyze button
-    if st.button("🔍 Analyze Sentiment", type="primary", use_container_width=True):
+    if st.button("Analyze Sentiment", type="primary", use_container_width=True):
         if text_input and text_input.strip():
             with st.spinner("Analyzing text sentiment..."):
                 sentiment, confidence = predict_text_sentiment(text_input)
@@ -707,37 +691,41 @@ elif page == "📝 Text Sentiment":
             st.error("Please enter some text to analyze.")
 
 # Audio Sentiment Page
-elif page == "🎵 Audio Sentiment":
-    st.title("🎵 Audio Sentiment Analysis")
+elif page == "Audio Sentiment":
+    st.title("Audio Sentiment Analysis")
     st.markdown(
         "Analyze the sentiment of your audio files using our fine-tuned Wav2Vec2 model."
     )
 
     # Preprocessing information
     st.info(
-        "ℹ️ **Audio Preprocessing**: Audio will be automatically processed to match CREMA-D + RAVDESS training format: "
+        "**Audio Preprocessing**: Audio will be automatically processed to match CREMA-D + RAVDESS training format: "
         "16kHz sampling rate, max 5 seconds, with automatic resampling and feature extraction."
     )
 
     # Model status
     model, device, num_classes, feature_extractor = load_audio_model()
     if model is None:
-        st.error("❌ Audio model could not be loaded. Please check the model file.")
-        st.info("Expected model file: `models/wav2vec2_model.pth`")
+        st.error(
+            "Audio model could not be loaded. Please check the Google Drive setup."
+        )
+        st.info(
+            "Expected: Models should be configured in Google Drive and accessible via the model manager."
+        )
     else:
         st.success(
-            f"✅ Audio model loaded successfully on {device} with {num_classes} classes!"
+            f"Audio model loaded successfully on {device} with {num_classes} classes!"
         )
 
     # Input method selection
-    st.subheader("🎤 Choose Input Method")
+    st.subheader("Choose Input Method")
     input_method = st.radio(
         "Select how you want to provide audio:",
-        ["📁 Upload Audio File", "🎙️ Record Audio"],
+        ["Upload Audio File", "Record Audio"],
         horizontal=True,
     )
 
-    if input_method == "📁 Upload Audio File":
+    if input_method == "Upload Audio File":
         # File uploader
         uploaded_audio = st.file_uploader(
             "Choose an audio file",
@@ -752,7 +740,7 @@ elif page == "🎵 Audio Sentiment":
         st.markdown(
             """
         <div class="model-card">
-            <h3>🎙️ Audio Recording</h3>
+            <h3>Audio Recording</h3>
             <p>Record audio directly with your microphone (max 5 seconds).</p>
             <p><strong>Note:</strong> Make sure your microphone is accessible and you have permission to use it.</p>
         </div>
@@ -769,7 +757,7 @@ elif page == "🎵 Audio Sentiment":
         if recorded_audio is not None:
             # Display recorded audio
             st.audio(recorded_audio, format="audio/wav")
-            st.success("✅ Audio recorded successfully!")
+            st.success("Audio recorded successfully!")
 
             # Convert recorded audio to bytes for processing
             uploaded_audio = recorded_audio
@@ -784,21 +772,21 @@ elif page == "🎵 Audio Sentiment":
         # Display audio player
         if audio_source == "recorded":
             st.audio(uploaded_audio, format="audio/wav")
-            st.info(f"🎙️ {audio_name} | Source: Microphone Recording")
+            st.info(f"{audio_name} | Source: Microphone Recording")
         else:
             st.audio(
                 uploaded_audio, format=f'audio/{uploaded_audio.name.split(".")[-1]}'
             )
             # File info for uploaded files
             file_size = len(uploaded_audio.getvalue()) / 1024  # KB
-            st.info(f"📁 File: {uploaded_audio.name} | Size: {file_size:.1f} KB")
+            st.info(f"File: {uploaded_audio.name} | Size: {file_size:.1f} KB")
 
         # Analyze button
         if st.button(
-            "🔍 Analyze Audio Sentiment", type="primary", use_container_width=True
+            "Analyze Audio Sentiment", type="primary", use_container_width=True
         ):
             if model is None:
-                st.error("❌ Model not loaded. Cannot analyze audio.")
+                st.error("Model not loaded. Cannot analyze audio.")
             else:
                 with st.spinner("Analyzing audio sentiment..."):
                     audio_bytes = uploaded_audio.getvalue()
@@ -828,46 +816,48 @@ elif page == "🎵 Audio Sentiment":
                     unsafe_allow_html=True,
                 )
     else:
-        if input_method == "📁 Upload Audio File":
-            st.info("👆 Please upload an audio file to begin analysis.")
+        if input_method == "Upload Audio File":
+            st.info("Please upload an audio file to begin analysis.")
         else:
-            st.info("🎙️ Click the microphone button above to record audio for analysis.")
+            st.info("Click the microphone button above to record audio for analysis.")
 
 # Vision Sentiment Page
-elif page == "🖼️ Vision Sentiment":
-    st.title("🖼️ Vision Sentiment Analysis")
+elif page == "Vision Sentiment":
+    st.title("Vision Sentiment Analysis")
     st.markdown(
         "Analyze the sentiment of your images using our fine-tuned ResNet-50 model."
     )
 
     st.info(
-        "ℹ️ **Note**: Images will be automatically preprocessed to match FER2013 format: face detection, grayscale conversion, and 224x224 resize (converted to 3-channel RGB)."
+        "**Note**: Images will be automatically preprocessed to match FER2013 format: face detection, grayscale conversion, and 224x224 resize (converted to 3-channel RGB)."
     )
 
     # Face cropping is set to 0% (no padding) for tightest crop
-    st.info(
-        "🎯 **Face Cropping**: Set to 0% padding for tightest crop on facial features"
-    )
+    st.info("**Face Cropping**: Set to 0% padding for tightest crop on facial features")
 
     # Model status
     model, device, num_classes = load_vision_model()
     if model is None:
-        st.error("❌ Vision model could not be loaded. Please check the model file.")
-        st.info("Expected model file: `models/resnet50_model.pth`")
+        st.error(
+            "Vision model could not be loaded. Please check the Google Drive setup."
+        )
+        st.info(
+            "Expected: Models should be configured in Google Drive and accessible via the model manager."
+        )
     else:
         st.success(
-            f"✅ Vision model loaded successfully on {device} with {num_classes} classes!"
+            f"Vision model loaded successfully on {device} with {num_classes} classes!"
         )
 
     # Input method selection
-    st.subheader("📸 Choose Input Method")
+    st.subheader("Choose Input Method")
     input_method = st.radio(
         "Select how you want to provide an image:",
-        ["📁 Upload Image File", "📷 Take Photo with Camera"],
+        ["Upload Image File", "Take Photo with Camera"],
         horizontal=True,
     )
 
-    if input_method == "📁 Upload Image File":
+    if input_method == "Upload Image File":
         # File uploader
         uploaded_image = st.file_uploader(
             "Choose an image file",
@@ -887,15 +877,15 @@ elif page == "🖼️ Vision Sentiment":
             # File info
             file_size = len(uploaded_image.getvalue()) / 1024  # KB
             st.info(
-                f"📁 File: {uploaded_image.name} | Size: {file_size:.1f} KB | Dimensions: {image.size[0]}x{image.size[1]}"
+                f"File: {uploaded_image.name} | Size: {file_size:.1f} KB | Dimensions: {image.size[0]}x{image.size[1]}"
             )
 
             # Analyze button
             if st.button(
-                "🔍 Analyze Image Sentiment", type="primary", use_container_width=True
+                "Analyze Image Sentiment", type="primary", use_container_width=True
             ):
                 if model is None:
-                    st.error("❌ Model not loaded. Cannot analyze image.")
+                    st.error("Model not loaded. Cannot analyze image.")
                 else:
                     with st.spinner("Analyzing image sentiment..."):
                         sentiment, confidence = predict_vision_sentiment(image)
@@ -932,7 +922,7 @@ elif page == "🖼️ Vision Sentiment":
         st.markdown(
             """
         <div class="model-card">
-            <h3>📷 Camera Capture</h3>
+            <h3>Camera Capture</h3>
             <p>Take a photo directly with your camera to analyze its sentiment.</p>
             <p><strong>Note:</strong> Make sure your camera is accessible and you have permission to use it.</p>
         </div>
@@ -957,15 +947,15 @@ elif page == "🖼️ Vision Sentiment":
 
             # Image info
             st.info(
-                f"📷 Captured Photo | Dimensions: {image.size[0]}x{image.size[1]} | Format: {image.format}"
+                f"Captured Photo | Dimensions: {image.size[0]}x{image.size[1]} | Format: {image.format}"
             )
 
             # Analyze button
             if st.button(
-                "🔍 Analyze Photo Sentiment", type="primary", use_container_width=True
+                "Analyze Photo Sentiment", type="primary", use_container_width=True
             ):
                 if model is None:
-                    st.error("❌ Model not loaded. Cannot analyze image.")
+                    st.error("Model not loaded. Cannot analyze image.")
                 else:
                     with st.spinner("Analyzing photo sentiment..."):
                         sentiment, confidence = predict_vision_sentiment(image)
@@ -999,14 +989,14 @@ elif page == "🖼️ Vision Sentiment":
                         )
 
     # Show info if no image is provided
-    if input_method == "📁 Upload Image File" and "uploaded_image" not in locals():
-        st.info("👆 Please upload an image file to begin analysis.")
-    elif input_method == "📷 Take Photo with Camera" and "camera_photo" not in locals():
-        st.info("📷 Click the camera button above to take a photo for analysis.")
+    if input_method == "Upload Image File" and "uploaded_image" not in locals():
+        st.info("Please upload an image file to begin analysis.")
+    elif input_method == "Take Photo with Camera" and "camera_photo" not in locals():
+        st.info("Click the camera button above to take a photo for analysis.")
 
 # Fused Model Page
-elif page == "🔗 Fused Model":
-    st.title("🔗 Fused Model Analysis")
+elif page == "Fused Model":
+    st.title("Fused Model Analysis")
     st.markdown(
         "Combine predictions from all three models for enhanced sentiment analysis."
     )
@@ -1026,30 +1016,30 @@ elif page == "🔗 Fused Model":
     col1, col2 = st.columns(2)
 
     with col1:
-        st.subheader("📝 Text Input")
+        st.subheader("Text Input")
         text_input = st.text_area(
             "Enter text (optional):",
             height=100,
             placeholder="Type or paste your text here...",
         )
 
-        st.subheader("🎵 Audio Input")
+        st.subheader("Audio Input")
 
         # Audio preprocessing information for fused model
         st.info(
-            "ℹ️ **Audio Preprocessing**: Audio will be automatically processed to match CREMA-D + RAVDESS training format: "
+            "**Audio Preprocessing**: Audio will be automatically processed to match CREMA-D + RAVDESS training format: "
             "16kHz sampling rate, max 5 seconds, with automatic resampling and feature extraction."
         )
 
         # Audio input method for fused model
         audio_input_method = st.radio(
             "Audio input method:",
-            ["📁 Upload File", "🎙️ Record Audio"],
+            ["Upload File", "Record Audio"],
             key="fused_audio_method",
             horizontal=True,
         )
 
-        if audio_input_method == "📁 Upload File":
+        if audio_input_method == "Upload File":
             uploaded_audio = st.file_uploader(
                 "Upload audio file (optional):",
                 type=["wav", "mp3", "m4a", "flac"],
@@ -1067,7 +1057,7 @@ elif page == "🔗 Fused Model":
 
             if recorded_audio is not None:
                 st.audio(recorded_audio, format="audio/wav")
-                st.success("✅ Audio recorded successfully!")
+                st.success("Audio recorded successfully!")
                 uploaded_audio = recorded_audio
                 audio_source = "recorded"
                 audio_name = "Recorded Audio"
@@ -1077,22 +1067,22 @@ elif page == "🔗 Fused Model":
                 audio_name = None
 
     with col2:
-        st.subheader("🖼️ Image Input")
+        st.subheader("Image Input")
 
         # Face cropping is set to 0% (no padding) for tightest crop
         st.info(
-            "🎯 **Face Cropping**: Set to 0% padding for tightest crop on facial features"
+            "**Face Cropping**: Set to 0% padding for tightest crop on facial features"
         )
 
         # Image input method for fused model
         image_input_method = st.radio(
             "Image input method:",
-            ["📁 Upload File", "📷 Take Photo"],
+            ["Upload File", "Take Photo"],
             key="fused_image_method",
             horizontal=True,
         )
 
-        if image_input_method == "📁 Upload File":
+        if image_input_method == "Upload File":
             uploaded_image = st.file_uploader(
                 "Upload image file (optional):",
                 type=["png", "jpg", "jpeg", "bmp", "tiff"],
@@ -1122,7 +1112,7 @@ elif page == "🔗 Fused Model":
             )
 
     # Analyze button
-    if st.button("🔍 Run Fused Analysis", type="primary", use_container_width=True):
+    if st.button("Run Fused Analysis", type="primary", use_container_width=True):
         if text_input or uploaded_audio or uploaded_image:
             with st.spinner("Running fused sentiment analysis..."):
                 # Prepare inputs
@@ -1154,7 +1144,7 @@ elif page == "🔗 Fused Model":
                     text_sentiment, text_conf = predict_text_sentiment(text_input)
                     results_data.append(
                         {
-                            "Model": "Text (TextBlob) ✅",
+                            "Model": "Text (TextBlob)",
                             "Input": f"Text: {text_input[:50]}...",
                             "Sentiment": text_sentiment,
                             "Confidence": f"{text_conf:.2f}",
@@ -1165,7 +1155,7 @@ elif page == "🔗 Fused Model":
                     audio_sentiment, audio_conf = predict_audio_sentiment(audio_bytes)
                     results_data.append(
                         {
-                            "Model": "Audio (Wav2Vec2) ✅",
+                            "Model": "Audio (Wav2Vec2)",
                             "Input": f"Audio: {audio_name}",
                             "Sentiment": audio_sentiment,
                             "Confidence": f"{audio_conf:.2f}",
@@ -1205,7 +1195,7 @@ elif page == "🔗 Fused Model":
                 )
         else:
             st.warning(
-                "⚠️ Please provide at least one input (text, audio, or image) for fused analysis."
+                "Please provide at least one input (text, audio, or image) for fused analysis."
             )
 
 # Footer

debug_drive.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Debug Google Drive download issues
+"""
+
+import os
+import requests
+import re
+from pathlib import Path
+
+
+# Load .env file manually
+def load_env():
+    env_file = Path(".env")
+    if env_file.exists():
+        with open(env_file, "r") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    os.environ[key.strip()] = value.strip().strip('"')
+
+
+def test_drive_bypass(file_id):
+    """Test different bypass methods"""
+    print(f"Testing file ID: {file_id}")
+    print("=" * 50)
+
+    # Method 1: Direct bypass
+    print("\n1. Testing direct bypass...")
+    try:
+        url = f"https://drive.usercontent.google.com/download?id={file_id}&export=download&confirm=t"
+        response = requests.get(url, stream=True)
+        print(f"Status: {response.status_code}")
+        print(f"Content-Type: {response.headers.get('content-type', 'Unknown')}")
+
+        first_chunk = next(response.iter_content(chunk_size=1024), b"")
+        if first_chunk.startswith(b"<!DOCTYPE") or first_chunk.startswith(b"<html"):
+            print("❌ Still getting HTML")
+            html_content = first_chunk.decode("utf-8", errors="ignore")
+            print(f"HTML preview: {html_content[:200]}...")
+        else:
+            print("✅ Got file content!")
+            print(f"First bytes: {first_chunk[:50]}")
+            return True
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+    # Method 2: Session-based approach
+    print("\n2. Testing session-based approach...")
+    try:
+        session = requests.Session()
+        session.headers.update(
+            {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.5",
+            }
+        )
+
+        # First get the virus scan page
+        virus_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+        response = session.get(virus_url)
+        print(f"Virus page status: {response.status_code}")
+
+        # Extract confirm and UUID
+        html_content = response.text
+        confirm_match = re.search(r'name="confirm" value="([^"]+)"', html_content)
+        uuid_match = re.search(r'name="uuid" value="([^"]+)"', html_content)
+
+        if confirm_match and uuid_match:
+            confirm_value = confirm_match.group(1)
+            uuid_value = uuid_match.group(1)
+            print(f"Found confirm: {confirm_value}")
+            print(f"Found UUID: {uuid_value}")
+
+            # Submit form
+            form_data = {
+                "id": file_id,
+                "export": "download",
+                "confirm": confirm_value,
+                "uuid": uuid_value,
+            }
+            form_url = "https://drive.usercontent.google.com/download"
+            response = session.post(form_url, data=form_data, stream=True)
+
+            print(f"Form submission status: {response.status_code}")
+            first_chunk = next(response.iter_content(chunk_size=1024), b"")
+
+            if first_chunk.startswith(b"<!DOCTYPE") or first_chunk.startswith(b"<html"):
+                print("❌ Form submission still returned HTML")
+            else:
+                print("✅ Form submission successful!")
+                return True
+        else:
+            print("❌ Could not extract confirm/UUID")
+            print(f"HTML preview: {html_content[:300]}...")
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+    # Method 3: Extract download URL from file page
+    print("\n3. Testing file page extraction...")
+    try:
+        session = requests.Session()
+        session.headers.update(
+            {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+                "Referer": "https://drive.google.com/",
+            }
+        )
+
+        file_url = f"https://drive.google.com/file/d/{file_id}/view"
+        response = session.get(file_url)
+        print(f"File page status: {response.status_code}")
+
+        if response.status_code == 200:
+            # Look for download URL in the page
+            download_match = re.search(r'"downloadUrl":"([^"]+)"', response.text)
+            if download_match:
+                download_url = (
+                    download_match.group(1)
+                    .replace("\\u003d", "=")
+                    .replace("\\u0026", "&")
+                )
+                print(f"Found download URL: {download_url}")
+
+                # Try downloading from this URL
+                response = session.get(download_url, stream=True)
+                first_chunk = next(response.iter_content(chunk_size=1024), b"")
+
+                if first_chunk.startswith(b"<!DOCTYPE") or first_chunk.startswith(
+                    b"<html"
+                ):
+                    print("❌ Download URL still returned HTML")
+                else:
+                    print("✅ Download URL successful!")
+                    return True
+            else:
+                print("❌ Could not find download URL in page")
+        else:
+            print(f"❌ Could not access file page")
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+    print("\n❌ All methods failed")
+    return False
+
+
+def main():
+    print("Google Drive Bypass Debug Tool")
+    print("=" * 50)
+
+    # Load environment variables
+    load_env()
+
+    # Get file ID from environment or user input
+    vision_url = os.getenv("VISION_MODEL_DRIVE_LINK", "")
+    audio_url = os.getenv("AUDIO_MODEL_DRIVE_LINK", "")
+
+    if not vision_url and not audio_url:
+        print("❌ No environment variables found!")
+        print("Please set VISION_MODEL_DRIVE_LINK or AUDIO_MODEL_DRIVE_LINK")
+        return
+
+    if vision_url:
+        print(f"\nTesting Vision Model URL: {vision_url}")
+        if "/file/d/" in vision_url:
+            file_id = vision_url.split("/file/d/")[1].split("/")[0]
+            test_drive_bypass(file_id)
+        else:
+            print("❌ Invalid vision model URL format")
+
+    if audio_url:
+        print(f"\nTesting Audio Model URL: {audio_url}")
+        if "/file/d/" in audio_url:
+            file_id = audio_url.split("/file/d/")[1].split("/")[0]
+            test_drive_bypass(file_id)
+        else:
+            print("❌ Invalid audio model URL format")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -4,4 +4,7 @@ version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.9"
-dependencies = []
+dependencies = [
+    "gdown>=5.2.0",
+    "python-dotenv>=1.1.1",
+]

requirements.txt

@@ -3,10 +3,13 @@ pandas>=1.5.0
 Pillow>=9.0.0
 numpy>=1.21.0
 textblob>=0.17.0
-torch>=1.13.0
-torchvision>=0.14.0
+torch>=2.0.0
+torchvision>=0.15.0
 transformers>=4.21.0
 librosa>=0.9.0
 soundfile>=0.12.0
 opencv-python>=4.5.0
 accelerate>=0.20.0
+requests>=2.25.0
+python-dotenv>=0.19.0
+gdown>=4.7.0

simple_model_manager.py

@@ -0,0 +1,410 @@
+#!/usr/bin/env python3
+"""
+Simple Model Manager - Downloads models from Google Drive using gdown
+"""
+
+import os
+import gdown
+from pathlib import Path
+import logging
+from typing import Tuple, Any
+import torch
+import torch.nn as nn
+from torchvision import models
+
+# Try to load .env file if it exists
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv()
+except ImportError:
+    # If python-dotenv is not installed, try to load .env manually
+    env_file = Path(".env")
+    if env_file.exists():
+        with open(env_file, "r") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, value = line.split("=", 1)
+                    os.environ[key.strip()] = value.strip()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class SimpleModelManager:
+    """Simple model manager that downloads models from Google Drive using gdown"""
+
+    def __init__(self, model_dir: str = "models", cache_models: bool = True):
+        """
+        Initialize simple model manager
+
+        Args:
+            model_dir: Local directory to store models
+            cache_models: Whether to cache models locally
+        """
+        self.model_dir = Path(model_dir)
+        self.model_dir.mkdir(exist_ok=True)
+        self.cache_models = cache_models
+
+        # Load model links from environment variables
+        self.model_links = {
+            "vision": {
+                "url": os.getenv("VISION_MODEL_DRIVE_ID", ""),
+                "filename": os.getenv("VISION_MODEL_FILENAME", "resnet50_model.pth"),
+                "description": "Vision sentiment analysis model",
+            },
+            "audio": {
+                "url": os.getenv("AUDIO_MODEL_DRIVE_ID", ""),
+                "filename": os.getenv("AUDIO_MODEL_FILENAME", "wav2vec2_model.pth"),
+                "description": "Audio sentiment analysis model",
+            },
+        }
+
+        # Validate that environment variables are set
+        self._validate_environment()
+
+    def _validate_environment(self):
+        """Validate that required environment variables are set"""
+        missing_vars = []
+
+        if not self.model_links["vision"]["url"]:
+            missing_vars.append("VISION_MODEL_DRIVE_LINK")
+
+        if not self.model_links["audio"]["url"]:
+            missing_vars.append("AUDIO_MODEL_DRIVE_LINK")
+
+        if missing_vars:
+            logger.warning(f"Missing environment variables: {', '.join(missing_vars)}")
+            logger.warning("Please set these in your .env file or environment")
+            logger.warning("Models will not be available until these are configured")
+
+    def download_from_google_drive(self, share_url: str, filename: str) -> str:
+        """
+        Download file from Google Drive share link using gdown
+
+        Args:
+            share_url: Google Drive share link
+            filename: Name to save the file as
+
+        Returns:
+            Path to downloaded file
+        """
+        try:
+            local_path = self.model_dir / filename
+
+            if local_path.exists() and self.cache_models:
+                logger.info(f"Model already cached: {local_path}")
+                return str(local_path)
+
+            logger.info(f"Downloading {filename} from Google Drive using gdown...")
+
+            # Use gdown to download the file
+            # gdown automatically handles virus scan warnings and other Google Drive issues
+            output_path = str(local_path)
+
+            # Download with progress bar
+            gdown.download(
+                id=share_url,
+                output=output_path,
+                quiet=False,  # Show progress bar
+                fuzzy=True,  # Handle various Google Drive URL formats
+            )
+
+            # Verify the file was downloaded
+            if not Path(output_path).exists():
+                raise FileNotFoundError(f"Download failed: {output_path} not found")
+
+            file_size = Path(output_path).stat().st_size
+            if file_size == 0:
+                raise ValueError(f"Downloaded file is empty: {output_path}")
+
+            logger.info(f"Successfully downloaded {filename} ({file_size} bytes)")
+            return output_path
+
+        except Exception as e:
+            logger.error(f"Failed to download {filename}: {e}")
+            raise
+
+    def load_vision_model(self) -> Tuple[Any, torch.device, int]:
+        """Load vision sentiment model"""
+        try:
+            model_info = self.model_links["vision"]
+
+            # Check if URL is configured
+            if not model_info["url"]:
+                raise ValueError("VISION_MODEL_DRIVE_LINK environment variable not set")
+
+            model_path = self.download_from_google_drive(
+                model_info["url"], model_info["filename"]
+            )
+
+            # Validate the downloaded file
+            if not Path(model_path).exists():
+                raise FileNotFoundError(f"Model file not found at {model_path}")
+
+            file_size = Path(model_path).stat().st_size
+            if file_size == 0:
+                raise ValueError(f"Model file is empty: {model_path}")
+
+            # Check file header to see what type of file it is
+            with open(model_path, "rb") as f:
+                header = f.read(100)  # Read first 100 bytes
+
+            logger.info(f"File size: {file_size} bytes")
+            logger.info(f"File header (first 100 bytes): {header[:50]}...")
+
+            # Try to detect file type
+            if header.startswith(b"<"):
+                raise ValueError(
+                    f"File appears to be HTML/XML, not a PyTorch model: {model_path}"
+                )
+            elif header.startswith(b"\x89PNG"):
+                raise ValueError(f"File appears to be a PNG image: {model_path}")
+            elif header.startswith(b"\xff\xd8\xff"):
+                raise ValueError(f"File appears to be a JPEG image: {model_path}")
+
+            # For any other file type (including ZIP), try to load it directly as a PyTorch model
+            logger.info(
+                f"File appears to be a PyTorch model file, attempting to load directly..."
+            )
+
+            # Load the model
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            try:
+                # Try loading the file directly as a PyTorch model
+                checkpoint = torch.load(
+                    model_path, map_location=device, weights_only=False
+                )
+                logger.info("Successfully loaded model file directly")
+            except Exception as load_error:
+                logger.error(f"Failed to load model directly: {load_error}")
+                try:
+                    # Try with weights only as fallback
+                    checkpoint = torch.load(
+                        model_path, map_location=device, weights_only=True
+                    )
+                    logger.info("Loaded with weights_only=True (weights only)")
+                except Exception as fallback_error:
+                    logger.error(
+                        f"Failed to load with weights_only=True: {fallback_error}"
+                    )
+                    raise ValueError(
+                        f"Cannot load model file {model_path}. File may be corrupted or in wrong format."
+                    )
+
+            # Initialize ResNet-50 model
+            model = models.resnet50(weights=None)
+            num_ftrs = model.fc.in_features
+
+            # Determine number of classes from checkpoint
+            if "fc.weight" in checkpoint:
+                num_classes = checkpoint["fc.weight"].shape[0]
+            else:
+                num_classes = 3  # Default fallback
+
+            model.fc = nn.Linear(num_ftrs, num_classes)
+            model.load_state_dict(checkpoint)
+            model.to(device)
+            model.eval()
+
+            logger.info(f"Vision model loaded successfully with {num_classes} classes!")
+            return model, device, num_classes
+
+        except Exception as e:
+            logger.error(f"Failed to load vision model: {e}")
+            raise
+
+    def load_audio_model(self) -> Tuple[Any, torch.device]:
+        """Load audio sentiment model"""
+        try:
+            model_info = self.model_links["audio"]
+
+            # Check if URL is configured
+            if not model_info["url"]:
+                raise ValueError("AUDIO_MODEL_DRIVE_LINK environment variable not set")
+
+            model_path = self.download_from_google_drive(
+                model_info["url"], model_info["filename"]
+            )
+
+            # Validate the downloaded file
+            if not Path(model_path).exists():
+                raise FileNotFoundError(f"Model file not found at {model_path}")
+
+            file_size = Path(model_path).stat().st_size
+            if file_size == 0:
+                raise ValueError(f"Model file is empty: {model_path}")
+
+            # Check file header to see what type of file it is
+            with open(model_path, "rb") as f:
+                header = f.read(100)  # Read first 100 bytes
+
+            logger.info(f"File size: {file_size} bytes")
+            logger.info(f"File header (first 100 bytes): {header[:50]}...")
+
+            # Try to detect file type
+            if header.startswith(b"<"):
+                raise ValueError(
+                    f"File appears to be HTML/XML, not a PyTorch model: {model_path}"
+                )
+            elif header.startswith(b"\x89PNG"):
+                raise ValueError(f"File appears to be a PNG image: {model_path}")
+            elif header.startswith(b"\xff\xd8\xff"):
+                raise ValueError(f"File appears to be a JPEG image: {model_path}")
+
+            # For any other file type (including ZIP), try to load it directly as a PyTorch model
+            logger.info(
+                f"File appears to be a PyTorch model file, attempting to load directly..."
+            )
+
+            # Load the model
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            try:
+                # Try loading the file directly as a PyTorch model
+                checkpoint = torch.load(
+                    model_path, map_location=device, weights_only=False
+                )
+                logger.info("Successfully loaded model file directly")
+            except Exception as load_error:
+                logger.error(f"Failed to load model directly: {load_error}")
+                try:
+                    # Try with weights only as fallback
+                    checkpoint = torch.load(
+                        model_path, map_location=device, weights_only=True
+                    )
+                    logger.info("Loaded with weights_only=True (weights only)")
+                except Exception as fallback_error:
+                    logger.error(
+                        f"Failed to load with weights_only=True: {fallback_error}"
+                    )
+                    raise ValueError(
+                        f"Cannot load model file {model_path}. File may be corrupted or in wrong format."
+                    )
+
+            # Check if we have a state dict or a full model
+            if isinstance(checkpoint, dict) and "classifier.weight" in checkpoint:
+                # This is a state dictionary - we need to initialize the model first
+                from transformers import AutoModelForAudioClassification
+
+                # Determine number of classes from checkpoint
+                if "classifier.weight" in checkpoint:
+                    num_classes = checkpoint["classifier.weight"].shape[0]
+                else:
+                    num_classes = 3  # Default fallback
+
+                # Initialize Wav2Vec2 model with the correct number of classes
+                model = AutoModelForAudioClassification.from_pretrained(
+                    "facebook/wav2vec2-base", num_labels=num_classes
+                )
+
+                # Load the state dictionary
+                model.load_state_dict(checkpoint)
+                model.to(device)
+                model.eval()
+
+                logger.info(
+                    f"Audio model loaded successfully with {num_classes} classes!"
+                )
+                return model, device
+            else:
+                # This is a full model object
+                model = checkpoint
+                model.to(device)
+                model.eval()
+
+                logger.info("Audio model loaded successfully!")
+                return model, device
+
+        except Exception as e:
+            logger.error(f"Failed to load audio model: {e}")
+            raise
+
+    def update_model_links(self, vision_url: str = None, audio_url: str = None):
+        """Update Google Drive URLs for models (optional override)"""
+        if vision_url:
+            self.model_links["vision"]["url"] = vision_url
+        if audio_url:
+            self.model_links["audio"]["url"] = audio_url
+
+        # Update environment variables if provided
+        if vision_url:
+            os.environ["VISION_MODEL_DRIVE_LINK"] = vision_url
+        if audio_url:
+            os.environ["AUDIO_MODEL_DRIVE_LINK"] = audio_url
+
+        logger.info("Model links updated!")
+
+    def list_cached_models(self) -> list:
+        """List all cached models"""
+        cached_models = []
+        for file_path in self.model_dir.glob("*.pth"):
+            cached_models.append(file_path.name)
+        return cached_models
+
+    def clear_cache(self):
+        """Clear all cached models"""
+        for file_path in self.model_dir.glob("*.pth"):
+            file_path.unlink()
+        logger.info("Cache cleared!")
+
+    def get_model_status(self) -> dict:
+        """Get status of all models"""
+        status = {}
+        for model_type, info in self.model_links.items():
+            status[model_type] = {
+                "configured": bool(info["url"]),
+                "filename": info["filename"],
+                "cached": (self.model_dir / info["filename"]).exists(),
+                "url": info["url"] if info["url"] else "Not configured",
+            }
+        return status
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize manager
+    manager = SimpleModelManager()
+
+    # Check model status
+    status = manager.get_model_status()
+    print("Model Status:")
+    for model_type, info in status.items():
+        print(f"  {model_type}: {'✅' if info['configured'] else '❌'} {info['url']}")
+        if info["cached"]:
+            print(f"    📁 Cached: {info['filename']}")
+
+    # Load models if configured
+    try:
+        if status["vision"]["configured"]:
+            vision_model, device, num_classes = manager.load_vision_model()
+            print(f"✅ Vision model loaded: {num_classes} classes")
+        else:
+            print("❌ Vision model not configured")
+
+        if status["audio"]["configured"]:
+            audio_model, device = manager.load_audio_model()
+            print("✅ Audio model loaded")
+        else:
+            print("❌ Audio model not configured")
+
+        if status["vision"]["configured"] and status["audio"]["configured"]:
+            print("\n🎉 All models loaded successfully!")
+        else:
+            print("\n⚠️  Some models are not configured")
+            print("Please set the following environment variables:")
+            print("  VISION_MODEL_DRIVE_LINK")
+            print("  AUDIO_MODEL_DRIVE_LINK")
+
+    except Exception as e:
+        print(f"Error loading models: {e}")
+        print("\nFor folder structures:")
+        print("   1. Navigate to each subfolder (Audio/Vision)")
+        print("   2. Right-click on each .pth file")
+        print("   3. Share -> Copy link")
+        print("   4. Use those direct file links instead of folder links")
+        print("\nNote: Downloaded files are used directly as PyTorch models.")
+        print("\nOr set environment variables in your .env file:")
+        print("  VISION_MODEL_DRIVE_ID=your_vision_model_file_id")
+        print("  AUDIO_MODEL_DRIVE_ID=your_audio_model_file_id")

test_download.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""
+Test the updated Google Drive download function
+"""
+
+from simple_model_manager import SimpleModelManager
+
+
+def test_download():
+    """Test the download function"""
+    print("Testing Google Drive Download Function")
+    print("=" * 50)
+
+    # Initialize manager
+    manager = SimpleModelManager()
+
+    # Check model status
+    status = manager.get_model_status()
+    print("Model Status:")
+    for model_type, info in status.items():
+        print(f"  {model_type}: {'✅' if info['configured'] else '❌'} {info['url']}")
+        if info["cached"]:
+            print(f"    📁 Cached: {info['filename']}")
+
+    # Test vision model download
+    if status["vision"]["configured"]:
+        print(f"\nTesting vision model download...")
+        try:
+            vision_model, device, num_classes = manager.load_vision_model()
+            print(f"✅ Vision model loaded: {num_classes} classes")
+        except Exception as e:
+            print(f"❌ Vision model failed: {e}")
+    else:
+        print("❌ Vision model not configured")
+
+    # Test audio model download
+    if status["audio"]["configured"]:
+        print(f"\nTesting audio model download...")
+        try:
+            audio_model, device = manager.load_audio_model()
+            print(f"✅ Audio model loaded")
+        except Exception as e:
+            print(f"❌ Audio model failed: {e}")
+    else:
+        print("❌ Audio model not configured")
+
+
+if __name__ == "__main__":
+    test_download()

test_drive_links.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+Test Google Drive links directly to see what's being returned
+"""
+
+import requests
+import os
+from pathlib import Path
+
+
+def test_drive_link(url, filename):
+    """Test a Google Drive link directly"""
+    print(f"\nTesting: {filename}")
+    print(f"URL: {url}")
+
+    try:
+        # Convert Google Drive share link to direct download link
+        if "drive.google.com" in url:
+            if "/file/d/" in url:
+                file_id = url.split("/file/d/")[1].split("/")[0]
+            elif "id=" in url:
+                file_id = url.split("id=")[1].split("&")[0]
+            else:
+                print("❌ Could not extract file ID")
+                return
+
+            direct_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+            print(f"Direct URL: {direct_url}")
+        else:
+            direct_url = url
+
+        # Test the download
+        print("Downloading...")
+        response = requests.get(direct_url, stream=True)
+
+        print(f"Status Code: {response.status_code}")
+        print(f"Content-Type: {response.headers.get('content-type', 'Unknown')}")
+        print(f"Content-Length: {response.headers.get('content-length', 'Unknown')}")
+
+        if response.status_code == 200:
+            # Read first 200 bytes to check content
+            content = response.raw.read(200)
+            print(f"First 200 bytes: {content[:100]}...")
+
+            # Check if it's HTML
+            if content.startswith(b"<!DOCTYPE") or content.startswith(b"<html"):
+                print("❌ ERROR: This is an HTML page, not a model file!")
+                print("   Your Google Drive link is not working properly")
+                print("   Check file permissions and sharing settings")
+            else:
+                print("✅ Looks like a valid file (not HTML)")
+
+                # Save a small sample to check
+                sample_path = f"sample_{filename}"
+                with open(sample_path, "wb") as f:
+                    f.write(content)
+                print(f"Saved sample to: {sample_path}")
+
+        else:
+            print(f"❌ Download failed with status: {response.status_code}")
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+
+def main():
+    print("Google Drive Link Tester")
+    print("=" * 50)
+
+    # Check environment variables
+    vision_url = os.getenv("VISION_MODEL_DRIVE_LINK")
+    audio_url = os.getenv("AUDIO_MODEL_DRIVE_LINK")
+
+    if not vision_url and not audio_url:
+        print("❌ No environment variables found!")
+        print("Please run setup_env.py first or set:")
+        print("  VISION_MODEL_DRIVE_LINK")
+        print("  AUDIO_MODEL_DRIVE_LINK")
+        return
+
+    if vision_url:
+        test_drive_link(vision_url, "resnet50_model.pth")
+
+    if audio_url:
+        test_drive_link(audio_url, "wav2vec2_model.pth")
+
+    print("\n" + "=" * 50)
+    print("If you see HTML content, your Google Drive links need fixing!")
+    print("Make sure:")
+    print("  1. Files are set to 'Anyone with the link can view'")
+    print("  2. You're using direct file links, not folder links")
+    print("  3. Files are not too large for direct download")
+
+
+if __name__ == "__main__":
+    main()

uv.lock

@@ -2,7 +2,233 @@ version = 1
 revision = 2
 requires-python = ">=3.9"
 
+[[package]]
+name = "beautifulsoup4"
+version = "4.13.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/85/2e/3e5079847e653b1f6dc647aa24549d68c6addb4c595cc0d902d1b19308ad/beautifulsoup4-4.13.5.tar.gz", hash = "sha256:5e70131382930e7c3de33450a2f54a63d5e4b19386eab43a5b34d594268f3695", size = 622954, upload_time = "2025-08-24T14:06:13.168Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/eb/f4151e0c7377a6e08a38108609ba5cede57986802757848688aeedd1b9e8/beautifulsoup4-4.13.5-py3-none-any.whl", hash = "sha256:642085eaa22233aceadff9c69651bc51e8bf3f874fb6d7104ece2beb24b47c4a", size = 105113, upload_time = "2025-08-24T14:06:14.884Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", hash = "sha256:e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407", size = 162386, upload_time = "2025-08-03T03:07:47.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload_time = "2025-08-03T03:07:45.777Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/2d/5fd176ceb9b2fc619e63405525573493ca23441330fcdaee6bef9460e924/charset_normalizer-3.4.3.tar.gz", hash = "sha256:6fce4b8500244f6fcb71465d4a4930d132ba9ab8e71a7859e6a5d59851068d14", size = 122371, upload_time = "2025-08-09T07:57:28.46Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/98/f3b8013223728a99b908c9344da3aa04ee6e3fa235f19409033eda92fb78/charset_normalizer-3.4.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fb7f67a1bfa6e40b438170ebdc8158b78dc465a5a67b6dde178a46987b244a72", size = 207695, upload_time = "2025-08-09T07:55:36.452Z" },
+    { url = "https://files.pythonhosted.org/packages/21/40/5188be1e3118c82dcb7c2a5ba101b783822cfb413a0268ed3be0468532de/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc9370a2da1ac13f0153780040f465839e6cccb4a1e44810124b4e22483c93fe", size = 147153, upload_time = "2025-08-09T07:55:38.467Z" },
+    { url = "https://files.pythonhosted.org/packages/37/60/5d0d74bc1e1380f0b72c327948d9c2aca14b46a9efd87604e724260f384c/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:07a0eae9e2787b586e129fdcbe1af6997f8d0e5abaa0bc98c0e20e124d67e601", size = 160428, upload_time = "2025-08-09T07:55:40.072Z" },
+    { url = "https://files.pythonhosted.org/packages/85/9a/d891f63722d9158688de58d050c59dc3da560ea7f04f4c53e769de5140f5/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:74d77e25adda8581ffc1c720f1c81ca082921329452eba58b16233ab1842141c", size = 157627, upload_time = "2025-08-09T07:55:41.706Z" },
+    { url = "https://files.pythonhosted.org/packages/65/1a/7425c952944a6521a9cfa7e675343f83fd82085b8af2b1373a2409c683dc/charset_normalizer-3.4.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0e909868420b7049dafd3a31d45125b31143eec59235311fc4c57ea26a4acd2", size = 152388, upload_time = "2025-08-09T07:55:43.262Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c9/a2c9c2a355a8594ce2446085e2ec97fd44d323c684ff32042e2a6b718e1d/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c6f162aabe9a91a309510d74eeb6507fab5fff92337a15acbe77753d88d9dcf0", size = 150077, upload_time = "2025-08-09T07:55:44.903Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/38/20a1f44e4851aa1c9105d6e7110c9d020e093dfa5836d712a5f074a12bf7/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca4c094de7771a98d7fbd67d9e5dbf1eb73efa4f744a730437d8a3a5cf994f0", size = 161631, upload_time = "2025-08-09T07:55:46.346Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/fa/384d2c0f57edad03d7bec3ebefb462090d8905b4ff5a2d2525f3bb711fac/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:02425242e96bcf29a49711b0ca9f37e451da7c70562bc10e8ed992a5a7a25cc0", size = 159210, upload_time = "2025-08-09T07:55:47.539Z" },
+    { url = "https://files.pythonhosted.org/packages/33/9e/eca49d35867ca2db336b6ca27617deed4653b97ebf45dfc21311ce473c37/charset_normalizer-3.4.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:78deba4d8f9590fe4dae384aeff04082510a709957e968753ff3c48399f6f92a", size = 153739, upload_time = "2025-08-09T07:55:48.744Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/91/26c3036e62dfe8de8061182d33be5025e2424002125c9500faff74a6735e/charset_normalizer-3.4.3-cp310-cp310-win32.whl", hash = "sha256:d79c198e27580c8e958906f803e63cddb77653731be08851c7df0b1a14a8fc0f", size = 99825, upload_time = "2025-08-09T07:55:50.305Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/c6/f05db471f81af1fa01839d44ae2a8bfeec8d2a8b4590f16c4e7393afd323/charset_normalizer-3.4.3-cp310-cp310-win_amd64.whl", hash = "sha256:c6e490913a46fa054e03699c70019ab869e990270597018cef1d8562132c2669", size = 107452, upload_time = "2025-08-09T07:55:51.461Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/b5/991245018615474a60965a7c9cd2b4efbaabd16d582a5547c47ee1c7730b/charset_normalizer-3.4.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b256ee2e749283ef3ddcff51a675ff43798d92d746d1a6e4631bf8c707d22d0b", size = 204483, upload_time = "2025-08-09T07:55:53.12Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2a/ae245c41c06299ec18262825c1569c5d3298fc920e4ddf56ab011b417efd/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13faeacfe61784e2559e690fc53fa4c5ae97c6fcedb8eb6fb8d0a15b475d2c64", size = 145520, upload_time = "2025-08-09T07:55:54.712Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/a4/b3b6c76e7a635748c4421d2b92c7b8f90a432f98bda5082049af37ffc8e3/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:00237675befef519d9af72169d8604a067d92755e84fe76492fef5441db05b91", size = 158876, upload_time = "2025-08-09T07:55:56.024Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e6/63bb0e10f90a8243c5def74b5b105b3bbbfb3e7bb753915fe333fb0c11ea/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:585f3b2a80fbd26b048a0be90c5aae8f06605d3c92615911c3a2b03a8a3b796f", size = 156083, upload_time = "2025-08-09T07:55:57.582Z" },
+    { url = "https://files.pythonhosted.org/packages/87/df/b7737ff046c974b183ea9aa111b74185ac8c3a326c6262d413bd5a1b8c69/charset_normalizer-3.4.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e78314bdc32fa80696f72fa16dc61168fda4d6a0c014e0380f9d02f0e5d8a07", size = 150295, upload_time = "2025-08-09T07:55:59.147Z" },
+    { url = "https://files.pythonhosted.org/packages/61/f1/190d9977e0084d3f1dc169acd060d479bbbc71b90bf3e7bf7b9927dec3eb/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:96b2b3d1a83ad55310de8c7b4a2d04d9277d5591f40761274856635acc5fcb30", size = 148379, upload_time = "2025-08-09T07:56:00.364Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/92/27dbe365d34c68cfe0ca76f1edd70e8705d82b378cb54ebbaeabc2e3029d/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:939578d9d8fd4299220161fdd76e86c6a251987476f5243e8864a7844476ba14", size = 160018, upload_time = "2025-08-09T07:56:01.678Z" },
+    { url = "https://files.pythonhosted.org/packages/99/04/baae2a1ea1893a01635d475b9261c889a18fd48393634b6270827869fa34/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:fd10de089bcdcd1be95a2f73dbe6254798ec1bda9f450d5828c96f93e2536b9c", size = 157430, upload_time = "2025-08-09T07:56:02.87Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/36/77da9c6a328c54d17b960c89eccacfab8271fdaaa228305330915b88afa9/charset_normalizer-3.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1e8ac75d72fa3775e0b7cb7e4629cec13b7514d928d15ef8ea06bca03ef01cae", size = 151600, upload_time = "2025-08-09T07:56:04.089Z" },
+    { url = "https://files.pythonhosted.org/packages/64/d4/9eb4ff2c167edbbf08cdd28e19078bf195762e9bd63371689cab5ecd3d0d/charset_normalizer-3.4.3-cp311-cp311-win32.whl", hash = "sha256:6cf8fd4c04756b6b60146d98cd8a77d0cdae0e1ca20329da2ac85eed779b6849", size = 99616, upload_time = "2025-08-09T07:56:05.658Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/9c/996a4a028222e7761a96634d1820de8a744ff4327a00ada9c8942033089b/charset_normalizer-3.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:31a9a6f775f9bcd865d88ee350f0ffb0e25936a7f930ca98995c05abf1faf21c", size = 107108, upload_time = "2025-08-09T07:56:07.176Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5e/14c94999e418d9b87682734589404a25854d5f5d0408df68bc15b6ff54bb/charset_normalizer-3.4.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e28e334d3ff134e88989d90ba04b47d84382a828c061d0d1027b1b12a62b39b1", size = 205655, upload_time = "2025-08-09T07:56:08.475Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a8/c6ec5d389672521f644505a257f50544c074cf5fc292d5390331cd6fc9c3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0cacf8f7297b0c4fcb74227692ca46b4a5852f8f4f24b3c766dd94a1075c4884", size = 146223, upload_time = "2025-08-09T07:56:09.708Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/eb/a2ffb08547f4e1e5415fb69eb7db25932c52a52bed371429648db4d84fb1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c6fd51128a41297f5409deab284fecbe5305ebd7e5a1f959bee1c054622b7018", size = 159366, upload_time = "2025-08-09T07:56:11.326Z" },
+    { url = "https://files.pythonhosted.org/packages/82/10/0fd19f20c624b278dddaf83b8464dcddc2456cb4b02bb902a6da126b87a1/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cfb2aad70f2c6debfbcb717f23b7eb55febc0bb23dcffc0f076009da10c6392", size = 157104, upload_time = "2025-08-09T07:56:13.014Z" },
+    { url = "https://files.pythonhosted.org/packages/16/ab/0233c3231af734f5dfcf0844aa9582d5a1466c985bbed6cedab85af9bfe3/charset_normalizer-3.4.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1606f4a55c0fd363d754049cdf400175ee96c992b1f8018b993941f221221c5f", size = 151830, upload_time = "2025-08-09T07:56:14.428Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/02/e29e22b4e02839a0e4a06557b1999d0a47db3567e82989b5bb21f3fbbd9f/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:027b776c26d38b7f15b26a5da1044f376455fb3766df8fc38563b4efbc515154", size = 148854, upload_time = "2025-08-09T07:56:16.051Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6b/e2539a0a4be302b481e8cafb5af8792da8093b486885a1ae4d15d452bcec/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:42e5088973e56e31e4fa58eb6bd709e42fc03799c11c42929592889a2e54c491", size = 160670, upload_time = "2025-08-09T07:56:17.314Z" },
+    { url = "https://files.pythonhosted.org/packages/31/e7/883ee5676a2ef217a40ce0bffcc3d0dfbf9e64cbcfbdf822c52981c3304b/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cc34f233c9e71701040d772aa7490318673aa7164a0efe3172b2981218c26d93", size = 158501, upload_time = "2025-08-09T07:56:18.641Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/35/6525b21aa0db614cf8b5792d232021dca3df7f90a1944db934efa5d20bb1/charset_normalizer-3.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320e8e66157cc4e247d9ddca8e21f427efc7a04bbd0ac8a9faf56583fa543f9f", size = 153173, upload_time = "2025-08-09T07:56:20.289Z" },
+    { url = "https://files.pythonhosted.org/packages/50/ee/f4704bad8201de513fdc8aac1cabc87e38c5818c93857140e06e772b5892/charset_normalizer-3.4.3-cp312-cp312-win32.whl", hash = "sha256:fb6fecfd65564f208cbf0fba07f107fb661bcd1a7c389edbced3f7a493f70e37", size = 99822, upload_time = "2025-08-09T07:56:21.551Z" },
+    { url = "https://files.pythonhosted.org/packages/39/f5/3b3836ca6064d0992c58c7561c6b6eee1b3892e9665d650c803bd5614522/charset_normalizer-3.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:86df271bf921c2ee3818f0522e9a5b8092ca2ad8b065ece5d7d9d0e9f4849bcc", size = 107543, upload_time = "2025-08-09T07:56:23.115Z" },
+    { url = "https://files.pythonhosted.org/packages/65/ca/2135ac97709b400c7654b4b764daf5c5567c2da45a30cdd20f9eefe2d658/charset_normalizer-3.4.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:14c2a87c65b351109f6abfc424cab3927b3bdece6f706e4d12faaf3d52ee5efe", size = 205326, upload_time = "2025-08-09T07:56:24.721Z" },
+    { url = "https://files.pythonhosted.org/packages/71/11/98a04c3c97dd34e49c7d247083af03645ca3730809a5509443f3c37f7c99/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41d1fc408ff5fdfb910200ec0e74abc40387bccb3252f3f27c0676731df2b2c8", size = 146008, upload_time = "2025-08-09T07:56:26.004Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f5/4659a4cb3c4ec146bec80c32d8bb16033752574c20b1252ee842a95d1a1e/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1bb60174149316da1c35fa5233681f7c0f9f514509b8e399ab70fea5f17e45c9", size = 159196, upload_time = "2025-08-09T07:56:27.25Z" },
+    { url = "https://files.pythonhosted.org/packages/86/9e/f552f7a00611f168b9a5865a1414179b2c6de8235a4fa40189f6f79a1753/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:30d006f98569de3459c2fc1f2acde170b7b2bd265dc1943e87e1a4efe1b67c31", size = 156819, upload_time = "2025-08-09T07:56:28.515Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/95/42aa2156235cbc8fa61208aded06ef46111c4d3f0de233107b3f38631803/charset_normalizer-3.4.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:416175faf02e4b0810f1f38bcb54682878a4af94059a1cd63b8747244420801f", size = 151350, upload_time = "2025-08-09T07:56:29.716Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/a9/3865b02c56f300a6f94fc631ef54f0a8a29da74fb45a773dfd3dcd380af7/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6aab0f181c486f973bc7262a97f5aca3ee7e1437011ef0c2ec04b5a11d16c927", size = 148644, upload_time = "2025-08-09T07:56:30.984Z" },
+    { url = "https://files.pythonhosted.org/packages/77/d9/cbcf1a2a5c7d7856f11e7ac2d782aec12bdfea60d104e60e0aa1c97849dc/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fdabf8315679312cfa71302f9bd509ded4f2f263fb5b765cf1433b39106c3cc9", size = 160468, upload_time = "2025-08-09T07:56:32.252Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/42/6f45efee8697b89fda4d50580f292b8f7f9306cb2971d4b53f8914e4d890/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:bd28b817ea8c70215401f657edef3a8aa83c29d447fb0b622c35403780ba11d5", size = 158187, upload_time = "2025-08-09T07:56:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/70/99/f1c3bdcfaa9c45b3ce96f70b14f070411366fa19549c1d4832c935d8e2c3/charset_normalizer-3.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:18343b2d246dc6761a249ba1fb13f9ee9a2bcd95decc767319506056ea4ad4dc", size = 152699, upload_time = "2025-08-09T07:56:34.739Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/ad/b0081f2f99a4b194bcbb1934ef3b12aa4d9702ced80a37026b7607c72e58/charset_normalizer-3.4.3-cp313-cp313-win32.whl", hash = "sha256:6fb70de56f1859a3f71261cbe41005f56a7842cc348d3aeb26237560bfa5e0ce", size = 99580, upload_time = "2025-08-09T07:56:35.981Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/8f/ae790790c7b64f925e5c953b924aaa42a243fb778fed9e41f147b2a5715a/charset_normalizer-3.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:cf1ebb7d78e1ad8ec2a8c4732c7be2e736f6e5123a4146c5b89c9d1f585f8cef", size = 107366, upload_time = "2025-08-09T07:56:37.339Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/91/b5a06ad970ddc7a0e513112d40113e834638f4ca1120eb727a249fb2715e/charset_normalizer-3.4.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3cd35b7e8aedeb9e34c41385fda4f73ba609e561faedfae0a9e75e44ac558a15", size = 204342, upload_time = "2025-08-09T07:56:38.687Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ec/1edc30a377f0a02689342f214455c3f6c2fbedd896a1d2f856c002fc3062/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b89bc04de1d83006373429975f8ef9e7932534b8cc9ca582e4db7d20d91816db", size = 145995, upload_time = "2025-08-09T07:56:40.048Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e5/5e67ab85e6d22b04641acb5399c8684f4d37caf7558a53859f0283a650e9/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2001a39612b241dae17b4687898843f254f8748b796a2e16f1051a17078d991d", size = 158640, upload_time = "2025-08-09T07:56:41.311Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/e5/38421987f6c697ee3722981289d554957c4be652f963d71c5e46a262e135/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8dcfc373f888e4fb39a7bc57e93e3b845e7f462dacc008d9749568b1c4ece096", size = 156636, upload_time = "2025-08-09T07:56:43.195Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/e4/5a075de8daa3ec0745a9a3b54467e0c2967daaaf2cec04c845f73493e9a1/charset_normalizer-3.4.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18b97b8404387b96cdbd30ad660f6407799126d26a39ca65729162fd810a99aa", size = 150939, upload_time = "2025-08-09T07:56:44.819Z" },
+    { url = "https://files.pythonhosted.org/packages/02/f7/3611b32318b30974131db62b4043f335861d4d9b49adc6d57c1149cc49d4/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ccf600859c183d70eb47e05a44cd80a4ce77394d1ac0f79dbd2dd90a69a3a049", size = 148580, upload_time = "2025-08-09T07:56:46.684Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/61/19b36f4bd67f2793ab6a99b979b4e4f3d8fc754cbdffb805335df4337126/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:53cd68b185d98dde4ad8990e56a58dea83a4162161b1ea9272e5c9182ce415e0", size = 159870, upload_time = "2025-08-09T07:56:47.941Z" },
+    { url = "https://files.pythonhosted.org/packages/06/57/84722eefdd338c04cf3030ada66889298eaedf3e7a30a624201e0cbe424a/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:30a96e1e1f865f78b030d65241c1ee850cdf422d869e9028e2fc1d5e4db73b92", size = 157797, upload_time = "2025-08-09T07:56:49.756Z" },
+    { url = "https://files.pythonhosted.org/packages/72/2a/aff5dd112b2f14bcc3462c312dce5445806bfc8ab3a7328555da95330e4b/charset_normalizer-3.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d716a916938e03231e86e43782ca7878fb602a125a91e7acb8b5112e2e96ac16", size = 152224, upload_time = "2025-08-09T07:56:51.369Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/8c/9839225320046ed279c6e839d51f028342eb77c91c89b8ef2549f951f3ec/charset_normalizer-3.4.3-cp314-cp314-win32.whl", hash = "sha256:c6dbd0ccdda3a2ba7c2ecd9d77b37f3b5831687d8dc1b6ca5f56a4880cc7b7ce", size = 100086, upload_time = "2025-08-09T07:56:52.722Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/7a/36fbcf646e41f710ce0a563c1c9a343c6edf9be80786edeb15b6f62e17db/charset_normalizer-3.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:73dc19b562516fc9bcf6e5d6e596df0b4eb98d87e4f79f3ae71840e6ed21361c", size = 107400, upload_time = "2025-08-09T07:56:55.172Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/ca/9a0983dd5c8e9733565cf3db4df2b0a2e9a82659fd8aa2a868ac6e4a991f/charset_normalizer-3.4.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:70bfc5f2c318afece2f5838ea5e4c3febada0be750fcf4775641052bbba14d05", size = 207520, upload_time = "2025-08-09T07:57:11.026Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c6/99271dc37243a4f925b09090493fb96c9333d7992c6187f5cfe5312008d2/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23b6b24d74478dc833444cbd927c338349d6ae852ba53a0d02a2de1fce45b96e", size = 147307, upload_time = "2025-08-09T07:57:12.4Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/69/132eab043356bba06eb333cc2cc60c6340857d0a2e4ca6dc2b51312886b3/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:34a7f768e3f985abdb42841e20e17b330ad3aaf4bb7e7aeeb73db2e70f077b99", size = 160448, upload_time = "2025-08-09T07:57:13.712Z" },
+    { url = "https://files.pythonhosted.org/packages/04/9a/914d294daa4809c57667b77470533e65def9c0be1ef8b4c1183a99170e9d/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb731e5deb0c7ef82d698b0f4c5bb724633ee2a489401594c5c88b02e6cb15f7", size = 157758, upload_time = "2025-08-09T07:57:14.979Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/a8/6f5bcf1bcf63cb45625f7c5cadca026121ff8a6c8a3256d8d8cd59302663/charset_normalizer-3.4.3-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:257f26fed7d7ff59921b78244f3cd93ed2af1800ff048c33f624c87475819dd7", size = 152487, upload_time = "2025-08-09T07:57:16.332Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/72/d3d0e9592f4e504f9dea08b8db270821c909558c353dc3b457ed2509f2fb/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1ef99f0456d3d46a50945c98de1774da86f8e992ab5c77865ea8b8195341fc19", size = 150054, upload_time = "2025-08-09T07:57:17.576Z" },
+    { url = "https://files.pythonhosted.org/packages/20/30/5f64fe3981677fe63fa987b80e6c01042eb5ff653ff7cec1b7bd9268e54e/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:2c322db9c8c89009a990ef07c3bcc9f011a3269bc06782f916cd3d9eed7c9312", size = 161703, upload_time = "2025-08-09T07:57:20.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/ef/dd08b2cac9284fd59e70f7d97382c33a3d0a926e45b15fc21b3308324ffd/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:511729f456829ef86ac41ca78c63a5cb55240ed23b4b737faca0eb1abb1c41bc", size = 159096, upload_time = "2025-08-09T07:57:21.329Z" },
+    { url = "https://files.pythonhosted.org/packages/45/8c/dcef87cfc2b3f002a6478f38906f9040302c68aebe21468090e39cde1445/charset_normalizer-3.4.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:88ab34806dea0671532d3f82d82b85e8fc23d7b2dd12fa837978dad9bb392a34", size = 153852, upload_time = "2025-08-09T07:57:22.608Z" },
+    { url = "https://files.pythonhosted.org/packages/63/86/9cbd533bd37883d467fcd1bd491b3547a3532d0fbb46de2b99feeebf185e/charset_normalizer-3.4.3-cp39-cp39-win32.whl", hash = "sha256:16a8770207946ac75703458e2c743631c79c59c5890c80011d536248f8eaa432", size = 99840, upload_time = "2025-08-09T07:57:23.883Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d6/7e805c8e5c46ff9729c49950acc4ee0aeb55efb8b3a56687658ad10c3216/charset_normalizer-3.4.3-cp39-cp39-win_amd64.whl", hash = "sha256:d22dbedd33326a4a5190dd4fe9e9e693ef12160c77382d9e87919bce54f3d4ca", size = 107438, upload_time = "2025-08-09T07:57:25.287Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/1f/f041989e93b001bc4e44bb1669ccdcf54d3f00e628229a85b08d330615c5/charset_normalizer-3.4.3-py3-none-any.whl", hash = "sha256:ce571ab16d890d23b5c278547ba694193a45011ff86a9162a71307ed9f86759a", size = 53175, upload_time = "2025-08-09T07:57:26.864Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload_time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload_time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.19.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/bb/0ab3e58d22305b6f5440629d20683af28959bf793d98d11950e305c1c326/filelock-3.19.1.tar.gz", hash = "sha256:66eda1888b0171c998b35be2bcc0f6d75c388a7ce20c3f3f37aa8e96c2dddf58", size = 17687, upload_time = "2025-08-14T16:56:03.016Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/14/42b2651a2f46b022ccd948bca9f2d5af0fd8929c4eec235b8d6d844fbe67/filelock-3.19.1-py3-none-any.whl", hash = "sha256:d38e30481def20772f5baf097c122c3babc4fcdb7e14e57049eb9d88c6dc017d", size = 15988, upload_time = "2025-08-14T16:56:01.633Z" },
+]
+
+[[package]]
+name = "gdown"
+version = "5.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "filelock" },
+    { name = "requests", extra = ["socks"] },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/6a/37e6b70c5bda3161e40265861e63b64a86bfc6ca6a8f1c35328a675c84fd/gdown-5.2.0.tar.gz", hash = "sha256:2145165062d85520a3cd98b356c9ed522c5e7984d408535409fd46f94defc787", size = 284647, upload_time = "2024-05-12T06:45:12.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/70/e07c381e6488a77094f04c85c9caf1c8008cdc30778f7019bc52e5285ef0/gdown-5.2.0-py3-none-any.whl", hash = "sha256:33083832d82b1101bdd0e9df3edd0fbc0e1c5f14c9d8c38d2a35bf1683b526d6", size = 18235, upload_time = "2024-05-12T06:45:10.017Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload_time = "2024-09-15T18:07:39.745Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload_time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "pysocks"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0", size = 284429, upload_time = "2019-09-20T02:07:35.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725, upload_time = "2019-09-20T02:06:22.938Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload_time = "2025-06-24T04:21:07.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload_time = "2025-06-24T04:21:06.073Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload_time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload_time = "2025-08-18T20:46:00.542Z" },
+]
+
+[package.optional-dependencies]
+socks = [
+    { name = "pysocks" },
+]
+
 [[package]]
 name = "sentiment-fused"
 version = "0.1.0"
 source = { virtual = "." }
+dependencies = [
+    { name = "gdown" },
+    { name = "python-dotenv" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "gdown", specifier = ">=5.2.0" },
+    { name = "python-dotenv", specifier = ">=1.1.1" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload_time = "2025-04-20T18:50:08.518Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload_time = "2025-04-20T18:50:07.196Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload_time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload_time = "2024-11-24T20:12:19.698Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.14.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload_time = "2025-07-04T13:28:34.16Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload_time = "2025-07-04T13:28:32.743Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload_time = "2025-06-18T14:07:41.644Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload_time = "2025-06-18T14:07:40.39Z" },
+]