Sync from GitHub kumarsrinivasbobba/case_study_1@cf796927435e8a4b0e2e91e4f713110439fbbea2

.gitignore

@@ -0,0 +1,81 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Model cache (can be large)
+*.bin
+*.safetensors
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Gradio
+flagged/

README.md

@@ -0,0 +1,45 @@
+---
+title: DreamWeaver AI - Local Transformers
+emoji: 🌙
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+python_version: "3.10"
+app_file: app.py
+pinned: false
+license: mit
+short_description: Dream journal & interpreter (local Transformers)
+---
+
+# 🌙 DreamWeaver AI - Dream Journal & Interpreter
+
+An innovative AI-powered dream analysis tool that interprets your dreams, identifies emotional themes, and generates creative dream-inspired stories.
+
+## Features
+
+- 🎭 **Emotional Analysis**: Detect the emotional undertones of your dreams
+- 🔮 **Symbol Detection**: Identify and interpret common dream symbols  
+- 📖 **AI Interpretation**: Get personalized dream interpretations
+- ✨ **Story Generation**: Transform dreams into creative stories
+- 🎨 **Visual Prompts**: Generate prompts for AI image generators
+- 📔 **Dream Journal**: Save and format your dream entries
+
+## Architecture
+
+This is the **Local Transformers Version** which uses:
+- `transformers` pipelines for model inference (models are downloaded to the Space)
+- Gradio for the user interface
+- Hosted on Hugging Face Spaces
+
+## Models Used
+
+- `j-hartmann/emotion-english-distilroberta-base` - Emotion classification
+- `distilgpt2` - Lightweight text generation for interpretations and stories
+
+## Citations
+
+- Hugging Face Transformers Documentation
+- Gradio Documentation
+- Dream symbolism inspired by Jungian psychology
+- GitHub Copilot for code assistance

app.py

@@ -0,0 +1,592 @@
+"""
+🌙 DreamWeaver AI - Dream Journal & Interpreter (Local Transformers Version)
+====================================================================
+An innovative AI-powered dream analysis tool that interprets your dreams,
+identifies emotional themes, and generates creative dream-inspired stories.
+
+This version uses local Transformers pipelines (downloaded at runtime) for model execution.
+
+Citations:
+- Hugging Face Transformers Documentation
+- Gradio Documentation (gradio.app)
+- GitHub Copilot for code assistance
+- Dream symbolism inspired by Jungian psychology concepts
+"""
+
+import gradio as gr
+import time
+import random
+import os
+from datetime import datetime
+
+
+class _LabelScore:
+    def __init__(self, label: str, score: float):
+        self.label = label
+        self.score = score
+
+
+class LocalTransformersClient:
+    """A tiny wrapper around local `transformers` pipelines.
+
+    Keeps the same `client.text_classification()` and `client.text_generation()`
+    interface used by the app and tests, but runs models locally.
+    """
+
+    def __init__(self):
+        self._emotion_model_id: str | None = None
+        self._emotion_pipe = None
+        self._generation_model_id: str | None = None
+        self._generation_pipe = None
+
+    def _get_emotion_pipe(self, model: str):
+        if self._emotion_pipe is not None and self._emotion_model_id == model:
+            return self._emotion_pipe
+
+        from transformers import pipeline
+
+        self._emotion_model_id = model
+        self._emotion_pipe = pipeline(
+            task="text-classification",
+            model=model,
+            device=-1,
+            top_k=None,
+        )
+        return self._emotion_pipe
+
+    def _get_generation_pipe(self, model: str):
+        if self._generation_pipe is not None and self._generation_model_id == model:
+            return self._generation_pipe
+
+        from transformers import pipeline
+
+        self._generation_model_id = model
+        self._generation_pipe = pipeline(
+            task="text-generation",
+            model=model,
+            device=-1,
+        )
+        return self._generation_pipe
+
+    def text_classification(self, text: str, model: str):
+        pipe = self._get_emotion_pipe(model)
+        raw = pipe(text)
+
+        # transformers can return `[[{label,score},...]]` when running on a list of inputs.
+        if isinstance(raw, list) and raw and isinstance(raw[0], list):
+            raw = raw[0]
+
+        if not isinstance(raw, list):
+            raise RuntimeError(f"Unexpected text_classification response: {raw!r}")
+
+        results: list[_LabelScore] = []
+        for item in raw:
+            if isinstance(item, dict) and "label" in item and "score" in item:
+                results.append(_LabelScore(str(item["label"]), float(item["score"])))
+
+        results.sort(key=lambda x: x.score, reverse=True)
+        if not results:
+            raise RuntimeError(f"Empty/invalid text_classification response: {raw!r}")
+        return results
+
+    def text_generation(
+        self,
+        prompt: str,
+        model: str,
+        max_new_tokens: int = 200,
+        temperature: float = 0.7,
+        do_sample: bool = True,
+    ) -> str:
+        pipe = self._get_generation_pipe(model)
+        try:
+            out = pipe(
+                prompt,
+                max_new_tokens=int(max_new_tokens),
+                temperature=float(temperature),
+                do_sample=bool(do_sample),
+                return_full_text=False,
+            )
+        except TypeError:
+            out = pipe(
+                prompt,
+                max_new_tokens=int(max_new_tokens),
+                temperature=float(temperature),
+                do_sample=bool(do_sample),
+            )
+
+        if not isinstance(out, list) or not out or not isinstance(out[0], dict) or "generated_text" not in out[0]:
+            raise RuntimeError(f"Unexpected text_generation response: {out!r}")
+
+        generated = str(out[0]["generated_text"])
+        if generated.startswith(prompt):
+            generated = generated[len(prompt):].lstrip()
+        return generated
+
+
+client = LocalTransformersClient()
+
+# Dream symbol database for enhanced interpretations
+DREAM_SYMBOLS = {
+    "water": "💧 Emotions, unconscious mind, purification",
+    "flying": "🦋 Freedom, ambition, escaping limitations", 
+    "falling": "⬇️ Loss of control, anxiety, letting go",
+    "teeth": "🦷 Confidence, self-image, communication",
+    "chase": "🏃 Avoidance, pressure, unresolved issues",
+    "house": "🏠 Self, psyche, different aspects of personality",
+    "snake": "🐍 Transformation, hidden fears, healing",
+    "death": "💀 Endings, transformation, new beginnings",
+    "baby": "👶 New beginnings, innocence, vulnerability",
+    "car": "🚗 Life direction, control, personal drive",
+    "fire": "🔥 Passion, anger, transformation, energy",
+    "ocean": "🌊 Vast emotions, the unknown, life's depth",
+    "forest": "🌲 Unconscious, mystery, personal growth",
+    "mirror": "🪞 Self-reflection, truth, identity",
+    "stairs": "🪜 Progress, transition, spiritual journey",
+    "door": "🚪 Opportunities, transitions, new paths",
+    "rain": "🌧️ Cleansing, sadness, renewal",
+    "sun": "☀️ Clarity, vitality, consciousness",
+    "moon": "🌙 Intuition, feminine energy, cycles",
+    "bird": "🐦 Freedom, perspective, spiritual messages"
+}
+
+# Mood colors for visualization
+MOOD_COLORS = {
+    "joy": "#FFD700",
+    "fear": "#4B0082", 
+    "sadness": "#4169E1",
+    "anger": "#DC143C",
+    "surprise": "#FF69B4",
+    "peace": "#90EE90",
+    "confusion": "#DDA0DD",
+    "excitement": "#FF4500"
+}
+
+
+def analyze_dream_sentiment(dream_text: str) -> tuple:
+    """
+    Analyze the emotional content of a dream using sentiment analysis.
+    """
+    if not dream_text.strip():
+        return "Please describe your dream first.", "N/A", ""
+    
+    start_time = time.time()
+    
+    try:
+        # Multi-label emotion classification
+        emotions = client.text_classification(
+            dream_text,
+            model="j-hartmann/emotion-english-distilroberta-base"
+        )
+        
+        end_time = time.time()
+        response_time = f"{(end_time - start_time):.3f}s"
+        
+        # Format emotional analysis
+        result = "## 🎭 Emotional Landscape of Your Dream\n\n"
+        
+        emotion_bars = ""
+        for emotion in emotions[:5]:  # Top 5 emotions
+            label = emotion.label.capitalize()
+            score = emotion.score
+            bar_length = int(score * 20)
+            color = MOOD_COLORS.get(label.lower(), "#888888")
+            emoji = {"joy": "😊", "fear": "😨", "sadness": "😢", "anger": "😠", 
+                    "surprise": "😲", "disgust": "🤢", "neutral": "😐"}.get(label.lower(), "🔮")
+            
+            result += f"{emoji} **{label}**: {'█' * bar_length}{'░' * (20-bar_length)} {score:.1%}\n"
+        
+        # Dominant mood
+        dominant = emotions[0].label if emotions else "Unknown"
+        result += f"\n### 🎯 Dominant Mood: **{dominant.upper()}**"
+        
+        return result, response_time, dominant.lower()
+        
+    except Exception as e:
+        return f"❌ Error analyzing emotions: {str(e)}", "N/A", ""
+
+
+def generate_text(prompt: str, max_tokens: int, temperature: float) -> tuple:
+    """Basic text generation helper (used by unit tests)."""
+    if not prompt.strip():
+        return "Please enter some text to generate.", "N/A"
+
+    start_time = time.time()
+    try:
+        result = client.text_generation(
+            prompt,
+                model="distilgpt2",
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            do_sample=True,
+        )
+        end_time = time.time()
+        response_time = f"{(end_time - start_time):.3f}s"
+        return result, response_time
+    except Exception as e:
+        return f"❌ Error generating text: {str(e)}", "N/A"
+
+
+def find_dream_symbols(dream_text: str) -> str:
+    """
+    Identify and interpret common dream symbols in the text.
+    """
+    dream_lower = dream_text.lower()
+    found_symbols = []
+    
+    for symbol, meaning in DREAM_SYMBOLS.items():
+        if symbol in dream_lower:
+            found_symbols.append(f"- **{symbol.capitalize()}**: {meaning}")
+    
+    if found_symbols:
+        return "## 🔮 Dream Symbols Detected\n\n" + "\n".join(found_symbols)
+    else:
+        return "## 🔮 Dream Symbols\n\n*No common symbols detected. Your dream may contain unique personal symbolism.*"
+
+
+def generate_dream_interpretation(dream_text: str, mood: str) -> tuple:
+    """
+    Generate an AI interpretation of the dream using text generation.
+    """
+    if not dream_text.strip():
+        return "Please describe your dream first.", "N/A"
+    
+    start_time = time.time()
+    
+    try:
+        # Create a prompt for dream interpretation
+        prompt = f"""As a dream analyst, provide a thoughtful interpretation of this dream:
+
+Dream: {dream_text}
+
+The dreamer's dominant emotion was: {mood}
+
+Interpretation:"""
+
+        result = client.text_generation(
+            prompt,
+                model="distilgpt2",
+            max_new_tokens=200,
+            temperature=0.7,
+            do_sample=True
+        )
+        
+        end_time = time.time()
+        response_time = f"{(end_time - start_time):.3f}s"
+        
+        interpretation = f"## 📖 Dream Interpretation\n\n{result}"
+        return interpretation, response_time
+        
+    except Exception as e:
+        return f"❌ Error generating interpretation: {str(e)}", "N/A"
+
+
+def generate_dream_story(dream_text: str, genre: str, length: int) -> tuple:
+    """
+    Transform the dream into a creative short story.
+    """
+    if not dream_text.strip():
+        return "Please describe your dream first.", "N/A"
+    
+    start_time = time.time()
+    
+    try:
+        genre_prompts = {
+            "Fantasy": "Write a magical fantasy story",
+            "Sci-Fi": "Write a futuristic science fiction story", 
+            "Mystery": "Write a mysterious thriller story",
+            "Romance": "Write a romantic story",
+            "Horror": "Write a suspenseful horror story",
+            "Adventure": "Write an exciting adventure story"
+        }
+        
+        prompt = f"""{genre_prompts.get(genre, "Write a creative story")} inspired by this dream:
+
+Dream elements: {dream_text}
+
+Story:"""
+
+        result = client.text_generation(
+            prompt,
+                model="distilgpt2",
+            max_new_tokens=length,
+            temperature=0.8,
+            do_sample=True
+        )
+        
+        end_time = time.time()
+        response_time = f"{(end_time - start_time):.3f}s"
+        
+        story = f"## ✨ Dream-Inspired {genre} Story\n\n{result}"
+        return story, response_time
+        
+    except Exception as e:
+        return f"❌ Error generating story: {str(e)}", "N/A"
+
+
+def generate_dream_image_prompt(dream_text: str) -> str:
+    """
+    Generate an image prompt based on the dream for use with image generators.
+    """
+    # Extract key visual elements
+    visual_keywords = []
+    
+    for symbol in DREAM_SYMBOLS.keys():
+        if symbol in dream_text.lower():
+            visual_keywords.append(symbol)
+    
+    # Add atmospheric descriptors based on common dream themes
+    atmosphere = random.choice([
+        "surreal", "ethereal", "mystical", "dreamlike", 
+        "fantastical", "otherworldly", "atmospheric"
+    ])
+    
+    style = random.choice([
+        "digital art", "oil painting style", "watercolor", 
+        "concept art", "impressionist", "fantasy illustration"
+    ])
+    
+    if visual_keywords:
+        elements = ", ".join(visual_keywords[:5])
+        prompt = f"A {atmosphere} scene featuring {elements}, {style}, dreamy lighting, vivid colors, detailed"
+    else:
+        prompt = f"A {atmosphere} dreamscape, {style}, surreal environment, dreamy lighting, mysterious atmosphere"
+    
+    return f"## 🎨 Image Generation Prompt\n\n*Use this prompt with DALL-E, Midjourney, or Stable Diffusion:*\n\n```\n{prompt}\n```"
+
+
+def save_to_journal(dream_text: str, interpretation: str) -> str:
+    """
+    Format dream entry for saving to a journal.
+    """
+    timestamp = datetime.now().strftime("%B %d, %Y at %I:%M %p")
+    
+    journal_entry = f"""
+# 📔 Dream Journal Entry
+## {timestamp}
+
+### 💭 The Dream
+{dream_text}
+
+### 🔮 Interpretation
+{interpretation}
+
+---
+*Recorded with DreamWeaver AI*
+"""
+    return journal_entry
+
+
+# Create the main Gradio interface
+with gr.Blocks(
+    title="🌙 DreamWeaver AI",
+    theme=gr.themes.Soft(
+        primary_hue="indigo",
+        secondary_hue="purple",
+        neutral_hue="slate"
+    ),
+    css="""
+    .gradio-container {
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+    }
+    .main-title {
+        text-align: center;
+        color: #e2e2e2;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🌙 DreamWeaver AI - Dream Journal & Interpreter
+    ### *Unlock the secrets of your subconscious mind*
+    
+    Welcome to DreamWeaver AI! This innovative tool uses advanced AI to analyze your dreams,
+    identify emotional patterns, discover symbolic meanings, and even transform your dreams
+    into creative stories.
+    
+    **✨ Local Transformers Version** - Models are downloaded and run on this Space
+    
+    ---
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            dream_input = gr.Textbox(
+                label="🌙 Describe Your Dream",
+                placeholder="Last night I dreamed I was flying over a vast ocean. The water was crystal clear and I could see colorful fish below. Suddenly, I noticed a mysterious door floating in the sky...",
+                lines=8,
+                max_lines=15
+            )
+            
+            with gr.Row():
+                analyze_btn = gr.Button("🔍 Analyze Dream", variant="primary", size="lg")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+    
+    with gr.Tabs():
+        # Tab 1: Emotional Analysis
+        with gr.TabItem("🎭 Emotional Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    emotion_output = gr.Markdown(label="Emotional Landscape")
+                with gr.Column():
+                    emotion_time = gr.Textbox(label="⏱️ Analysis Time", interactive=False)
+            
+            mood_state = gr.State("")
+        
+        # Tab 2: Symbol Interpretation
+        with gr.TabItem("🔮 Dream Symbols"):
+            symbols_output = gr.Markdown(label="Detected Symbols")
+        
+        # Tab 3: AI Interpretation
+        with gr.TabItem("📖 AI Interpretation"):
+            with gr.Row():
+                interpret_btn = gr.Button("🧠 Generate Interpretation", variant="primary")
+            interpretation_output = gr.Markdown(label="Dream Interpretation")
+            interpretation_time = gr.Textbox(label="⏱️ Generation Time", interactive=False)
+        
+        # Tab 4: Dream Story Generator
+        with gr.TabItem("✨ Story Generator"):
+            gr.Markdown("### Transform your dream into a creative story!")
+            
+            with gr.Row():
+                genre_dropdown = gr.Dropdown(
+                    choices=["Fantasy", "Sci-Fi", "Mystery", "Romance", "Horror", "Adventure"],
+                    value="Fantasy",
+                    label="📚 Select Genre"
+                )
+                length_slider = gr.Slider(
+                    minimum=100,
+                    maximum=500,
+                    value=250,
+                    step=50,
+                    label="📏 Story Length (tokens)"
+                )
+            
+            story_btn = gr.Button("✍️ Generate Story", variant="primary")
+            story_output = gr.Markdown(label="Your Dream Story")
+            story_time = gr.Textbox(label="⏱️ Generation Time", interactive=False)
+        
+        # Tab 5: Image Prompt
+        with gr.TabItem("🎨 Visualize"):
+            gr.Markdown("### Create visual art from your dream!")
+            image_prompt_btn = gr.Button("🖼️ Generate Image Prompt", variant="primary")
+            image_prompt_output = gr.Markdown(label="Image Prompt")
+        
+        # Tab 6: Dream Journal
+        with gr.TabItem("📔 Journal"):
+            gr.Markdown("### Save your dream to your journal")
+            save_btn = gr.Button("💾 Format for Journal", variant="primary")
+            journal_output = gr.Textbox(
+                label="Journal Entry (Copy this)",
+                lines=15,
+                show_copy_button=True
+            )
+        
+        # Tab 7: About
+        with gr.TabItem("ℹ️ About"):
+            gr.Markdown("""
+            ## About DreamWeaver AI
+            
+            ### 🌟 Features
+            - **Emotional Analysis**: Detect the emotional undertones of your dreams
+            - **Symbol Detection**: Identify and interpret common dream symbols
+            - **AI Interpretation**: Get personalized dream interpretations
+            - **Story Generation**: Transform dreams into creative stories
+            - **Visual Prompts**: Generate prompts for AI image generators
+            
+            ### 🔧 Technical Architecture
+            
+            | Component | Technology |
+            |-----------|------------|
+            | Frontend | Gradio 4.x |
+            | Emotion Model | distilroberta-base |
+            | Text Generation | distilgpt2 |
+            | Hosting | Hugging Face Spaces |
+            | Inference | Local Transformers |
+            
+            ### ⚡ Local Model Approach Trade-offs
+            
+            | ✅ Advantages | ⚠️ Considerations |
+            |--------------|-------------------|
+            | No external API dependency | First-run model download time |
+            | No network latency | More RAM/disk usage |
+            | Works offline (after download) | Smaller models on CPU |
+            
+            ### 📚 Citations
+            - Hugging Face Transformers
+            - Gradio Documentation
+            - Dream symbolism: Jungian psychology concepts
+            - GitHub Copilot assistance
+            
+            ### 👥 Team
+            *Add your team members here*
+            """)
+    
+    # Example dreams
+    gr.Examples(
+        examples=[
+            ["I was flying over a beautiful forest at sunset. The trees below were golden and I felt completely free. Suddenly I noticed I was being chased by a dark shadow."],
+            ["I found myself in my childhood home, but all the rooms were different. There was a mysterious door that I had never seen before. When I opened it, I saw an endless staircase."],
+            ["I was swimming in a crystal-clear ocean with colorful fish. The water was warm and I could breathe underwater. I discovered an ancient underwater city with golden buildings."],
+            ["I was taking an important exam but realized I couldn't read any of the questions. My teeth started falling out and everyone was staring at me."],
+        ],
+        inputs=dream_input,
+        label="💭 Example Dreams"
+    )
+    
+    # Event handlers
+    def full_analysis(dream_text):
+        emotions, time, mood = analyze_dream_sentiment(dream_text)
+        symbols = find_dream_symbols(dream_text)
+        return emotions, time, mood, symbols
+    
+    analyze_btn.click(
+        fn=full_analysis,
+        inputs=[dream_input],
+        outputs=[emotion_output, emotion_time, mood_state, symbols_output]
+    )
+    
+    interpret_btn.click(
+        fn=generate_dream_interpretation,
+        inputs=[dream_input, mood_state],
+        outputs=[interpretation_output, interpretation_time]
+    )
+    
+    story_btn.click(
+        fn=generate_dream_story,
+        inputs=[dream_input, genre_dropdown, length_slider],
+        outputs=[story_output, story_time]
+    )
+    
+    image_prompt_btn.click(
+        fn=generate_dream_image_prompt,
+        inputs=[dream_input],
+        outputs=[image_prompt_output]
+    )
+    
+    save_btn.click(
+        fn=lambda d, i: save_to_journal(d, i),
+        inputs=[dream_input, interpretation_output],
+        outputs=[journal_output]
+    )
+    
+    clear_btn.click(
+        fn=lambda: ("", "", "", "", "", "", "", ""),
+        outputs=[dream_input, emotion_output, emotion_time, symbols_output, 
+                interpretation_output, story_output, image_prompt_output, journal_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    <center>
+    
+    *🌙 DreamWeaver AI - Powered by Transformers*
+    
+    *Made with ❤️ for MLOps Case Study*
+    
+    </center>
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch()

pytest.ini

@@ -0,0 +1,11 @@
+# Pytest configuration file
+
+[pytest]
+testpaths = .
+python_files = test_*.py
+python_functions = test_*
+python_classes = Test*
+addopts = -v --tb=short
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::UserWarning

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+huggingface_hub<0.24
+transformers>=4.35.0
+torch>=2.0.0
+accelerate>=0.24.0

test_app.py

@@ -0,0 +1,272 @@
+"""
+Unit Tests for DreamWeaver AI - API-Based Version
+==================================================
+These tests verify the functionality of the dream analysis components.
+Note: Some tests mock API calls to avoid rate limits during CI/CD.
+
+Run with: pytest test_app.py -v
+"""
+
+import pytest
+import sys
+import os
+from unittest.mock import Mock, patch, MagicMock
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+
+class TestDreamSymbols:
+    """Test suite for dream symbol detection (no API calls needed)."""
+    
+    def test_import_app(self):
+        """Test that app module can be imported."""
+        import app
+        assert app is not None
+    
+    def test_dream_symbols_exist(self):
+        """Test that dream symbols dictionary exists."""
+        import app
+        assert hasattr(app, 'DREAM_SYMBOLS')
+        assert len(app.DREAM_SYMBOLS) > 0
+    
+    def test_find_dream_symbols_basic(self):
+        """Test basic symbol detection."""
+        import app
+        dream = "I was flying over the ocean and saw a beautiful house."
+        result = app.find_dream_symbols(dream)
+        assert "flying" in result.lower() or "ocean" in result.lower() or "house" in result.lower()
+    
+    def test_find_dream_symbols_no_match(self):
+        """Test when no symbols are found."""
+        import app
+        dream = "I had a conversation with someone."
+        result = app.find_dream_symbols(dream)
+        assert "No common symbols" in result or "unique personal symbolism" in result
+    
+    def test_find_dream_symbols_multiple(self):
+        """Test detection of multiple symbols."""
+        import app
+        dream = "I saw water, fire, and a snake near a door in the moonlight."
+        result = app.find_dream_symbols(dream)
+        # At least some symbols should be detected
+        assert "🔮" in result  # The header emoji
+
+
+class TestMoodColors:
+    """Test suite for mood color mappings."""
+    
+    def test_mood_colors_exist(self):
+        """Test that mood colors dictionary exists."""
+        import app
+        assert hasattr(app, 'MOOD_COLORS')
+        assert len(app.MOOD_COLORS) > 0
+    
+    def test_mood_colors_have_hex(self):
+        """Test that mood colors have hex values."""
+        import app
+        for mood, color in app.MOOD_COLORS.items():
+            assert color.startswith('#')
+
+
+class TestImagePromptGeneration:
+    """Test suite for image prompt generation (no API calls)."""
+    
+    def test_generate_image_prompt_basic(self):
+        """Test image prompt generation."""
+        import app
+        dream = "I was flying through a forest with the moon above."
+        result = app.generate_dream_image_prompt(dream)
+        assert "Image Generation Prompt" in result
+        assert "```" in result  # Code block for the prompt
+    
+    def test_generate_image_prompt_empty(self):
+        """Test image prompt with minimal input."""
+        import app
+        dream = "A simple dream."
+        result = app.generate_dream_image_prompt(dream)
+        assert "dreamscape" in result.lower() or "scene" in result.lower()
+
+
+class TestJournalSaving:
+    """Test suite for journal entry formatting."""
+    
+    def test_save_to_journal_format(self):
+        """Test journal entry formatting."""
+        import app
+        dream = "I had a wonderful dream about flying."
+        interpretation = "This dream represents freedom."
+        result = app.save_to_journal(dream, interpretation)
+        
+        assert "Dream Journal Entry" in result
+        assert dream in result
+        assert interpretation in result
+        assert "DreamWeaver AI" in result
+
+
+class TestSentimentAnalysisMocked:
+    """Test suite for sentiment analysis with mocked API."""
+    
+    @patch('app.client')
+    def test_analyze_sentiment_success(self, mock_client):
+        """Test sentiment analysis with mocked successful response."""
+        import app
+        
+        # Mock the API response
+        mock_result = [
+            Mock(label="joy", score=0.8),
+            Mock(label="surprise", score=0.1),
+            Mock(label="neutral", score=0.1)
+        ]
+        mock_client.text_classification.return_value = mock_result
+        
+        result, time, mood = app.analyze_dream_sentiment("I was so happy in my dream!")
+        
+        assert "Emotional Landscape" in result
+        assert mood == "joy"
+        assert "s" in time  # time should contain seconds
+    
+    @patch('app.client')
+    def test_analyze_sentiment_empty_input(self, mock_client):
+        """Test sentiment analysis with empty input."""
+        import app
+        
+        result, time, mood = app.analyze_dream_sentiment("")
+        
+        assert "Please enter some text" in result or "Please describe your dream" in result
+        mock_client.text_classification.assert_not_called()
+
+
+class TestTextGenerationMocked:
+    """Test suite for text generation with mocked API."""
+    
+    @patch('app.client')
+    def test_generate_text_success(self, mock_client):
+        """Test text generation with mocked response."""
+        import app
+        
+        mock_client.text_generation.return_value = "Once upon a time, in a magical land..."
+        
+        result, time = app.generate_text("Once upon a time", 50, 0.7)
+        
+        assert isinstance(result, str)
+        assert "s" in time
+    
+    @patch('app.client')
+    def test_generate_text_empty_input(self, mock_client):
+        """Test text generation with empty input."""
+        import app
+        
+        result, time = app.generate_text("", 50, 0.7)
+        
+        assert "Please enter" in result
+        mock_client.text_generation.assert_not_called()
+
+
+class TestDreamInterpretationMocked:
+    """Test suite for dream interpretation with mocked API."""
+    
+    @patch('app.client')
+    def test_generate_interpretation_success(self, mock_client):
+        """Test interpretation generation with mocked response."""
+        import app
+        
+        mock_client.text_generation.return_value = "This dream symbolizes your desire for freedom..."
+        
+        result, time = app.generate_dream_interpretation(
+            "I was flying over mountains",
+            "joy"
+        )
+        
+        assert "Dream Interpretation" in result
+        assert "s" in time
+
+
+class TestDreamStoryMocked:
+    """Test suite for story generation with mocked API."""
+    
+    @patch('app.client')
+    def test_generate_story_fantasy(self, mock_client):
+        """Test fantasy story generation."""
+        import app
+        
+        mock_client.text_generation.return_value = "The hero discovered a magical realm..."
+        
+        result, time = app.generate_dream_story(
+            "I found a magical sword",
+            "Fantasy",
+            250
+        )
+        
+        assert "Fantasy" in result
+        assert "Story" in result
+    
+    @patch('app.client')
+    def test_generate_story_scifi(self, mock_client):
+        """Test sci-fi story generation."""
+        import app
+        
+        mock_client.text_generation.return_value = "In the year 3000..."
+        
+        result, time = app.generate_dream_story(
+            "I was on a spaceship",
+            "Sci-Fi",
+            250
+        )
+        
+        assert "Sci-Fi" in result
+
+
+class TestErrorHandling:
+    """Test suite for error handling."""
+    
+    @patch('app.client')
+    def test_api_error_handling(self, mock_client):
+        """Test that API errors are handled gracefully."""
+        import app
+        
+        mock_client.text_classification.side_effect = Exception("API rate limit exceeded")
+        
+        result, time, mood = app.analyze_dream_sentiment("Test dream")
+        
+        assert "Error" in result
+        assert "rate limit" in result.lower() or "error" in result.lower()
+
+
+class TestGradioInterface:
+    """Test suite for Gradio interface components."""
+    
+    def test_demo_exists(self):
+        """Test that the Gradio demo object exists."""
+        import app
+        assert hasattr(app, 'demo')
+    
+    def test_demo_is_blocks(self):
+        """Test that demo is a Gradio Blocks instance."""
+        import app
+        import gradio as gr
+        assert isinstance(app.demo, gr.Blocks)
+
+
+# Integration test (only runs if HF_TOKEN is available)
+class TestIntegrationWithAPI:
+    """Integration tests that actually call the API (skipped in CI without token)."""
+    
+    @pytest.mark.skipif(
+        os.getenv('SKIP_API_TESTS', 'true').lower() == 'true',
+        reason="Skipping API tests to avoid rate limits"
+    )
+    def test_real_sentiment_analysis(self):
+        """Test real API call for sentiment analysis."""
+        import app
+        
+        result, time, mood = app.analyze_dream_sentiment(
+            "I was extremely happy flying through beautiful clouds."
+        )
+        
+        assert "Emotional Landscape" in result
+        assert mood != ""
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])