Update main.py

main.py

@@ -5,342 +5,287 @@ import re
 import tempfile
 import time
 from datetime import datetime
-from io import BytesIO
-
-# Third-party imports
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 import pandas as pd
 import pypdf
 import google.generativeai as genai
-from PIL import Image
-
-# specific import for image fallback
-try:
-    from pdf2image import convert_from_path
-    PDF_IMAGE_SUPPORT = True
-except ImportError:
-    PDF_IMAGE_SUPPORT = False
-    logging.warning("pdf2image not installed. Scanned/Encrypted PDF fallback will not work.")
+import PIL.Image
 
 # Setup logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO)
 
 app = Flask(__name__)
-CORS(app)
+CORS(app)  # Enable CORS for all routes
 
 # Get API key securely
 api_key = os.getenv('Gemini')
 if not api_key:
-    # Fallback for local testing if env var not set, though env var is preferred
-    logging.warning("Gemini API key not found in environment variables.")
+    raise ValueError("Gemini API key not found in environment variables")
 
 def configure_gemini(api_key):
     """Configure Gemini AI model."""
     try:
         genai.configure(api_key=api_key)
-        # Using 2.0 Flash as it has superior vision and long-context capabilities
         return genai.GenerativeModel('gemini-2.0-flash')
     except Exception as e:
         logging.error(f"Error configuring Gemini: {str(e)}")
         raise
 
-# -------------------------------------------------------------------------
-# PROMPTS
-# -------------------------------------------------------------------------
-
-# Enhanced Prompt for General Financial Documents (Statements, Invoices, Receipts)
-# Addresses Point 1 (Rounding/Dates) & Point 3 (Document Types)
-FINANCIAL_DOC_PROMPT = """Analyze this financial document (which could be a Bank Statement, Invoice, Receipt, or Transaction List).
-Extract all relevant transactions/items in JSON format.
-
-RULES:
-1. **Dates**: Extract the date printed on the document. Format as DD/MM/YYYY.
-   - If the year is missing in the row, use the document's context (e.g., header date).
-   - Do NOT use the current date (today) unless the document explicitly says "Today".
-2. **Amounts**: Extract the EXACT amount including decimals. DO NOT ROUND.
-3. **Ignore**: Opening/Closing balances, page numbers, or cumulative running totals.
-
-FIELDS TO EXTRACT:
-- Date: string (DD/MM/YYYY)
-- Description: string (Full description of item/transaction)
-- Amount: number (Float, exact value)
-- Type: string (Categorize exactly as one of: 'income', 'expense', 'asset', 'liability', 'equity', 'transfer', 'investment', 'loan_repayment', 'capital_injection')
-- Customer_name: string (If 'income', name of payer. If 'expense', name of payee/vendor. Else 'N/A')
-- City: string (Extract from address if present, else 'N/A')
-- Document_Type: string (Infer: 'statement', 'invoice', 'receipt', 'transaction_list')
-- Destination_of_funds: string (Categorize based on description. e.g., 'Salaries', 'Fuel', 'Rentals', 'Equipment', etc.)
+def read_pdf_pages(file_path):
+    """Extract text from each page of a PDF file as list of strings."""
+    try:
+        pages = []
+        with open(file_path, 'rb') as f:
+            reader = pypdf.PdfReader(f)
+            for page in reader.pages:
+                text = page.extract_text() or ""
+                pages.append(text)
+        return pages
+    except Exception as e:
+        logging.error(f"Error reading PDF: {str(e)}")
+        raise
 
-RETURN STRUCTURE:
+PROMPT = """Analyze this bank statement and extract transactions in JSON format with these fields:
+
+Date (format DD/MM/YYYY)
+Description
+Amount (just the integer value)
+Type (categorize into one of the following based on the transaction nature):
+'income' - money received from customers, sales, services rendered
+'expense' - operational costs, purchases, payments made
+'asset' - purchase of equipment, property, vehicles, or other assets
+'liability' - taking on debt, loans received, credit facilities
+'equity' - owner investments, capital contributions, retained earnings transfers
+'transfer' - money moved between own accounts, internal transfers
+'investment' - securities purchases, investment account funding, portfolio additions
+'loan_repayment' - paying back borrowed money, loan principal payments
+'capital_injection' - owner or investor adding money to the business
+Customer Name (Only if Type is 'income' and if no name is extracted write 'general income'. For all other types, extract relevant party name or write 'N/A')
+City (In address of bank statement)
+Destination_of_funds (categorize based on Type and description):
+If 'expense': Water and electricity, Salaries and wages, Repairs & Maintenance, Motor vehicle expenses, Projects Expenses, Hardware expenses, Refunds, Accounting fees, Loan interest, Bank charges, Insurance, SARS PAYE UIF, Advertising & Marketing, Logistics and distribution, Fuel, Website hosting fees, Rentals, Subscriptions, Computer internet and Telephone, Staff training, Travel and accommodation, Depreciation, Other expenses
+If 'income': 'income'
+If 'asset': Equipment, Property, Vehicles, Technology, Furniture, Other assets
+If 'liability': Bank loan, Credit facility, Supplier credit, Other liabilities
+If 'equity': Owner investment, Retained earnings, Share capital, Other equity
+If 'transfer': Internal transfer
+If 'investment': Securities, Mutual funds, Fixed deposits, Other investments
+If 'loan_repayment': Loan repayment
+If 'capital_injection': Capital injection
+ignore opening or closing balances.
+extract the amount in full including decimals.
+Return ONLY the raw JSON object, without any surrounding text, explanations, or markdown fences like ```json.
+Return ONLY valid JSON with this structure:
 {
-  "transactions": [
-    {
-      "Date": "DD/MM/YYYY",
-      "Description": "Item Description",
-      "Customer_name": "Vendor or Payer",
-      "City": "City Name",
-      "Amount": 123.45,
-      "Type": "expense",
-      "Destination_of_funds": "Category",
-      "Document_Type": "invoice"
-    }
-  ]
+"transactions": [
+{
+"Date": "string",
+"Description": "string",
+"Customer_name": "string",
+"City": "string",
+"Amount": number,
+"Type": "string",
+"Destination_of_funds": "string"
 }
+]
+}"""
 
-Return ONLY raw JSON. No markdown formatting.
-"""
-
-def get_text_prompt_with_fallback_date():
-    """
-    Generate prompt for raw text snippets where context might be missing.
-    Only allows current date fallback for raw text, not PDFs.
-    """
+def get_text_prompt_with_date():
+    """Generate TEXT_PROMPT with current date context."""
     current_date = datetime.now().strftime("%d/%m/%Y")
-    return f"""IMPORTANT: Today's date is {current_date}.
-If the text below does not specify a year or date, reasonable assume {current_date} context, but prefer explicit dates in text.
-
-{FINANCIAL_DOC_PROMPT}
+    return f"""IMPORTANT: Today's date is {current_date}. If the user does not specify a date for a transaction, use {current_date} as the default date.
+
+Analyze the following natural language text and extract transactions in JSON format with these fields:
+
+Date (format DD/MM/YYYY) - USE {current_date} IF NO DATE IS SPECIFIED
+Description
+Amount (just the integer value)
+Type (categorize into one of the following based on the transaction nature):
+'income' - money received from customers, sales, services rendered
+'expense' - operational costs, purchases, payments made
+'asset' - purchase of equipment, property, vehicles, or other assets
+'liability' - taking on debt, loans received, credit facilities
+'equity' - owner investments, capital contributions, retained earnings transfers
+'transfer' - money moved between own accounts, internal transfers
+'investment' - securities purchases, investment account funding, portfolio additions
+'loan_repayment' - paying back borrowed money, loan principal payments
+'capital_injection' - owner or investor adding money to the business
+Customer Name (Only if Type is 'income' and if no name is extracted write 'general income'. For all other types, extract relevant party name or write 'N/A')
+City (extract from any address information provided or write 'N/A' if not available)
+Destination_of_funds (categorize based on Type and description):
+If 'expense': Water and electricity, Salaries and wages, Repairs & Maintenance, Motor vehicle expenses, Projects Expenses, Hardware expenses, Refunds, Accounting fees, Loan interest, Bank charges, Insurance, SARS PAYE UIF, Advertising & Marketing, Logistics and distribution, Fuel, Website hosting fees, Rentals, Subscriptions, Computer internet and Telephone, Staff training, Travel and accommodation, Depreciation, Other expenses
+If 'income': 'income'
+If 'asset': Equipment, Property, Vehicles, Technology, Furniture, Other assets
+If 'liability': Bank loan, Credit facility, Supplier credit, Other liabilities
+If 'equity': Owner investment, Retained earnings, Share capital, Other equity
+If 'transfer': Internal transfer
+If 'investment': Securities, Mutual funds, Fixed deposits, Other investments
+If 'loan_repayment': Loan repayment
+If 'capital_injection': Capital injection
+ignore opening or closing balances.
+Return ONLY valid JSON with this structure:
+{{
+"transactions": [
+{{
+"Date": "string",
+"Description": "string",
+"Customer_name": "string",
+"City": "string",
+"Amount": number,
+"Type": "string",
+"Destination_of_funds": "string"
+}}
+]
+}}
+important: Return an empty array if no transactions are in the text. Do not make up false data.
 """
 
-# -------------------------------------------------------------------------
-# HELPER FUNCTIONS
-# -------------------------------------------------------------------------
-
-def extract_json_from_response(response_text):
-    """Extract valid JSON from Gemini's response, handling Markdown fences."""
-    # Remove markdown code blocks
-    cleaned_text = re.sub(r'```json\s*', '', response_text)
-    cleaned_text = re.sub(r'```\s*', '', cleaned_text)
-    
-    # Find JSON object
-    match = re.search(r'(\{.*\})', cleaned_text, re.DOTALL)
-    if match:
-        json_string = match.group(1)
-    else:
-        # Fallback: assume the whole text is JSON
-        json_string = cleaned_text
-
-    try:
-        return json.loads(json_string)
-    except json.JSONDecodeError:
-        logging.warning("JSON parsing failed, attempting repair.")
-        raise ValueError(json_string) # Pass invalid string to caller for repair
-
 def repair_json_with_gemini(model, broken_json_string):
-    """Uses Gemini to fix broken JSON syntax."""
-    repair_prompt = f"""Fix this broken JSON string. Return ONLY valid JSON.
-    Broken JSON: {broken_json_string}"""
+    """Makes a second API call to Gemini to fix a broken JSON string."""
+    logging.info("Attempting to repair broken JSON with another Gemini call...")
+    repair_prompt = f"""The following text is a JSON object that is syntactically incorrect.
+    It might have missing commas, brackets, or other errors.
+    Please fix the syntax to make it a valid JSON object.
+    Return ONLY the corrected, raw JSON object and nothing else.
+
+    Broken JSON:
+    {broken_json_string}
+    """
     try:
         resp = model.generate_content(repair_prompt)
-        return extract_json_from_response(resp.text)
+        return resp.text
     except Exception as e:
-        logging.error(f"JSON repair failed: {e}")
-        return {"transactions": []} # Fail safe
+        logging.error(f"Error during JSON repair call: {e}")
+        raise ValueError("Failed to repair the JSON string.")
 
-def call_gemini_with_retry(model, content, prompt, retries=2):
-    """
-    Generic runner for Gemini.
-    Args:
-        content: Can be a String (text) or a PIL.Image object (vision).
-    """
-    for attempt in range(retries + 1):
+def call_gemini_with_retry_custom(model, text, prompt, retries=3, backoff_factor=2):
+    """Call Gemini with retries, now with JSON repair logic."""
+    for attempt in range(1, retries + 1):
         try:
-            # Gemini Python SDK handles [Prompt, Image] or [Prompt, Text] automatically
-            response = model.generate_content([prompt, content])
-            
+            resp = model.generate_content([prompt, text])
+            response_text = resp.text
             try:
-                return extract_json_from_response(response.text)
-            except ValueError as ve:
-                # Value error here contains the broken JSON string
-                broken_json = str(ve)
-                return repair_json_with_gemini(model, broken_json)
-                
+                # First attempt to parse the original response
+                return extract_json_from_response(response_text)
+            except Exception:
+                # If parsing fails, trigger the repair process
+                logging.warning("Initial JSON parsing failed. Attempting repair.")
+                repaired_text = repair_json_with_gemini(model, response_text)
+                return extract_json_from_response(repaired_text) # Parse the repaired text
         except Exception as e:
-            if "429" in str(e) or "ResourceExhausted" in str(e):
-                time.sleep(2 * (attempt + 1))
-                continue
-            logging.error(f"Gemini Error: {e}")
-            if attempt == retries:
+            msg = str(e)
+            if '429' in msg or 'RateLimit' in msg and attempt < retries:
+                wait = backoff_factor ** attempt
+                logging.warning(f"Rate limit hit, retrying in {wait}s (attempt {attempt}/{retries})")
+                time.sleep(wait)
+            else:
+                logging.error(f"Error processing with Gemini after retries: {msg}")
                 raise
 
-    return {"transactions": []}
-
-def is_file_empty(file_path):
-    """Check if file is empty."""
-    return os.path.getsize(file_path) == 0
-
-# -------------------------------------------------------------------------
-# CORE LOGIC: PDF PROCESSING (HYBRID TEXT + VISION)
-# -------------------------------------------------------------------------
+def call_gemini_with_retry(model, text, retries=3, backoff_factor=2):
+    """Call Gemini with retries, now with JSON repair logic."""
+    # This function now simply calls the custom one with the default PROMPT
+    return call_gemini_with_retry_custom(model, text, PROMPT, retries, backoff_factor)
 
-def process_pdf_page_as_image(model, pdf_path, page_num):
-    """Point 4: Convert specific PDF page to image and process with Vision."""
-    if not PDF_IMAGE_SUPPORT:
-        raise ImportError("pdf2image/poppler not installed")
+def extract_json_from_response(response_text):
+    """Extract valid JSON from Gemini's response, even if it's embedded."""
+    # First, try to find a JSON block enclosed in markdown fences
+    match = re.search(r'json\s*(\{.*?\})\s*', response_text, re.DOTALL)
+    if match:
+        json_string = match.group(1)
+    else:
+        # If no markdown, find the first '{' and the last '}'
+        match = re.search(r'{.*}', response_text, re.DOTALL)
+        if not match:
+            raise ValueError("No valid JSON object found in the LLM response")
+        json_string = match.group(0)
 
-    # Convert specific page to image
-    # first_page=page_num, last_page=page_num ensures we only convert 1 page at a time to save RAM
-    images = convert_from_path(pdf_path, first_page=page_num, last_page=page_num)
-    if not images:
-        return []
-    
-    # Process the image
-    result = call_gemini_with_retry(model, images[0], FINANCIAL_DOC_PROMPT)
-    return result.get('transactions', [])
+    try:
+        # Clean and load the extracted JSON string
+        return json.loads(json_string)
+    except json.JSONDecodeError as e:
+        logging.error(f"Failed to parse extracted JSON. Error: {e}")
+        logging.error(f"Problematic JSON string was: {json_string}")
+        raise ValueError(f"Could not parse JSON from LLM response: {e}")
 
 @app.route('/process-pdf', methods=['POST'])
 def process_pdf():
-    """
-    Smart PDF Processor:
-    1. Checks if empty.
-    2. Tries standard Text extraction (Fast/Cheap).
-    3. If Text fails (Encryption) or is empty (Scanned), falls back to Vision (Slow/Powerful).
-    """
-    temp_path = None
+    """Handle PDF upload, process it in page-chunks with Gemini, and aggregate results."""
     try:
-        # 1. Validation
         if 'file' not in request.files:
             return jsonify({'error': 'No file uploaded'}), 400
         file = request.files['file']
-        if file.filename == '':
-            return jsonify({'error': 'No file selected'}), 400
+        if file.filename == '' or not file.filename.lower().endswith('.pdf'):
+            return jsonify({'error': 'A valid PDF file must be uploaded'}), 400
 
-        # Save Temp
+        # Save to temp file
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
             file.save(tmp.name)
-            temp_path = tmp.name
-
-        # Point 2: Empty File Check
-        if is_file_empty(temp_path):
-             return jsonify({'error': 'Uploaded file is empty'}), 400
+            file_path = tmp.name
 
-        model = configure_gemini(api_key)
-        all_transactions = []
-        
-        # Determine strategy: Try reading PDF structure first
         try:
-            reader = pypdf.PdfReader(temp_path)
-            num_pages = len(reader.pages)
-            
-            for i in range(num_pages):
-                logging.info(f"Processing page {i+1}/{num_pages}")
-                
-                # Attempt Text Extraction
-                try:
-                    text_content = reader.pages[i].extract_text()
-                except Exception:
-                    text_content = "" # Force fallback if extraction fails
-
-                # LOGIC: Check if text is sufficient. If < 50 chars, it's likely a scan or image-heavy.
-                if text_content and len(text_content.strip()) > 50:
-                    # Strategy A: Text Mode
-                    logging.info("Text detected. Using Text Strategy.")
-                    result = call_gemini_with_retry(model, text_content, FINANCIAL_DOC_PROMPT)
-                else:
-                    # Strategy B: Vision Fallback (Point 4)
-                    logging.info("Low text/Encryption detected. Switching to Vision Strategy.")
-                    if PDF_IMAGE_SUPPORT:
-                        # Page numbers in pypdf are 0-indexed, pdf2image uses 1-based indexing often, 
-                        # but convert_from_path handles slicing via first_page/last_page (1-based)
-                        txs = process_pdf_page_as_image(model, temp_path, i+1)
-                        all_transactions.extend(txs)
-                        continue # Skip the rest of loop
-                    else:
-                        logging.warning("Cannot process scanned PDF - pdf2image missing.")
-                        result = {"transactions": []}
-
+            model = configure_gemini(api_key)
+            pages = read_pdf_pages(file_path)
+            all_transactions = []
+
+            for idx, page_text in enumerate(pages, start=1):
+                if not page_text.strip():
+                    continue
+                logging.info(f"Processing page {idx}/{len(pages)}")
+                result = call_gemini_with_retry(model, page_text)
                 txs = result.get('transactions', [])
                 all_transactions.extend(txs)
 
-        except pypdf.errors.PdfReadError:
-            # If pypdf fails completely (e.g., highly corrupted or weird encryption), try Vision on whole file
-            logging.warning("pypdf failed to read file. Attempting full Vision fallback.")
-            if PDF_IMAGE_SUPPORT:
-                # Warning: Processing all pages as images might be slow
-                images = convert_from_path(temp_path)
-                for img in images:
-                    result = call_gemini_with_retry(model, img, FINANCIAL_DOC_PROMPT)
-                    all_transactions.extend(result.get('transactions', []))
-            else:
-                raise ValueError("PDF is unreadable and Vision fallback is unavailable.")
-
-        return jsonify({'transactions': all_transactions})
+            return jsonify({'transactions': all_transactions})
+        finally:
+            os.remove(file_path)
 
+    except ValueError as ve:
+        logging.warning(f"Client error: {ve}")
+        return jsonify({'error': str(ve)}), 400
     except Exception as e:
-        logging.error(f"Server Error: {e}")
-        return jsonify({'error': str(e)}), 500
-    finally:
-        if temp_path and os.path.exists(temp_path):
-            os.remove(temp_path)
-
-# -------------------------------------------------------------------------
-# TEXT & IMAGE ENDPOINTS (UPDATED)
-# -------------------------------------------------------------------------
+        logging.error(f"Internal server error: {e}")
+        return jsonify({'error': 'Internal server error'}), 500
 
 @app.route('/process-text', methods=['POST'])
 def process_text():
-    """Handle raw text input."""
+    """Handle text input and extract transactions using Gemini."""
     try:
+        # Get JSON data from request
         data = request.get_json()
         if not data or 'text' not in data:
             return jsonify({'error': 'No text provided'}), 400
-        
+
         text_input = data['text']
+        
         if not text_input.strip():
-            return jsonify({'error': 'Text input cannot be empty'}), 400 # Point 2
+            return jsonify({'error': 'Text input cannot be empty'}), 400
         
+        # Configure Gemini model
         model = configure_gemini(api_key)
-        # Use specific prompt with date fallback for raw text
-        prompt = get_text_prompt_with_fallback_date()
         
-        result = call_gemini_with_retry(model, text_input, prompt)
-        return jsonify({'transactions': result.get('transactions', [])})
-        
-    except Exception as e:
-        logging.error(f"Error: {e}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/process-image', methods=['POST'])
-def process_image():
-    """Handle raw image upload (Receipts, Photos of invoices)."""
-    temp_path = None
-    try:
-        if 'file' not in request.files:
-            return jsonify({'error': 'No file uploaded'}), 400
-        file = request.files['file']
+        # Generate prompt with current date
+        text_prompt = get_text_prompt_with_date()
         
-        # Point 2: Empty check
-        file.seek(0, os.SEEK_END)
-        size = file.tell()
-        file.seek(0)
-        if size == 0:
-            return jsonify({'error': 'File is empty'}), 400
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as tmp:
-            file.save(tmp.name)
-            temp_path = tmp.name
-
-        model = configure_gemini(api_key)
+        # Process the text with Gemini
+        logging.info("Processing text input for transaction extraction")
+        result = call_gemini_with_retry_custom(model, text_input, text_prompt)
         
-        # Load image with PIL
-        img = Image.open(temp_path)
+        transactions = result.get('transactions', [])
         
-        # Use the General Financial Prompt
-        result = call_gemini_with_retry(model, img, FINANCIAL_DOC_PROMPT)
+        return jsonify({'transactions': transactions})
         
-        return jsonify({'transactions': result.get('transactions', [])})
-    
+    except ValueError as ve:
+        logging.warning(f"Client error: {ve}")
+        return jsonify({'error': str(ve)}), 400
     except Exception as e:
-        logging.error(f"Error: {e}")
-        return jsonify({'error': str(e)}), 500
-    finally:
-        if temp_path and os.path.exists(temp_path):
-            os.remove(temp_path)
+        logging.error(f"Internal server error: {e}")
+        return jsonify({'error': 'Internal server error'}), 500
 
 @app.route('/transaction-types', methods=['GET'])
 def get_transaction_types():
     """Return available transaction types and their categories."""
-    # Kept identical for backwards compatibility
     transaction_types = {
         "types": [
             {
@@ -409,15 +354,65 @@ def get_transaction_types():
     }
     return jsonify(transaction_types)
 
+@app.route('/process-image', methods=['POST'])
+def process_image():
+    """Handle image upload, process it with Gemini Vision, and extract transactions."""
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file uploaded'}), 400
+
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+        
+        # Check if file is an image
+        allowed_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'}
+        file_ext = os.path.splitext(file.filename)[1].lower()
+        if file_ext not in allowed_extensions:
+            return jsonify({'error': 'Invalid file type. Supported formats: JPG, JPEG, PNG, GIF, BMP, WEBP'}), 400
+        
+        # Save to temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as tmp:
+            file.save(tmp.name)
+            file_path = tmp.name
+        
+        try:
+            model = configure_gemini(api_key)
+            
+            logging.info(f"Processing image file: {file.filename}")
+            
+            # Read image file as bytes
+            img = PIL.Image.open(file_path)
+            
+            # Generate content with the image and prompt
+            response = model.generate_content([PROMPT, img])
+            
+            # Parse the response
+            result = extract_json_from_response(response.text)
+            transactions = result.get('transactions', [])
+            
+            return jsonify({'transactions': transactions})
+            
+        finally:
+            # Clean up temp file
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+    except ValueError as ve:
+        logging.warning(f"Client error: {ve}")
+        return jsonify({'error': str(ve)}), 400
+    except Exception as e:
+        logging.error(f"Internal server error: {e}")
+        return jsonify({'error': 'Internal server error'}), 500
+
 @app.route('/health', methods=['GET'])
 def health_check():
+    """Health check endpoint."""
     return jsonify({
         'status': 'healthy',
         'timestamp': datetime.now().isoformat(),
-        'version': '2.1.0',
-        'vision_support': PDF_IMAGE_SUPPORT
+        'version': '2.0.0'
     })
 
 if __name__ == '__main__':
-    # Ensure this port matches your server configuration
     app.run(debug=True, host="0.0.0.0", port=7860)