Update app.py

app.py

@@ -5,58 +5,28 @@ import pandas as pd
 from datetime import datetime
 import plotly.express as px
 import plotly.io as pio
-from googletrans import Translator
 import numpy as np
+import dotenv
+import json
 
-app = Flask(__name__)
-
-# Initialize translator
-translator = Translator()
+dotenv.load_dotenv()
 
-# Translation dictionaries
-MARATHI_TRANSLATIONS = {
-    'state': 'राज्य',
-    'district': 'जिल्हा',
-    'market': 'बाजार',
-    'commodity': 'पीक',
-    'variety': 'प्रकार',
-    'grade': 'श्रेणी',
-    'arrival_date': 'आगमन तारीख',
-    'min_price': 'किमान किंमत',
-    'max_price': 'कमाल किंमत',
-    'modal_price': 'सरासरी किंमत',
-    'Select State': 'राज्य निवडा',
-    'Select District': 'जिल्हा निवडा',
-    'Select Market': 'बाजार निवडा',
-    'Select Commodity': 'पीक निवडा',
-    'Market Data': 'बाजार माहिती',
-    'Top 5 Cheapest Crops': 'सर्वात स्वस्त 5 पिके',
-    'Top 5 Costliest Crops': 'सर्वात महाग 5 पिके'
-}
-
-def translate_to_marathi(text):
-    """Translate text to Marathi"""
-    try:
-        if text in MARATHI_TRANSLATIONS:
-            return MARATHI_TRANSLATIONS[text]
-        translation = translator.translate(text, dest='mr')
-        return translation.text
-    except:
-        return text
+app = Flask(__name__)
 
 def fetch_market_data(state=None, district=None, market=None, commodity=None):
-    """Fetch data from the agricultural market API"""
-    api_key = os.getenv("data_api_key")
-    print(api_key)
-    base_url = "https://api.data.gov.in/resource/9ef84268-d588-465a-a308-a864a43d0070"
+    """Fetch data from the agricultural market API.
+    If the API fails or returns empty data, fallback to the CSV file.
+    Filters (state, district, market, commodity) are applied manually on CSV data.
+    """
+    api_key = "579b464db66ec23bdd000001189bbb99e979428764bdbe8fdd44ebb7"
+    base_url = "https://api.data.gov.in/resource/9ef84268-d588-465a-a308-a864a43d007"
     
     params = {
-        "api-key": "579b464db66ec23bdd000001189bbb99e979428764bdbe8fdd44ebb7",
+        "api-key": api_key,
         "format": "json",
-        "limit": 10,
+        "limit": 1000,
     }
     
-    # Add filters if provided
     if state:
         params["filters[state]"] = state
     if district:
@@ -72,147 +42,295 @@ def fetch_market_data(state=None, district=None, market=None, commodity=None):
             data = response.json()
             records = data.get("records", [])
             df = pd.DataFrame(records)
-            return df
         else:
             print(f"API Error: {response.status_code}")
-            return pd.DataFrame()
+            raise Exception(f"API Error: {response.status_code}")
     except Exception as e:
-        print(f"Error fetching data: {str(e)}")
-        return pd.DataFrame()
-
+        print(f"Error fetching data from API: {str(e)}. Falling back to CSV file.")
+        df = pd.read_csv("final_price_data.csv")
+        if 'min_price' not in df.columns:
+            rename_mapping = {
+                'State': 'state',
+                'District': 'district',
+                'Market': 'market',
+                'Commodity': 'commodity',
+                'Variety': 'variety',
+                'Grade': 'grade',
+                'Arrival_Date': 'arrival_date',
+                'Min_x0020_Price': 'min_price',
+                'Max_x0020_Price': 'max_price',
+                'Modal_x0020_Price': 'modal_price'
+            }
+            df.rename(columns=rename_mapping, inplace=True)
+    
+    if df.empty:
+        print("API returned empty data. Falling back to CSV file.")
+        df = pd.read_csv("final_price_data.csv")
+        if 'min_price' not in df.columns:
+            rename_mapping = {
+                'State': 'state',
+                'District': 'district',
+                'Market': 'market',
+                'Commodity': 'commodity',
+                'Variety': 'variety',
+                'Grade': 'grade',
+                'Arrival_Date': 'arrival_date',
+                'Min_x0020_Price': 'min_price',
+                'Max_x0020_Price': 'max_price',
+                'Modal_x0020_Price': 'modal_price'
+            }
+            df.rename(columns=rename_mapping, inplace=True)
+    
+    if state:
+        df = df[df['state'] == state]
+    if district:
+        df = df[df['district'] == district]
+    if market:
+        df = df[df['market'] == market]
+    if commodity:
+        df = df[df['commodity'] == commodity]
+    
+    return df
 
-def get_ai_insights(market_data, state, district):
-    """Get enhanced insights from LLM API with focus on profitable suggestions for farmers"""
+def get_ai_insights(market_data, state, district, market=None, commodity=None, language="English"):
+    """Get enhanced insights from Gemini API with focus on profitable suggestions for farmers.
+       Supports multiple languages through the prompt.
+       Returns dynamic insights only. If something goes wrong, returns an empty string.
+    """
     if not state or not district or market_data.empty:
         return ""
-
+    
     try:
-        # Calculate additional market metrics
+        # Filter data based on provided parameters
         district_data = market_data[market_data['district'] == district]
+        if district_data.empty:
+            return ""
         
-        # Price trends and volatility
+        # Apply market filter if provided
+        if market and not market_data[market_data['market'] == market].empty:
+            market_specific = True
+            district_data = district_data[district_data['market'] == market]
+        else:
+            market_specific = False
+            
+        # Apply commodity filter if provided
+        if commodity and not market_data[market_data['commodity'] == commodity].empty:
+            commodity_specific = True
+            district_data = district_data[district_data['commodity'] == commodity]
+        else:
+            commodity_specific = False
+        
+        # Calculate price trends
         price_trends = district_data.groupby('commodity').agg({
             'modal_price': ['mean', 'min', 'max', 'std']
         }).round(2)
         
-        # Calculate price stability (lower std/mean ratio indicates more stable prices)
+        # Using environment variable for Gemini API key
+        api_key = os.environ.get('GEMINI_API_KEY')
+        if not api_key:
+            print("Warning: Gemini API key not set")
+            return ""
+            
         price_trends['price_stability'] = (price_trends['modal_price']['std'] / 
                                          price_trends['modal_price']['mean']).round(2)
         
-        # Identify commodities with consistent high prices
-        high_value_crops = price_trends[price_trends['modal_price']['mean'] > 
-                                      price_trends['modal_price']['mean'].median()]
-        
-        # Get seasonal patterns
         district_data['arrival_date'] = pd.to_datetime(district_data['arrival_date'])
         district_data['month'] = district_data['arrival_date'].dt.month
         monthly_trends = district_data.groupby(['commodity', 'month'])['modal_price'].mean().round(2)
         
-        # Market competition analysis
         market_competition = len(district_data['market'].unique())
+        top_commodities = district_data.groupby('commodity')['modal_price'].mean().nlargest(5).index.tolist()
         
-        # Prepare comprehensive market summary
-        market_summary = {
-            "high_value_crops": high_value_crops.index.tolist(),
-            "price_stability": price_trends['price_stability'].to_dict(),
-            "monthly_trends": monthly_trends.to_dict(),
-            "market_competition": market_competition,
-            "avg_prices": district_data.groupby('commodity')['modal_price'].mean().round(2).to_dict(),
-            "price_ranges": {
-                crop: {
-                    'min': price_trends.loc[crop, ('modal_price', 'min')],
-                    'max': price_trends.loc[crop, ('modal_price', 'max')]
-                } for crop in price_trends.index
-            }
-        }
-
-        # Enhanced LLM prompt for more actionable insights
+        # Get min and max prices for key commodities
+        price_range_info = {}
+        for commodity in top_commodities[:3]:
+            comm_data = district_data[district_data['commodity'] == commodity]
+            if not comm_data.empty:
+                price_range_info[commodity] = {
+                    'min': comm_data['modal_price'].min(),
+                    'max': comm_data['modal_price'].max(),
+                    'avg': comm_data['modal_price'].mean()
+                }
+        
+        # Calculate market-specific metrics if market is selected
+        market_details = ""
+        if market_specific:
+            market_details = f"""
+            Market-specific information for {market}:
+            - Number of commodities: {len(district_data['commodity'].unique())}
+            - Most expensive commodity: {district_data.groupby('commodity')['modal_price'].mean().idxmax()}
+            - Cheapest commodity: {district_data.groupby('commodity')['modal_price'].mean().idxmin()}
+            """
+        
+        # Commodity-specific details if commodity is selected
+        commodity_details = ""
+        if commodity_specific:
+            commodity_data = district_data[district_data['commodity'] == commodity]
+            best_market = commodity_data.loc[commodity_data['modal_price'].idxmin()]['market']
+            worst_market = commodity_data.loc[commodity_data['modal_price'].idxmax()]['market']
+            
+            commodity_details = f"""
+            Commodity-specific information for {commodity}:
+            - Best market to buy (lowest price): {best_market}
+            - Highest priced market: {worst_market}
+            - Price variance across markets: {commodity_data['modal_price'].std().round(2)}
+            """
+        
+        # Improved prompt for better structured output with language support
         prompt = f"""
-        As an agricultural market expert, analyze this data for {district}, {state} and provide specific, actionable advice for farmers:
-
-        Market Overview:
-        - Number of active markets: {market_competition}
-        - High-value crops: {', '.join(market_summary['high_value_crops'][:5])}
-        - Price stability data available for {len(market_summary['price_stability'])} crops
-        - Monthly price trends tracked across {len(market_summary['monthly_trends'])} entries
-
-        Based on this comprehensive data, provide:
-
-        1. Immediate Market Opportunities (Next 2-4 weeks):
-        - Which crops currently show the best profit potential?
-        - Which markets are offering the best prices?
-        - Any immediate selling or holding recommendations?
-
-        2. Strategic Planning (Next 3-6 months):
-        - Which crops show consistent high returns?
-        - What are the optimal planting times based on price patterns?
-        - Which crop combinations could maximize profit throughout the year?
-
-        3. Risk Management:
-        - Which crops have shown the most stable prices?
-        - How can farmers diversify their crops to minimize risk?
-        - What are the warning signs to watch for in the market?
-
-        4. Market Engagement Strategy:
-        - Which markets consistently offer better prices?
-        - What quality grades are fetching premium prices?
-        - How can farmers negotiate better based on current market dynamics?
-
-        5. Storage and Timing Recommendations:
-        - Which crops are worth storing for better prices?
-        - What are the best times to sell each major crop?
-        - How can farmers use price trends to time their sales?
-
-        Provide practical, actionable advice that farmers can implement immediately. Include specific numbers and percentages where relevant.
-        Break the response into clear sections and keep it concise but informative.
+        Analyze the following agricultural market data for {district}, {state} and provide insights in {language} language.
+        
+        Market data:
+        - Active markets: {market_competition}
+        - Top crops: {', '.join(top_commodities[:5])}
+        - Data from {len(price_trends.index)} crops and {len(monthly_trends)} monthly entries.
+        
+        Price information:
+        {json.dumps(price_range_info, indent=2)}
+        
+        {market_details}
+        {commodity_details}
+        
+        Analyze this data and provide insights about crop market trends and profitability. 
+        Include specific numbers from the data about prices.
+        
+        Provide structured insights with clear sections. Use this exact format with bullet points:
+        
+        Crop Profitability Analysis:
+        * [First insight about profitable crops with specific prices mentioned]
+        * [Second insight]
+        
+        Market Price Analysis:
+        * [First insight about markets with specific price ranges]
+        * [Second insight]
+        
+        Recommendations for Farmers:
+        * [Action item 1]
+        * [Action item 2]
         """
-        api_url = "https://api-inference.huggingface.co/models/meta-llama/Llama-3.2-1B-Instruct/v1/chat/completions"
-        headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}
+        
+        api_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent"
+        headers = {"Content-Type": "application/json"}
+        
         payload = {
-            "inputs": prompt
+            "contents": [
+                {
+                    "parts": [
+                        {"text": prompt}
+                    ]
+                }
+            ],
+            "generationConfig": {
+                "temperature": 0.4,
+                "maxOutputTokens": 1024
+            }
         }
         
-        response = requests.post(api_url,headers=headers, json=payload)
+        response = requests.post(
+            f"{api_url}?key={api_key}", 
+            headers=headers, 
+            json=payload, 
+            timeout=20
+        )
+        
         if response.status_code == 200:
             response_data = response.json()
-            if (response_data and 
-                'choices' in response_data and 
-                len(response_data['choices']) > 0 and 
-                'message' in response_data['choices'][0] and 
-                'content' in response_data['choices'][0]['message']):
-                
-                insights = response_data['choices'][0]['message']['content']
-                formatted_insights = format_ai_insights(insights)
-                return formatted_insights
-                
-        return "AI insights temporarily unavailable"
-
+            if 'candidates' in response_data and len(response_data['candidates']) > 0:
+                content = response_data['candidates'][0]['content']
+                if 'parts' in content and len(content['parts']) > 0:
+                    insights = content['parts'][0]['text']
+                    return format_ai_insights(insights)
+            print(f"API Response issue: {response.text[:100]}")
+        else:
+            print(f"Gemini API Error: {response.status_code} - {response.text[:100]}")
+        
+        return ""
+    
     except Exception as e:
         print(f"Error generating insights: {str(e)}")
-        return f"Could not generate insights: {str(e)}"
+        return ""
+
+def format_ai_insights(insights_data):
+    """Format AI insights into structured HTML.
+       Returns an empty string if no valid insights are provided.
+    """
+    if not insights_data or not insights_data.strip():
+        return ""
+    
+    # Process the insights text - each bullet point becomes a formatted item
+    formatted_content = ""
+    
+    # Split by bullet points
+    bullet_points = insights_data.split('*')
+    
+    # Filter out empty items and process each bullet point
+    bullet_points = [point.strip() for point in bullet_points if point.strip()]
+    
+    # Check if any section headers exist in the content
+    sections = {}
+    current_section = "Recommendations"
+    
+    for point in bullet_points:
+        if ":" in point and len(point.split(":")[0]) < 30:  # Likely a section header
+            current_section = point.split(":")[0].strip()
+            # Start a new section
+            if current_section not in sections:
+                sections[current_section] = []
+        else:
+            # Add to current section
+            if current_section not in sections:
+                sections[current_section] = []
+            sections[current_section].append(point)
+    
+    # Now build the HTML with proper sections
+    for section, points in sections.items():
+        formatted_content += f'<div class="insight-card"><h5>{section}</h5><ul class="insight-list">'
+        for point in points:
+            # Highlight prices with special styling
+            if "₹" in point:
+                # Replace price mentions with highlighted spans
+                parts = point.split("₹")
+                styled_point = parts[0]
+                for i in range(1, len(parts)):
+                    # Extract the price value
+                    price_text = parts[i].split()[0]
+                    # Add the highlighted price and the rest of the text
+                    styled_point += f'<span class="price-highlight">₹{price_text}</span>' + parts[i][len(price_text):]
+                formatted_content += f'<li>{styled_point}</li>'
+            else:
+                formatted_content += f'<li>{point}</li>'
+        formatted_content += '</ul></div>'
+    
+    # Add a wrapper for the insights
+    html = f"""
+    <div class="insights-header">
+        <h3>AI Market Insights</h3>
+    </div>
+    <div class="insight-section">
+        {formatted_content}
+    </div>
+    """
+    
+    return html
 
-def generate_plots(df, lang='en'):
-    """Generate all plots with language support"""
+def generate_plots(df):
+    """Generate all plots in English"""
     if df.empty:
         return {}, "No data available"
     
-    # Convert price columns to numeric
     price_cols = ['min_price', 'max_price', 'modal_price']
     for col in price_cols:
         df[col] = pd.to_numeric(df[col], errors='coerce')
     
-    # Color scheme
     colors = ["#4CAF50", "#8BC34A", "#CDDC39", "#FFC107", "#FF5722"]
     
-    # 1. Bar Chart
     df_bar = df.groupby('commodity')['modal_price'].mean().reset_index()
     fig_bar = px.bar(df_bar, 
                      x='commodity', 
                      y='modal_price',
-                     title=translate_to_marathi("Average Price by Commodity") if lang == 'mr' else "Average Price by Commodity",
+                     title="Average Price by Commodity",
                      color_discrete_sequence=colors)
     
-    # 2. Line Chart (if commodity selected)
     fig_line = None
     if 'commodity' in df.columns and len(df['commodity'].unique()) == 1:
         df['arrival_date'] = pd.to_datetime(df['arrival_date'])
@@ -220,18 +338,16 @@ def generate_plots(df, lang='en'):
         fig_line = px.line(df_line, 
                           x='arrival_date', 
                           y='modal_price',
-                          title=translate_to_marathi("Price Trend") if lang == 'mr' else "Price Trend",
+                          title="Price Trend",
                           color_discrete_sequence=colors)
     
-    # 3. Box Plot
     fig_box = px.box(df, 
                      x='commodity', 
                      y='modal_price',
-                     title=translate_to_marathi("Price Distribution") if lang == 'mr' else "Price Distribution",
+                     title="Price Distribution",
                      color='commodity',
                      color_discrete_sequence=colors)
     
-    # Convert to HTML
     plots = {
         'bar': pio.to_html(fig_bar, full_html=False),
         'box': pio.to_html(fig_box, full_html=False)
@@ -243,27 +359,30 @@ def generate_plots(df, lang='en'):
 
 @app.route('/')
 def index():
-    """Render main page"""
-    initial_data = fetch_market_data()
-    states = sorted(initial_data['state'].dropna().unique())
+    try:
+        initial_data = fetch_market_data()
+        states = sorted(initial_data['state'].dropna().unique()) if not initial_data.empty else []
+    except Exception as e:
+        print(f"Error fetching initial data: {str(e)}")
+        states = []
+    
     return render_template('index.html', 
-                         states=states,
-                         today=datetime.today().strftime('%Y-%m-%d'))
+                           states=states,
+                           today=datetime.today().strftime('%Y-%m-%d'))
 
 @app.route('/filter_data', methods=['POST'])
 def filter_data():
-    """Handle data filtering, chart generation, and table generation"""
     state = request.form.get('state')
     district = request.form.get('district')
     market = request.form.get('market')
     commodity = request.form.get('commodity')
-    lang = request.form.get('language', 'en')
+    language = request.form.get('language', 'English')  # Default to English
     
     df = fetch_market_data(state, district, market, commodity)
-    plots = generate_plots(df, lang)
-    insights = get_ai_insights(df, state, district) if state and district and not df.empty else ""
+    plots = generate_plots(df)
+    # Pass market and commodity to get_ai_insights
+    insights = get_ai_insights(df, state, district, market, commodity, language) if state and district and not df.empty else ""
     
-    # Generate market data table HTML
     market_table_html = """
     <div class="table-responsive">
         <table class="table table-striped table-bordered">
@@ -301,7 +420,6 @@ def filter_data():
         """
     market_table_html += "</tbody></table></div>"
 
-    # Generate top 5 cheapest crops table
     cheapest_crops = df.sort_values('modal_price', ascending=True).head(5)
     cheapest_table_html = """
     <div class="table-responsive">
@@ -326,7 +444,6 @@ def filter_data():
         """
     cheapest_table_html += "</tbody></table></div>"
 
-    # Generate top 5 costliest crops table
     costliest_crops = df.sort_values('modal_price', ascending=False).head(5)
     costliest_table_html = """
     <div class="table-responsive">
@@ -351,7 +468,6 @@ def filter_data():
         """
     costliest_table_html += "</tbody></table></div>"
 
-    # Calculate market statistics
     market_stats = {
         'total_commodities': len(df['commodity'].unique()),
         'avg_modal_price': f"₹{df['modal_price'].mean():.2f}",
@@ -362,7 +478,6 @@ def filter_data():
     response = {
         'plots': plots,
         'insights': insights,
-        'translations': MARATHI_TRANSLATIONS if lang == 'mr' else {},
         'success': not df.empty,
         'hasStateDistrict': bool(state and district),
         'market_html': market_table_html,
@@ -373,121 +488,8 @@ def filter_data():
     
     return jsonify(response)
 
-def format_ai_insights(insights_data, lang='en'):
-    """Format AI insights into structured HTML with language support"""
-    # Translation dictionary for section headers and labels
-    translations = {
-        'AI Market Insights': 'एआय बाजार विश्लेषण',
-        'Immediate Market Opportunities': 'तात्काळ बाजार संधी',
-        'Best Profit Potential': 'सर्वोत्तम नफा क्षमता',
-        'Current Market Status': 'सध्याची बाजार स्थिती',
-        'Strategic Planning': 'धोरणात्मक नियोजन',
-        'High Return Crops': 'उच्च परतावा पिके',
-        'Recommended Crop Combinations': 'शिफारस केलेली पीक संयोजने',
-        'Risk Management & Market Strategy': 'जोखीम व्यवस्थापन आणि बाजार धोरण',
-        'Recommended Actions': 'शिफारस केलेल्या कृती',
-        'increase': 'वाढ',
-        'per kg': 'प्रति किलो',
-        'Most stable prices': 'सर्वात स्थिर किंमती',
-        'Best storage life': 'सर्वोत्तम साठवण कालावधी',
-        'Peak selling time': 'उच्चतम विक्री काळ',
-        'Plant mix of': 'पिकांचे मिश्रण लावा',
-        'Focus on': 'लक्ष केंद्रित करा',
-        'Store': 'साठवण करा',
-        'Aim for': 'लक्ष्य ठेवा',
-        'months': 'महिने'
-    }
-
-    def translate_text(text):
-        """Translate text based on language selection"""
-        if lang == 'mr':
-            # Try to find direct translation from dictionary
-            for eng, mar in translations.items():
-                text = text.replace(eng, mar)
-            return text
-        return text
-
-    def format_price(price_text):
-        """Format price with proper currency symbol and translation"""
-        if lang == 'mr':
-            return price_text.replace('₹', '₹').replace('per kg', 'प्रति किलो')
-        return price_text
-
-    """Format AI insights into structured HTML"""
-    html = f"""
-    <div class="insights-header">
-        <h3 class="en">AI Market Insights</h3>
-        <h3 class="mr" style="display:none;">एआय बाजार विश्लेषण</h3>
-    </div>
-    
-    <div class="insight-section">
-        <h4>Immediate Market Opportunities</h4>
-        <div class="insight-card">
-            <h5>Best Profit Potential</h5>
-            <ul class="insight-list">
-                <li>Beetroot and Bitter gourd showing <span class="percentage-up">15% increase</span> from base year</li>
-                <li>Bottle gourd premium quality fetching <span class="price-highlight">₹150 per kg</span></li>
-            </ul>
-        </div>
-        
-        <div class="insight-card">
-            <h5>Current Market Status</h5>
-            <ul class="insight-list">
-                <li>Brinjal in high demand with stable price of <span class="price-highlight">₹80 per kg</span></li>
-                <li>Premium quality bottle gourd commanding <span class="price-highlight">₹200 per kg</span></li>
-            </ul>
-        </div>
-    </div>
-    
-    <div class="insight-section">
-        <h4>Strategic Planning</h4>
-        <div class="insight-card">
-            <h5>High Return Crops</h5>
-            <ul class="insight-list">
-                <li>Cauliflower showing <span class="percentage-up">20% increase</span> from base year</li>
-                <li>Best planting time: Spring season for cauliflower and bottle gourd</li>
-            </ul>
-        </div>
-        
-        <div class="insight-card">
-            <h5>Recommended Crop Combinations</h5>
-            <ul class="insight-list">
-                <li>Brinjal + Bottle gourd + Cauliflower (similar demand patterns)</li>
-            </ul>
-        </div>
-    </div>
-    
-    <div class="insight-section">
-        <h4>Risk Management & Market Strategy</h4>
-        <div class="insight-card">
-            <ul class="insight-list">
-                <li>Most stable prices: Brinjal, Bottle gourd, Cauliflower</li>
-                <li>Best storage life: 6-9 months for Cauliflower, Brinjal, and Bottle gourd</li>
-                <li>Peak selling time for Cauliflower: March-April</li>
-            </ul>
-        </div>
-    </div>
-    
-    <div class="action-box">
-        <h5>Recommended Actions</h5>
-        <ul class="action-list">
-            <li>Plant mix of beetroot, bitter gourd, bottle gourd, brinjal, and cauliflower</li>
-            <li>Focus on stable price markets for cauliflower and bottle gourd</li>
-            <li>Store cauliflower for March-April peak prices</li>
-            <li>Aim for premium quality grades to maximize profits</li>
-        </ul>
-    </div>
-    """
-    if lang == 'mr':
-        html = translate_text(html)
-        # print(html
-        return html
-    
-    return html
-
 @app.route('/get_districts', methods=['POST'])
 def get_districts():
-    """Get districts for selected state"""
     state = request.form.get('state')
     df = fetch_market_data(state=state)
     districts = sorted(df['district'].dropna().unique())
@@ -495,7 +497,6 @@ def get_districts():
 
 @app.route('/get_markets', methods=['POST'])
 def get_markets():
-    """Get markets for selected district"""
     district = request.form.get('district')
     df = fetch_market_data(district=district)
     markets = sorted(df['market'].dropna().unique())
@@ -503,9 +504,11 @@ def get_markets():
 
 @app.route('/get_commodities', methods=['POST'])
 def get_commodities():
-    """Get commodities for selected market"""
     market = request.form.get('market')
     df = fetch_market_data(market=market)
     commodities = sorted(df['commodity'].dropna().unique())
     return jsonify(commodities)
 
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=7860)
+    pio.templates.default = "plotly_white"