Create app.py

app.py

@@ -0,0 +1,752 @@
+import streamlit as st
+import anthropic
+import requests
+import json
+import base64
+import plotly.graph_objects as go
+from typing import Dict, Any
+import time
+import random
+
+# Page Config
+st.set_page_config(
+    page_title="NarrativeCraft: Immersive Story & Character Design Studio",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    page_icon="📚"
+)
+
+# Custom CSS for professional dark theme
+st.markdown("""
+    <style>
+    .main {background-color: #0e1117; color: #ffffff;}
+    .stProgress > div > div > div > div {background-color: #1f77b4;}
+    .character-card {
+        background-color: #1e1e1e;
+        padding: 1.5rem;
+        border-radius: 0.5rem;
+        margin: 1rem 0;
+        border: 1px solid #2e2e2e;
+    }
+    .section-title {
+        font-size: 1.5rem;
+        font-weight: bold;
+        margin: 1.5rem 0 1rem 0;
+        padding-bottom: 0.5rem;
+        border-bottom: 2px solid #2e2e2e;
+    }
+    .subsection-title {
+        font-size: 1.2rem;
+        font-weight: bold;
+        margin: 1rem 0;
+        color: #4e8cff;
+    }
+    .story-section {
+        background-color: #1e1e1e;
+        padding: 2rem;
+        border-radius: 0.5rem;
+        margin: 1.5rem 0;
+        border: 1px solid #2e2e2e;
+    }
+    .audio-player {
+        margin: 1rem 0;
+        padding: 1rem;
+        background-color: #2e2e2e;
+        border-radius: 0.5rem;
+    }
+    .analysis-card {
+        background-color: #2e2e2e;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 0.5rem 0;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'character' not in st.session_state:
+    st.session_state.character = None
+if 'story_params' not in st.session_state:
+    st.session_state.story_params = None
+if 'generated_content' not in st.session_state:
+    st.session_state.generated_content = None
+if 'voice_data' not in st.session_state:
+    st.session_state.voice_data = None
+
+# Constants
+ARCHETYPES = {
+    "The Hero": "Brave, determined protagonist driven by a noble cause",
+    "The Mentor": "Wise guide with deep knowledge and experience",
+    "The Trickster": "Clever, unpredictable character who challenges conventions",
+    "The Sage": "Philosophical, thoughtful character seeking truth",
+    "The Rebel": "Independent spirit fighting against the system",
+    "The Caregiver": "Nurturing, protective character driven by compassion",
+    "The Creator": "Innovative, artistic character driven by vision",
+    "The Explorer": "Adventure-seeking character driven by curiosity",
+    "The Ruler": "Leadership-focused character seeking control",
+    "The Innocent": "Pure-hearted character maintaining optimism"
+}
+
+GENRES = [
+    "Epic Fantasy",
+    "Science Fiction",
+    "Dark Fantasy",
+    "Historical Fiction",
+    "Magical Realism",
+    "Contemporary Drama",
+    "Mystery/Thriller",
+    "Romance",
+    "Political Intrigue",
+    "Cyberpunk",
+    "Space Opera",
+    "Urban Fantasy",
+    "Gothic Horror",
+    "Adventure",
+    "Literary Fiction"
+]
+
+WRITING_STYLES = {
+    "Classical": "Elegant, formal prose with rich descriptions",
+    "Modern Minimalist": "Clean, precise language with impact",
+    "Lyrical": "Poetic, flowing prose with metaphorical depth",
+    "Gritty Realism": "Raw, direct style with stark honesty",
+    "Experimental": "Innovative structure and unique voice",
+    "Journalistic": "Clear, factual style with objectivity",
+    "Stream of Consciousness": "Free-flowing, internal narrative",
+    "Epic": "Grand, sweeping style with historical weight"
+}
+def create_character_section():
+    st.markdown('<p class="section-title">Character Design</p>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        selected_archetype = st.selectbox(
+            "Choose Character Archetype",
+            list(ARCHETYPES.keys())
+        )
+        
+        st.info(ARCHETYPES[selected_archetype])
+        
+        age_range = st.select_slider(
+            "Age Range",
+            options=["Child", "Teen", "Young Adult", "Adult", "Middle-aged", "Elderly"],
+            value="Adult"
+        )
+
+    with col2:
+        st.markdown('<p class="subsection-title">Character Preview</p>', unsafe_allow_html=True)
+        st.markdown(f"**Archetype:** {selected_archetype}")
+        st.markdown(f"**Age:** {age_range}")
+
+    st.markdown('<p class="subsection-title">Personality Traits</p>', unsafe_allow_html=True)
+    trait_col1, trait_col2, trait_col3 = st.columns(3)
+    
+    with trait_col1:
+        confidence = st.slider("Confidence", 1, 10, 5, help="Character's self-assurance level")
+        empathy = st.slider("Empathy", 1, 10, 5, help="Ability to understand others")
+        intelligence = st.slider("Intelligence", 1, 10, 5, help="Mental capability and wit")
+    
+    with trait_col2:
+        courage = st.slider("Courage", 1, 10, 5, help="Bravery in face of adversity")
+        ambition = st.slider("Ambition", 1, 10, 5, help="Drive to achieve goals")
+        loyalty = st.slider("Loyalty", 1, 10, 5, help="Faithfulness to causes/people")
+    
+    with trait_col3:
+        humor = st.slider("Humor", 1, 10, 5, help="Sense of humor and wit")
+        creativity = st.slider("Creativity", 1, 10, 5, help="Imaginative capability")
+        wisdom = st.slider("Wisdom", 1, 10, 5, help="Depth of understanding")
+
+    st.markdown('<p class="subsection-title">Voice & Speech</p>', unsafe_allow_html=True)
+    voice_col1, voice_col2 = st.columns(2)
+    
+    with voice_col1:
+        voice_type = st.selectbox(
+            "Voice Quality",
+            ["Deep", "Melodious", "Rough", "Soft", "Commanding", "Gentle", "Energetic"],
+            help="Primary characteristic of the character's voice"
+        )
+        
+        accent = st.selectbox(
+            "Accent",
+            ["Standard", "Regional", "Foreign", "Cultured", "Rustic"],
+            help="Character's accent or dialect"
+        )
+
+    with voice_col2:
+        speech_pattern = st.selectbox(
+            "Speech Pattern",
+            ["Formal", "Casual", "Educated", "Street-wise", "Poetic", "Technical", "Noble"],
+            help="How the character typically speaks"
+        )
+        
+        speech_pacing = st.select_slider(
+            "Speech Pace",
+            options=["Very Slow", "Slow", "Moderate", "Quick", "Very Quick"],
+            value="Moderate",
+            help="Speed and rhythm of speech"
+        )
+
+    st.markdown('<p class="subsection-title">Emotional Profile</p>', unsafe_allow_html=True)
+    emo_col1, emo_col2 = st.columns(2)
+    
+    with emo_col1:
+        primary_emotion = st.selectbox(
+            "Primary Emotional State",
+            ["Determined", "Serene", "Passionate", "Calculating", "Troubled", "Optimistic", "Reserved"]
+        )
+        emotional_stability = st.slider("Emotional Stability", 1, 10, 5)
+
+    with emo_col2:
+        emotional_expression = st.selectbox(
+            "Emotional Expression Style",
+            ["Open", "Guarded", "Volatile", "Controlled", "Subtle", "Dramatic"]
+        )
+        emotional_depth = st.slider("Emotional Depth", 1, 10, 5)
+
+    return {
+        "archetype": selected_archetype,
+        "age_range": age_range,
+        "traits": {
+            "confidence": confidence,
+            "empathy": empathy,
+            "intelligence": intelligence,
+            "courage": courage,
+            "ambition": ambition,
+            "loyalty": loyalty,
+            "humor": humor,
+            "creativity": creativity,
+            "wisdom": wisdom
+        },
+        "voice": {
+            "type": voice_type,
+            "accent": accent,
+            "pattern": speech_pattern,
+            "pacing": speech_pacing
+        },
+        "emotional_profile": {
+            "primary_emotion": primary_emotion,
+            "stability": emotional_stability,
+            "expression": emotional_expression,
+            "depth": emotional_depth
+        }
+    }
+    
+def create_voice_preview(description: str, text: str) -> Dict:
+    """Create voice preview using ElevenLabs API"""
+    url = 'https://api.elevenlabs.io/v1/text-to-voice/create-previews'
+    
+    headers = {
+        'xi-api-key': st.secrets["ELEVENLABS_API_KEY"],
+        'Content-Type': 'application/json'
+    }
+    
+    payload = {
+        'voice_description': description,
+        'text': text
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            st.error(f"Voice generation error: {response.status_code}")
+            st.write("Error details:", response.json())
+            return None
+    except Exception as e:
+        st.error(f"Error: {str(e)}")
+        return None
+
+def display_character_profile(character: Dict, voice_data: Dict = None):
+    """Display character profile with voice playback"""
+    if not character:
+        st.warning("No character data available")
+        return
+        
+    try:
+        with st.container():
+            st.markdown('<div class="character-card">', unsafe_allow_html=True)
+            
+            # Character Title
+            if character.get("archetype"):
+                st.markdown(f'<p class="section-title">{character["archetype"]}</p>', 
+                          unsafe_allow_html=True)
+            
+            col1, col2 = st.columns([2, 1])
+            
+            with col1:
+                if character.get("traits"):
+                    st.markdown("### Personality Profile")
+                    
+                    # Personality Traits Radar Chart
+                    traits = character['traits']
+                    fig = go.Figure(data=go.Scatterpolar(
+                        r=[traits[key] for key in traits.keys()],
+                        theta=list(traits.keys()),
+                        fill='toself',
+                        line=dict(color='#4e8cff')
+                    ))
+                    
+                    fig.update_layout(
+                        polar=dict(
+                            radialaxis=dict(visible=True, range=[0, 10])),
+                        showlegend=False,
+                        paper_bgcolor='rgba(0,0,0,0)',
+                        plot_bgcolor='rgba(0,0,0,0)',
+                        font=dict(color='white')
+                    )
+                    
+                    st.plotly_chart(fig, use_container_width=True)
+
+            with col2:
+                st.markdown('<p class="subsection-title">Voice Sample</p>', 
+                          unsafe_allow_html=True)
+                if voice_data and 'previews' in voice_data and voice_data['previews']:
+                    st.markdown('<div class="audio-player">', unsafe_allow_html=True)
+                    audio_data = base64.b64decode(voice_data['previews'][0]['audio_base_64'])
+                    st.audio(audio_data, format='audio/mp3')
+                    st.markdown('</div>', unsafe_allow_html=True)
+                
+                if character.get("voice"):
+                    st.markdown('<p class="subsection-title">Core Traits</p>', 
+                              unsafe_allow_html=True)
+                    st.markdown(f"**Age Range:** {character.get('age_range', 'N/A')}")
+                    st.markdown(f"**Voice Type:** {character['voice'].get('type', 'N/A')}")
+                    st.markdown(f"**Speech Pattern:** {character['voice'].get('pattern', 'N/A')}")
+
+            st.markdown('</div>', unsafe_allow_html=True)
+            
+    except Exception as e:
+        st.error(f"Error displaying character profile: {str(e)}")
+
+def create_story_parameters_section():
+    st.markdown('<p class="section-title">Story Configuration</p>', unsafe_allow_html=True)
+    
+    # Main Story Parameters
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        genre = st.selectbox("Genre", GENRES)
+        
+        writing_style = st.selectbox(
+            "Writing Style",
+            list(WRITING_STYLES.keys())
+        )
+        st.info(WRITING_STYLES[writing_style])
+
+        tone = st.select_slider(
+            "Story Tone",
+            options=["Light", "Hopeful", "Neutral", "Dark", "Gritty"],
+            value="Neutral"
+        )
+
+    with col2:
+        pacing = st.select_slider(
+            "Story Pacing",
+            options=["Slow & Thoughtful", "Balanced", "Fast & Intense"],
+            value="Balanced"
+        )
+
+        plot_complexity = st.slider("Plot Complexity", 1, 10, 5)
+        
+        dialogue_focus = st.slider("Dialogue Emphasis", 1, 10, 5)
+
+    # Setting Details
+    st.markdown('<p class="subsection-title">Setting & Atmosphere</p>', unsafe_allow_html=True)
+    set_col1, set_col2 = st.columns(2)
+    
+    with set_col1:
+        time_period = st.selectbox(
+            "Time Period",
+            ["Ancient", "Medieval", "Renaissance", "Industrial", "Modern", 
+             "Contemporary", "Near Future", "Far Future", "Multiple Eras"]
+        )
+        
+        setting_type = st.selectbox(
+            "Setting Type",
+            ["Urban", "Rural", "Wilderness", "Fantasy World", "Space", 
+             "Underground", "Ocean", "Multiple Locations"]
+        )
+
+    with set_col2:
+        atmosphere = st.select_slider(
+            "Atmosphere",
+            options=["Mysterious", "Whimsical", "Tense", "Peaceful", "Epic", "Intimate"],
+            value="Tense"
+        )
+        
+        realism_level = st.select_slider(
+            "Realism Level",
+            options=["Highly Realistic", "Balanced", "Fantastical"],
+            value="Balanced"
+        )
+
+    # Themes and Conflicts
+    st.markdown('<p class="subsection-title">Themes & Conflicts</p>', unsafe_allow_html=True)
+    theme_col1, theme_col2 = st.columns(2)
+    
+    with theme_col1:
+        themes = st.multiselect(
+            "Main Themes",
+            ["Redemption", "Power", "Love", "Justice", "Identity", "Change", 
+             "Good vs Evil", "Order vs Chaos", "Faith", "Family"],
+            default=["Identity"]
+        )
+        
+        conflict_type = st.selectbox(
+            "Primary Conflict",
+            ["Person vs Person", "Person vs Nature", "Person vs Society", 
+             "Person vs Self", "Person vs Technology", "Person vs Fate"]
+        )
+
+    with theme_col2:
+        moral_ambiguity = st.select_slider(
+            "Moral Ambiguity",
+            options=["Clear Good/Evil", "Some Gray Areas", "Morally Complex"],
+            value="Some Gray Areas"
+        )
+        
+        theme_exploration = st.select_slider(
+            "Theme Exploration",
+            options=["Subtle", "Balanced", "Overt"],
+            value="Balanced"
+        )
+
+    return {
+        "main_params": {
+            "genre": genre,
+            "writing_style": writing_style,
+            "tone": tone,
+            "pacing": pacing,
+            "plot_complexity": plot_complexity,
+            "dialogue_focus": dialogue_focus
+        },
+        "setting": {
+            "time_period": time_period,
+            "type": setting_type,
+            "atmosphere": atmosphere,
+            "realism": realism_level
+        },
+        "themes": {
+            "main_themes": themes,
+            "conflict": conflict_type,
+            "moral_ambiguity": moral_ambiguity,
+            "exploration": theme_exploration
+        }
+    }
+
+def display_story_preview(story_params: Dict, generated_content: Dict = None):
+    """Display generated story content"""
+    if not generated_content:
+        st.info("Generate preview to see content")
+        return
+        
+    st.markdown('<div class="story-section">', unsafe_allow_html=True)
+    
+    # Tabs for content sections
+    tabs = st.tabs(["Story", "Analysis"])
+    
+    with tabs[0]:
+        # Prologue
+        st.markdown('<p class="subsection-title" style="color: #4e8cff;">Prologue</p>', 
+                   unsafe_allow_html=True)
+        st.markdown(generated_content.get('prologue', ''))
+        
+        # Character Analysis
+        if generated_content.get('character_analysis'):
+            st.markdown('<p class="subsection-title" style="color: #4e8cff;">Character Analysis</p>', 
+                       unsafe_allow_html=True)
+            st.markdown(generated_content['character_analysis'])
+        
+        # Scene Preview
+        if generated_content.get('scene_preview'):
+            st.markdown('<p class="subsection-title" style="color: #4e8cff;">Scene Preview</p>', 
+                       unsafe_allow_html=True)
+            st.markdown(generated_content['scene_preview'])
+    
+    with tabs[1]:
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Themes
+            st.markdown('<p class="subsection-title" style="color: #4e8cff;">Themes & Motifs</p>', 
+                       unsafe_allow_html=True)
+            themes = generated_content.get('analysis', {}).get('themes', [])
+            if themes:
+                for theme in themes:
+                    st.markdown(f"• {theme}")
+            else:
+                st.info("No themes specified")
+            
+        with col2:
+            # Style Analysis
+            st.markdown('<p class="subsection-title" style="color: #4e8cff;">Style Analysis</p>', 
+                       unsafe_allow_html=True)
+            style = generated_content.get('analysis', {}).get('style', {})
+            if style:
+                for key, value in style.items():
+                    st.markdown(f"**{key}:**")
+                    st.markdown(value)
+            else:
+                st.info("No style analysis available")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+def generate_story_content(character: Dict, story_params: Dict) -> Dict:
+    """Generate story content using Claude"""
+    client = anthropic.Anthropic(api_key=st.secrets["ANTHROPIC_API_KEY"])
+    
+    prompt = f"""Create a compelling and human-like story preview based on the following character and parameters:
+
+Character Details:
+{json.dumps(character, indent=2)}
+
+Story Parameters:
+{json.dumps(story_params, indent=2)}
+
+Please provide:
+
+1. Prologue (2-3 engaging paragraphs)
+- Set the tone and atmosphere
+- Introduce the world/setting
+- Create intrigue
+
+2. Character Analysis
+- Deep psychological insights
+- Key motivations and conflicts
+- Unique traits and quirks
+
+3. Sample Scene
+- Show character in action
+- Demonstrate personality
+- Include meaningful dialogue
+
+4. Thematic Analysis
+- Provide 3-4 major themes
+- Explain their significance
+- Show their manifestation
+
+5. Style Elements
+- Discuss narrative approach
+- Note key stylistic choices
+- Highlight unique features
+
+Make the writing feel natural and professional, avoiding any AI-like patterns. Focus on depth and authenticity."""
+
+    try:
+        response = client.messages.create(
+            max_tokens=4096,
+            model="claude-3-5-sonnet-latest",
+            messages=[{"role": "user", "content": prompt}]
+        )
+        
+        content = response.content[0].text
+        
+        # Parse the content into structured sections
+        sections = parse_generated_content(content)
+        
+        return sections
+    except Exception as e:
+        st.error(f"Error generating content: {str(e)}")
+        return None
+
+def parse_generated_content(content: str) -> Dict:
+    """Parse Claude's response into structured sections"""
+    sections = {
+        "prologue": "",
+        "character_analysis": "",
+        "scene_preview": "",
+        "analysis": {
+            "themes": [],
+            "style": {}
+        }
+    }
+    
+    try:
+        current_section = None
+        buffer = []
+        
+        for line in content.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+            
+            lower_line = line.lower()
+            
+            # Section detection
+            if "prologue" in lower_line and len(line) < 30:
+                if buffer and current_section:
+                    sections[current_section] = '\n'.join(buffer).strip()
+                current_section = "prologue"
+                buffer = []
+                continue
+                
+            elif "character analysis" in lower_line and len(line) < 30:
+                if buffer and current_section:
+                    sections[current_section] = '\n'.join(buffer).strip()
+                current_section = "character_analysis"
+                buffer = []
+                continue
+                
+            elif "sample scene" in lower_line and len(line) < 30:
+                if buffer and current_section:
+                    sections[current_section] = '\n'.join(buffer).strip()
+                current_section = "scene_preview"
+                buffer = []
+                continue
+                
+            elif ("theme" in lower_line or "themes" in lower_line) and len(line) < 30:
+                if buffer and current_section:
+                    sections[current_section] = '\n'.join(buffer).strip()
+                current_section = "themes"
+                buffer = []
+                continue
+                
+            elif "style" in lower_line and len(line) < 30:
+                if buffer and current_section:
+                    sections[current_section] = '\n'.join(buffer).strip()
+                current_section = "style"
+                buffer = []
+                continue
+            
+            # Content processing
+            if current_section:
+                if current_section == "themes":
+                    if line.startswith(('•', '-', '*')):
+                        clean_line = line.lstrip('•-* ').strip()
+                        sections['analysis']['themes'].append(clean_line)
+                    elif line:
+                        buffer.append(line)
+                        
+                elif current_section == "style":
+                    if ':' in line:
+                        key, value = line.split(':', 1)
+                        key = key.strip().strip('0123456789.- ').strip()
+                        sections['analysis']['style'][key] = value.strip()
+                    elif line:
+                        buffer.append(line)
+                        
+                else:
+                    buffer.append(line)
+        
+        # Process any remaining buffer
+        if buffer and current_section:
+            if current_section in ["themes", "style"]:
+                # Process remaining theme/style buffer if needed
+                pass
+            else:
+                sections[current_section] = '\n'.join(buffer).strip()
+        
+        return sections
+        
+    except Exception as e:
+        st.error(f"Error parsing content: {str(e)}")
+        return None
+
+def main():
+    st.title("NarrativeCraft: Immersive Story & Character Design Studio")
+    st.markdown("#### Created by Oussama Naji")
+    
+    with st.sidebar:
+        st.markdown("### Creation Process")
+        current_step = st.radio(
+            "Select Step:",
+            ["Character Creation", "Story Configuration", "Generate Preview"]
+        )
+    
+    try:
+        if current_step == "Character Creation":
+            character = create_character_section()
+            if st.button("Save Character", type="primary"):
+                st.session_state.character = character
+                st.success("Character saved! Proceed to Story Configuration.")
+                
+        elif current_step == "Story Configuration":
+            if 'character' not in st.session_state:
+                st.warning("Please create a character first!")
+                return
+                
+            story_params = create_story_parameters_section()
+            if st.button("Save Story Parameters", type="primary"):
+                st.session_state.story_params = story_params
+                st.success("Story parameters saved! Proceed to Preview Generation.")
+                
+        else:  # Generate Preview
+            if 'character' not in st.session_state or 'story_params' not in st.session_state:
+                st.warning("Please complete character and story configuration first!")
+                return
+                
+            if st.button("Generate Preview", type="primary"):
+                with st.spinner("🎨 Crafting your story..."):
+                    progress_bar = st.progress(0)
+                    
+                    try:
+                        # Generate story content
+                        progress_bar.progress(25)
+                        st.info("🤖 Generating story content...")
+                        st.session_state.generated_content = generate_story_content(
+                            st.session_state.character,
+                            st.session_state.story_params
+                        )
+                        
+                        if not st.session_state.generated_content:
+                            st.error("Failed to generate story content")
+                            return
+                        
+                        # Generate voice
+                        progress_bar.progress(50)
+                        st.info("🎤 Creating character voice...")
+                        
+                        voice_desc = f"A {st.session_state.character['voice']['type']} voice with {st.session_state.character['voice']['pattern']} speech pattern"
+                        sample_text = "I stand here before you, ready to share my story. Each word carries the weight of my experiences, the essence of who I am."
+                        
+                        st.session_state.voice_data = create_voice_preview(voice_desc, sample_text)
+                        
+                        progress_bar.progress(75)
+                        st.info("✨ Finalizing preview...")
+                        
+                        # Display results
+                        if st.session_state.character:
+                            display_character_profile(
+                                st.session_state.character,
+                                st.session_state.voice_data
+                            )
+                            
+                        if st.session_state.story_params and st.session_state.generated_content:
+                            display_story_preview(
+                                st.session_state.story_params,
+                                st.session_state.generated_content
+                            )
+                        
+                        progress_bar.progress(100)
+                        st.success("✅ Preview generated successfully!")
+                        
+                    except Exception as e:
+                        st.error(f"An error occurred: {str(e)}")
+                        return
+            
+            # Display existing content if available
+            elif all(key in st.session_state for key in ['character', 'generated_content']):
+                display_character_profile(
+                    st.session_state.character,
+                    st.session_state.voice_data
+                )
+                display_story_preview(
+                    st.session_state.story_params,
+                    st.session_state.generated_content
+                )
+            
+            # Reset button
+            if 'generated_content' in st.session_state:
+                if st.button("Start Over"):
+                    for key in ['character', 'story_params', 'generated_content', 'voice_data']:
+                        if key in st.session_state:
+                            del st.session_state[key]
+                    st.rerun()
+                    
+    except Exception as e:
+        st.error(f"An error occurred in main: {str(e)}")
+
+if __name__ == "__main__":
+    main()