Update app.py

app.py

@@ -19,26 +19,81 @@ import time
 app = Flask(__name__)
 CORS(app)
 
-# Initialize AI models
+# Initialize AI models with fallback options
 print("Loading AI models...")
+
+# Global flags for model availability
+MODELS_AVAILABLE = {
+    'caption': False,
+    'text_gen': False,
+    'sentiment': False
+}
+
+# Try to load models with fallbacks
 try:
-    # Image captioning for smart suggestions
-    caption_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
-    caption_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+    # Set cache directory with proper permissions
+    os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers_cache'
+    os.environ['HF_HOME'] = '/tmp/hf_cache'
     
-    # Text generation for meme text
-    text_generator = pipeline("text-generation", 
-                            model="microsoft/DialoGPT-medium",
-                            tokenizer="microsoft/DialoGPT-medium")
+    # Create cache directories
+    os.makedirs('/tmp/transformers_cache', exist_ok=True)
+    os.makedirs('/tmp/hf_cache', exist_ok=True)
+    
+    print("Attempting to load image captioning model...")
+    caption_processor = BlipProcessor.from_pretrained(
+        "Salesforce/blip-image-captioning-base",
+        cache_dir='/tmp/transformers_cache',
+        use_fast=False
+    )
+    caption_model = BlipForConditionalGeneration.from_pretrained(
+        "Salesforce/blip-image-captioning-base",
+        cache_dir='/tmp/transformers_cache'
+    )
+    MODELS_AVAILABLE['caption'] = True
+    print("✓ Image captioning model loaded")
+    
+except Exception as e:
+    print(f"⚠ Image captioning model failed: {e}")
+    caption_processor = None
+    caption_model = None
+
+try:
+    print("Attempting to load sentiment analyzer...")
+    sentiment_analyzer = pipeline(
+        "sentiment-analysis",
+        model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+        cache_dir='/tmp/transformers_cache'
+    )
+    MODELS_AVAILABLE['sentiment'] = True
+    print("✓ Sentiment analyzer loaded")
     
-    # Sentiment analysis for mood-based memes
-    sentiment_analyzer = pipeline("sentiment-analysis", 
-                                model="cardiffnlp/twitter-roberta-base-sentiment-latest")
+except Exception as e:
+    print(f"⚠ Sentiment analyzer failed: {e}")
+    # Use a lighter fallback model
+    try:
+        sentiment_analyzer = pipeline("sentiment-analysis", cache_dir='/tmp/transformers_cache')
+        MODELS_AVAILABLE['sentiment'] = True
+        print("✓ Fallback sentiment analyzer loaded")
+    except:
+        sentiment_analyzer = None
+        print("⚠ All sentiment models failed")
+
+try:
+    print("Attempting to load text generator...")
+    text_generator = pipeline(
+        "text-generation",
+        model="gpt2",  # Lighter model
+        cache_dir='/tmp/transformers_cache'
+    )
+    MODELS_AVAILABLE['text_gen'] = True
+    print("✓ Text generator loaded")
     
-    print("Models loaded successfully!")
 except Exception as e:
-    print(f"Error loading models: {e}")
-    # Fallback to mock responses if models fail to load
+    print(f"⚠ Text generator failed: {e}")
+    text_generator = None
+
+print(f"Models loaded: {sum(MODELS_AVAILABLE.values())}/3")
+print("Fallback systems enabled for failed models")
 
 # Meme templates and trending data
 MEME_TEMPLATES = {
@@ -71,27 +126,66 @@ class MemeAI:
         
     def analyze_image(self, image):
         """Analyze image and generate smart suggestions"""
-        try:
-            # Generate caption
-            inputs = caption_processor(image, return_tensors="pt")
-            out = caption_model.generate(**inputs, max_length=50)
-            caption = caption_processor.decode(out[0], skip_special_tokens=True)
-            
-            # Extract key objects/concepts
-            keywords = self.extract_keywords(caption)
-            
-            return {
-                "caption": caption,
-                "keywords": keywords,
-                "suggestions": self.generate_text_suggestions(keywords)
-            }
-        except Exception as e:
-            print(f"Image analysis error: {e}")
-            return {
-                "caption": "Image uploaded",
-                "keywords": ["general"],
-                "suggestions": self.get_generic_suggestions()
-            }
+        if MODELS_AVAILABLE['caption'] and caption_processor and caption_model:
+            try:
+                # Generate caption using AI model
+                inputs = caption_processor(image, return_tensors="pt")
+                out = caption_model.generate(**inputs, max_length=50)
+                caption = caption_processor.decode(out[0], skip_special_tokens=True)
+                
+                # Extract key objects/concepts
+                keywords = self.extract_keywords(caption)
+                
+                return {
+                    "caption": caption,
+                    "keywords": keywords,
+                    "suggestions": self.generate_text_suggestions(keywords),
+                    "ai_powered": True
+                }
+            except Exception as e:
+                print(f"AI image analysis error: {e}")
+        
+        # Fallback to rule-based analysis
+        return self.analyze_image_fallback(image)
+    
+    def analyze_image_fallback(self, image):
+        """Fallback image analysis when AI models aren't available"""
+        # Simple image property analysis
+        width, height = image.size
+        mode = image.mode
+        
+        # Basic heuristics
+        keywords = []
+        caption = "Image uploaded"
+        
+        # Aspect ratio heuristics
+        aspect_ratio = width / height
+        if aspect_ratio > 1.5:
+            keywords.extend(["landscape", "wide", "horizontal"])
+            caption = "Wide image uploaded"
+        elif aspect_ratio < 0.7:
+            keywords.extend(["portrait", "vertical", "tall"])
+            caption = "Tall image uploaded"
+        else:
+            keywords.extend(["square", "balanced"])
+            caption = "Square image uploaded"
+        
+        # Color mode heuristics
+        if mode == "RGBA":
+            keywords.append("transparent")
+        elif mode == "L":
+            keywords.extend(["grayscale", "black and white"])
+        
+        # Add generic meme-friendly keywords
+        keywords.extend(["meme", "funny", "relatable"])
+        
+        return {
+            "caption": caption,
+            "keywords": keywords[:5],
+            "suggestions": self.generate_text_suggestions(keywords),
+            "ai_powered": False,
+            "note": "Using fallback analysis - upgrade for AI-powered insights"
+        }
     
     def extract_keywords(self, text):
         """Extract meaningful keywords from image caption"""
@@ -149,20 +243,55 @@ class MemeAI:
     
     def analyze_mood(self, text):
         """Analyze text mood for personalized suggestions"""
-        try:
-            result = sentiment_analyzer(text)[0]
-            mood = result['label'].lower()
-            confidence = result['score']
-            
-            mood_suggestions = {
-                'positive': ["You're killing it!", "Main character energy", "That's the spirit!"],
-                'negative': ["This is fine", "Why are we here?", "Everything is chaos"],
-                'neutral': ["It be like that sometimes", "Just vibing", "No thoughts, head empty"]
-            }
-            
-            return mood_suggestions.get(mood, mood_suggestions['neutral'])
-        except:
-            return self.get_generic_suggestions()
+        if MODELS_AVAILABLE['sentiment'] and sentiment_analyzer:
+            try:
+                result = sentiment_analyzer(text)[0]
+                # Handle different sentiment model outputs
+                if 'label' in result:
+                    mood = result['label'].lower()
+                    # Convert labels to standard format
+                    if 'pos' in mood or mood == 'positive':
+                        mood = 'positive'
+                    elif 'neg' in mood or mood == 'negative':
+                        mood = 'negative'
+                    else:
+                        mood = 'neutral'
+                else:
+                    mood = 'neutral'
+                
+                confidence = result.get('score', 0.5)
+                
+                mood_suggestions = {
+                    'positive': ["You're killing it!", "Main character energy", "That's the spirit!", "Living your best life"],
+                    'negative': ["This is fine", "Why are we here?", "Everything is chaos", "Big oof energy"],
+                    'neutral': ["It be like that sometimes", "Just vibing", "No thoughts, head empty", "Existing peacefully"]
+                }
+                
+                suggestions = mood_suggestions.get(mood, mood_suggestions['neutral'])
+                return suggestions + [f"When you're feeling {mood}"]
+                
+            except Exception as e:
+                print(f"Sentiment analysis error: {e}")
+        
+        # Fallback mood analysis
+        return self.analyze_mood_fallback(text)
+    
+    def analyze_mood_fallback(self, text):
+        """Fallback mood analysis using keyword matching"""
+        text_lower = text.lower()
+        
+        positive_words = ['good', 'great', 'awesome', 'happy', 'love', 'best', 'amazing', 'wonderful']
+        negative_words = ['bad', 'awful', 'hate', 'worst', 'terrible', 'sad', 'angry', 'frustrated']
+        
+        pos_count = sum(1 for word in positive_words if word in text_lower)
+        neg_count = sum(1 for word in negative_words if word in text_lower)
+        
+        if pos_count > neg_count:
+            return ["You're killing it!", "Positive vibes only", "That energy though"]
+        elif neg_count > pos_count:
+            return ["This is fine", "We've all been there", "Mood honestly"]
+        else:
+            return ["It be like that", "Just existing", "Neutral chaos energy"]
     
     def get_trending_suggestions(self):
         """Generate suggestions based on trending topics"""
@@ -216,7 +345,12 @@ meme_ai = MemeAI()
 
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({"status": "healthy", "timestamp": datetime.now().isoformat()})
+    return jsonify({
+        "status": "healthy", 
+        "timestamp": datetime.now().isoformat(),
+        "models_loaded": MODELS_AVAILABLE,
+        "ai_features": sum(MODELS_AVAILABLE.values())
+    })
 
 @app.route('/analyze-image', methods=['POST'])
 def analyze_image():