Update app.py

app.py

@@ -1,450 +1,225 @@
-from flask import Flask, request, jsonify, render_template, send_file, redirect, url_for, Response
-import tsadropboxretrieval
-# import findInitialMarkups
-import InitialMarkups
-import requests
-import fitz
-from io import BytesIO   
-import datetime
-import time
-from threading import Thread
-from urllib.parse import quote, unquote, parse_qs
-# import pdftotext
+import gradio as gr
+import os
 import json
-# -------------------- App & Globals --------------------
-app = Flask(__name__)
-pageNumTextFound = 0
-BASE_URL = "https://adr.trevorsadd.co.uk/api/testpage" ##changed this only
-backend_ready = False
-jsonoutput = []  # ensure defined before use
-
-# -------------------- Simple Health/Test --------------------
-@app.route("/health", methods=["GET"])
-def health():
-    return jsonify(status="ok", time=datetime.datetime.now().isoformat())
-
-# -------------------- Root: keep it simple & reliable --------------------
-@app.route("/", methods=["GET"])
-def root():
-    # Avoid missing-template errors. Keep it simple so external access works.
-    return jsonify(message="FIND APIs root. Use /health or /testpage."), 200
-
-# -------------------- Headers Filtering Find 1 Space --------------------
-@app.route('/api/process-data', methods=['POST'])
-def process_headers():
-    try:
-        data = request.get_json(force=True) or {}
-        filePath = data.get('filePath')
-        if not filePath:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        headers = findInitialMarkups.headersfrompdf(filePath)
-        return jsonify(headers)
-    except Exception as e:
-        print(f"Error in /api/process-data: {e}")
-        return jsonify({"error": str(e)}), 500
+import requests
+from io import BytesIO
+import fitz  # PyMuPDF
 
-# -------------------- PDF to Text 1 Space --------------------
-@app.route('/processalltext1', methods=['POST'])
-def processalltextTotext():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfpath = data.get('filePath')
-        if not pdfpath:
-            return jsonify({"error": "Missing 'filePath' in request data"}), 400
-        pdftext,filename = pdftotext.texts_from_pdfAllText(pdfpath)
-        return jsonify({"message": "Data received", "input_data": pdftext,"Filename:":filename})
-    except Exception as e:
-        print(f"Error in /processalltext1: {e}")
-        return jsonify({"error": str(e)}), 500
 
-# -------------------- Keepalive --------------------
-@app.route("/keepaliveapii", methods=["GET", "POST"])
-def keepaliveapi():
-    try:
-        print('Keepalive pinged')
-        return 'alivee'
-    except Exception as error:
-        print('Error in keepalive:', error)
-        return jsonify(status="error", message=str(error)), 500
-
-# -------------------- View PDF (Marked up) --------------------
-def getpdfcontent(pdf_path):
-    # Handle Dropbox URLs
-    if pdf_path and ('http' in pdf_path or 'dropbox' in pdf_path):
-        pdf_path = pdf_path.replace('dl=0', 'dl=1')
-
-    # Get the PDF bytes
-    response = requests.get(pdf_path)
-    pdf_bytes = response.content
 
-    if not pdf_bytes or not pdf_bytes.startswith(b"%PDF"):
-        raise ValueError("No valid PDF content found.")
 
-    # Return a BytesIO stream
-    return BytesIO(pdf_bytes)
+def get_toc_page_numbers(doc, max_pages_to_check=15):
+    toc_pages = []
 
+    # 1. Existing Dot Pattern (looking for ".....")
+    dot_pattern = re.compile(r"\.{2,}")
 
-@app.route('/view-pdf', methods=['GET'])
-def view_pdf():
-    encoded_pdf_link = request.args.get('pdfLink')
-    if not encoded_pdf_link:
-        return "Missing pdfLink parameter.", 400
+    # 2. NEW: Title Pattern (looking for specific headers)
+    # ^ and $ ensure the line is JUST that word (ignoring "The contents of the bag...")
+    # re.IGNORECASE makes it match "CONTENTS", "Contents", "Index", etc.
+    title_pattern = re.compile(r"^\s*(table of contents|contents|index)\s*$", re.IGNORECASE)
 
-    pdf_link = unquote(encoded_pdf_link)
-    print("Extracted PDF Link:", pdf_link)
+    for page_num in range(min(len(doc), max_pages_to_check)):
+        page = doc.load_page(page_num)
+        blocks = page.get_text("dict")["blocks"]
 
-    try:
-        pdf_content = getpdfcontent(pdf_link)
-    except Exception as e:
-        print("Error during PDF extraction:", e)
-        return "PDF could not be processed.", 500
-
-    if pdf_content is None:
-        return "PDF content not found or broken.", 404
-
-    # ✅ Do NOT wrap again in BytesIO
-    return send_file(
-        pdf_content,
-        mimetype='application/pdf',
-        as_attachment=False,
-        download_name="annotated_page.pdf"
-    )
+        dot_line_count = 0
+        has_toc_title = False
 
-# -------------------- Process PDF -> Upload to Dropbox (renamed to avoid duplicate route) --------------------
-@app.route('/api/process-pdf', methods=['POST'])
-def process_pdf_and_upload():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "'filePath' must be provided."}), 400
-
-        print("Processing PDF:", pdfLink)
-        pdfbytes, pdf_document, tablepdfoutput = InitialMarkups.extract_section_under_header(pdfLink)
-
-        dbxTeam = tsadropboxretrieval.ADR_Access_DropboxTeam('user')
-        metadata = dbxTeam.sharing_get_shared_link_metadata(pdfLink)
-
-        dbPath = '/TSA JOBS/ADR Test/FIND/'
-        pdflink = tsadropboxretrieval.uploadanyFile(doc=pdf_document, path=dbPath, pdfname=metadata.name)
-        tablepdfLink = tsadropboxretrieval.uploadanyFile(
-            doc=tablepdfoutput,
-            path=dbPath,
-            pdfname=metadata.name.rsplit(".pdf", 1)[0] + ' Markup Summary.pdf'
-        )
-        print('Uploaded:', pdflink, tablepdfLink)
+        for block in blocks:
+            for line in block.get("lines", []):
+                # Extract text from spans (mimicking get_spaced_text_from_spans)
+                line_text = " ".join([span["text"] for span in line["spans"]]).strip()
 
-        return jsonify({
-            "message": "PDF processed successfully.",
-            "PDF_MarkedUp": pdflink,
-            "Table_PDF_Markup_Summary": tablepdfLink
-        })
-    except Exception as e:
-        print(f"Error in /api/process-pdf: {e}")
-        return jsonify({"error": str(e)}), 500
+                # CHECK A: Does the line have dots?
+                if dot_pattern.search(line_text):
+                    dot_line_count += 1
 
-# -------------------- Not billed / Markup subsets --------------------
-@app.route('/findapitobebilled1', methods=['GET','POST'])
-def findapitobebilled1():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        pdfbytes, pdf_document, tablepdfoutput, alltext_tobebilled, alltextNoNotbilled , filename = InitialMarkups.extract_section_under_header_tobebilledOnly(pdfLink)
-        
-        return jsonify(alltext_tobebilled)
-    except Exception as e:
-        print(f"Error in /findapitobebilled1: {e}")
-        return jsonify({"error": str(e)}), 500
-    
+                # CHECK B: Is this line a Title?
+                # We check this early in the loop. If a page has a title "Contents",
+                # we mark it immediately.
+                if title_pattern.match(line_text):
+                    has_toc_title = True
 
-# ----------------------------------------------------------------------
-@app.route('/findapitobebilled_htmlformat', methods=['GET','POST'])
-def findapitobebilled_htmlformat():  
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        pdfbytes, pdf_document, tablepdfoutput, alltext_tobebilled, alltextNoNotbilled , filename = InitialMarkups.extract_section_under_header_tobebilledOnly(pdfLink)
-        # Parse JSON string → list of dicts
-        data = json.loads(tablepdfoutput)
-
-        # Collect all body parts
-        html_body = ""
-
-        for section in data:
-            if "head above 2" in section:
-                html_body += f"<h1>{section['head above 2']}</h1><br>"
-
-            if "head above 1" in section:
-                html_body += f"<h2>{section['head above 1']}</h2><br>"
-
-            if "Subject" in section:
-                html_body += f"<h3>{section['Subject']}</h3><br>"
-                if "BodyText" in section:
-                    html_body += f"<p>{' '.join(section['BodyText'])}</p><br>"
-                    # html_body += f"<div>{' '.join(section['bodytext'])}</div><br>"
-
-        # Wrap everything into one HTML document
-        html_content = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>{filename}</title>
-            <meta charset="utf-8">
-        </head>
-        <body>
-            {html_body}
-        </body>
-        </html>
-        """
-        # return Response(html_content, mimetype="text/html", headers={"Filename": filename})
-        return jsonify({"input_data": html_content,"Filename:":filename})
-    except Exception as e:
-        print(f"Error in /findapitobebilled_htmlformat: {e}")
-        return jsonify({"error": str(e)}), 500
+        # CONDITION:
+        # It is a TOC page if it has a Title OR if it has dot leaders.
+        # We use 'dot_line_count >= 1' to be sensitive to single-item lists.
+        if has_toc_title or dot_line_count >= 1:
+            toc_pages.append(page_num)
 
+    # RETURN:
+    # If we found TOC pages (e.g., [2, 3]), we return [0, 1, 2, 3]
+    # This covers the cover page, inside cover, and the TOC itself.
+    if toc_pages:
+        last_toc_page = toc_pages[0]
+        return list(range(0, last_toc_page + 1))
+
+    return [] # Return empty list if nothing found
 
-@app.route('/view-pdf-tobebilled', methods=['GET'])
-def view_pdf_tobebilled():
-    encoded_pdf_link = request.args.get('pdfLink')
-    if not encoded_pdf_link:
-        return "Missing pdfLink parameter.", 400
-    pdf_link = unquote(encoded_pdf_link)
-    print("Extracted PDF Link:", pdf_link)
-    try:
-        pdf_content = InitialMarkups.extract_section_under_header_tobebilledOnly(pdf_link)[0]
-    except Exception as e:
-        print("Error during PDF extraction:", e)
-        return "PDF could not be processed.", 500
-    if pdf_content is None or not pdf_content.startswith(b"%PDF"):
-        return "PDF content not found or broken.", 404
-    return send_file(
-        BytesIO(pdf_content),
-        mimetype='application/pdf',
-        as_attachment=False,
-        download_name=f"annotated_page_{pageNumTextFound}.pdf"
-    )
 
-# -------------------- Final markups: view one highlight --------------------
-@app.route('/view-highlight', methods=['GET','POST'])
-def download_pdfHighlight():
-    pdf_link = request.args.get('pdfLink')
-    keyword = request.args.get('keyword')
-    if not pdf_link or not keyword:
-        return "Missing required parameters.", 400
-
-    pdf_link = unquote(pdf_link)
-    print("Extracted PDF Link:", pdf_link)
-    print("Extracted Keyword:", keyword)
-
-    global jsonoutput
-    matching_item = next((item for item in jsonoutput if item.get("Subject") == keyword), None)
-
-    if matching_item:
-        page_number = int(matching_item.get("Page")) - 1
-        stringtowrite = matching_item.get("head above 1")
-        print(f"Page number for '{keyword}': {page_number}")
-    else:
-        page_number = 0
-        stringtowrite = None
-        print("No match found in jsonoutput; defaulting to page 0.")
-
-    pdf_content = InitialMarkups.extract_section_under_headerRawan(pdf_link, keyword, page_number, stringtowrite)[0]
-    if pdf_content is None:
-        return "PDF content not found.", 404
-
-    return send_file(
-        BytesIO(pdf_content),
-        mimetype='application/pdf',
-        as_attachment=False,
-        download_name=f"annotated_page_{pageNumTextFound}.pdf"
+def openPDF(pdf_path): 
+    pdf_path = pdf_path.replace('dl=0', 'dl=1')
+    response = requests.get(pdf_path)
+    pdf_content = BytesIO(response.content)
+    if not pdf_content:
+        raise ValueError("No valid PDF content found.")
+    
+    doc = fitz.open(stream=pdf_content, filetype="pdf")
+    return doc
+
+def identify_headers_with_openrouter(pdf_path, model,LLM_prompt, pages_to_check=None, top_margin=70, bottom_margin=85):
+    """Ask an LLM (OpenRouter) to identify headers in the document.
+
+    Returns a list of dicts: {text, page, suggested_level, confidence}.
+    The function sends plain page-line strings to the LLM (including page numbers)
+    and asks for a JSON array containing only header lines with suggested levels.
+    """
+    doc=openPDF(pdf_path)
+    api_key='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'
+    if api_key is None:
+       
+        api_key = os.getenv("OPENROUTER_API_KEY") or None
+
+    toc_pages = get_toc_page_numbers(doc)
+    lines_for_prompt = []
+
+    # Collect text lines from pages (skip TOC pages)
+    for pno in range(len(doc)):
+        if pages_to_check and pno not in pages_to_check:
+            continue
+        if pno in toc_pages:
+            continue
+        page = doc.load_page(pno)
+        page_height = page.rect.height
+        for block in page.get_text("dict").get('blocks', []):
+            if block.get('type') != 0:
+                continue
+            for line in block.get('lines', []):
+                spans = line.get('spans', [])
+                if not spans:
+                    continue
+                y0 = spans[0]['bbox'][1]
+                y1 = spans[0]['bbox'][3]
+                if y0 < top_margin or y1 > (page_height - bottom_margin):
+                    continue
+                text = " ".join(s.get('text','') for s in spans).strip()
+                if text:
+                    # prefix with page for easier mapping back
+                    lines_for_prompt.append(f"PAGE {pno+1}: {text}")
+
+    if not lines_for_prompt:
+        return []
+
+    prompt = (
+        LLM_prompt.join(lines_for_prompt)
     )
 
-@app.route('/findapiFilteredHeadings', methods=['GET','POST'])
-def findapiFilteredHeadings():
+    if not api_key:
+        # No API key: return empty so caller can fallback to heuristics
+        return []
+
+    url = "https://openrouter.ai/api/v1/chat/completions"
+
+    # Build headers following the OpenRouter example
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": os.getenv("OPENROUTER_REFERER", ""),
+        "X-Title": os.getenv("OPENROUTER_X_TITLE", "")
+    }
+
+    # Wrap the prompt as the example 'content' array expected by OpenRouter
+    body = {
+        "model": model,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt}
+                ]
+            }
+        ]
+    }
+
+    # Debug: log request body (truncated) and write raw response for inspection
     try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        listofheadings = data.get('listofheadings')  # json array
-        if not pdfLink or listofheadings is None:
-            return jsonify({"error": "Missing 'filePath' or 'listofheadings'"}), 400
-
-        pdfbytes, pdf_document, tablepdfoutput, alltext = InitialMarkups.extract_section_under_headerRawan(pdfLink, listofheadings)
-        global jsonoutput
-        jsonoutput = tablepdfoutput
-        return jsonify(alltext)
-    except Exception as e:
-        print(f"Error in /findapiFilteredHeadings: {e}")
-        return jsonify({"error": str(e)}), 500
+        print("LLM request (truncated):", prompt[:1000])
+        resp = requests.post(
+            url=url,
+            headers=headers,
+            data=json.dumps(body),
 
-@app.route('/findapitobebilledonlyNew', methods=['GET','POST'])
-def findapitobebilledonly():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        pdfbytes, pdf_document, tablepdfoutput, alltext , filename= InitialMarkups.extract_section_under_header_tobebilled2(pdfLink)
-        # return jsonify(tablepdfoutput)
-                # Parse JSON string → list of dicts
-        data = json.loads(tablepdfoutput)
-
-        # Collect all body parts
-        html_body = ""
-
-        for section in data:
-            if "head above 2" in section:
-                html_body += f"<h1>{section['head above 2']}</h1><br>"
-
-            if "head above 1" in section:
-                html_body += f"<h2>{section['head above 1']}</h2><br>"
-
-            if "Subject" in section:
-                html_body += f"<h3>{section['Subject']}</h3><br>"
-                if "BodyText" in section:
-                    html_body += f"<p>{' '.join(section['BodyText'])}</p><br>"
-                    # html_body += f"<div>{' '.join(section['bodytext'])}</div><br>"
-
-        # Wrap everything into one HTML document
-        html_content = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>{filename}</title>
-            <meta charset="utf-8">
-        </head>
-        <body>
-            {html_body}
-        </body>
-        </html>
-        """
-        # return Response(html_content, mimetype="text/html", headers={"Filename": filename})
-        return jsonify({"input_data": html_content,"Filename:":filename})
-        # return Response(html_content, mimetype="text/html", headers={"Filename": filename})
+        )
+        resp.raise_for_status()
+        resp_text = resp.text
+        print("LLM raw response length:", len(resp_text))
+        # Save raw response for offline inspection
+        try:
+            with open("llm_debug.json", "w", encoding="utf-8") as fh:
+                fh.write(resp_text)
+        except Exception as e:
+            print("Warning: could not write llm_debug.json:", e)
+        rj = resp.json()
+        print("LLM parsed response keys:", list(rj.keys()) if isinstance(rj, dict) else type(rj))
     except Exception as e:
-        print(f"Error in /findapitobebilledonly: {e}")
-        return jsonify({"error": str(e)}), 500
+        print("LLM call failed:", repr(e))
+        return []
+
+    # Extract textual reply robustly
+    text_reply = None
+    if isinstance(rj, dict):
+        choices = rj.get('choices') or []
+        if choices:
+            c0 = choices[0]
+            msg = c0.get('message') or c0.get('delta') or {}
+            content = msg.get('content')
+            if isinstance(content, list):
+                for c in content:
+                    if c.get('type') == 'text' and c.get('text'):
+                        text_reply = c.get('text')
+                        break
+            elif isinstance(content, str):
+                text_reply = content
+            elif isinstance(msg, dict) and msg.get('content') and isinstance(msg.get('content'), dict):
+                text_reply = msg.get('content').get('text')
+    if not text_reply:
+        for c in rj.get('choices', []):
+            if isinstance(c.get('text'), str):
+                text_reply = c.get('text')
+                break
+
+    if not text_reply:
+        return []
+
+    s = text_reply.strip()
+    start = s.find('[')
+    end = s.rfind(']')
+    js = s[start:end+1] if start != -1 and end != -1 else s
+    try:
+        parsed = json.loads(js)
+    except Exception:
+        return []
 
+    # Normalize parsed entries and return
+    out = []
+    for obj in parsed:
+        t = obj.get('text')
+        page = int(obj.get('page')) if obj.get('page') else None
+        level = obj.get('suggested_level')
+        conf = float(obj.get('confidence') or 0)
+        if t and page is not None:
+            out.append({'text': t, 'page': page-1, 'suggested_level': level, 'confidence': conf})
 
+    return out
 
-@app.route('/findapitobebilledonlyNewMultiplePDFS', methods=['GET','POST'])
-def findapitobebilledonlymarthe():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        pdfbytes, pdf_document, tablepdfoutput, alltext , filename= InitialMarkups.extract_section_under_header_tobebilledMultiplePDFS(pdfLink)
-        # return jsonify(tablepdfoutput)
-                # Parse JSON string → list of dicts
-        if isinstance(tablepdfoutput, str):
-            data = json.loads(tablepdfoutput)
-        else:
-            data = tablepdfoutput
-        # Collect all body parts
-        html_body = ""
-
-        for section in data:
-            if "head above 2" in section:
-                html_body += f"<h1>{section['head above 2']}</h1><br>"
-
-            if "head above 1" in section:
-                html_body += f"<h2>{section['head above 1']}</h2><br>"
-
-            if "Subject" in section:
-                html_body += f"<h3>{section['Subject']}</h3><br>"
-                if "BodyText" in section:
-                    html_body += f"<p>{' '.join(section['BodyText'])}</p><br>"
-                    # html_body += f"<div>{' '.join(section['bodytext'])}</div><br>"
-
-        # Wrap everything into one HTML document
-        html_content = f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <title>{filename}</title>
-            <meta charset="utf-8">
-        </head>
-        <body>
-            {html_body}
-        </body>
-        </html>
-        """
-        # return Response(html_content, mimetype="text/html", headers={"Filename": filename})
-        return jsonify({"input_data": html_content,"Filename:":filename})
-        # return Response(html_content, mimetype="text/html", headers={"Filename": filename})
-    except Exception as e:
-        print(f"Error in /findapitobebilledonly: {e}")
-        return jsonify({"error": str(e)}), 500
 
 
-@app.route('/findapiAllDocNoNotbilled', methods=['GET','POST'])
-def findapiAllDocNoNotbilled():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        pdfbytes, pdf_document, tablepdfoutput, alltext_tobebilled, alltextNoNotbilled ,filename= InitialMarkups.extract_section_under_header_tobebilledOnly(pdfLink)
-        return jsonify(alltextNoNotbilled)
-    except Exception as e:
-        print(f"Error in /findapiAllDocNoNotbilled: {e}")
-        return jsonify({"error": str(e)}), 500
+iface = gr.Interface(
+    fn=identify_headers_with_openrouter,
+    inputs=[gr.Textbox(label="Document Link"),
+        gr.Textbox(label="Model Type"),
+        gr.Textbox(label="LLM Prompt")]
+    outputs=gr.Textbox(label="Output")
+)
 
-# -------------------- Rawan - MC Connection --------------------
-@app.route('/findapi', methods=['GET','POST'])
-def findapi():
-    try:
-        data = request.get_json(force=True) or {}
-        pdfLink = data.get('filePath')
-        if not pdfLink:
-            return jsonify({"error": "Missing 'filePath'"}), 400
-        
-        pdfbytes, pdf_document, tablepdfoutput = InitialMarkups.extract_section_under_header(pdfLink)
-        global jsonoutput
-        jsonoutput = tablepdfoutput
-        return jsonify(tablepdfoutput)
-    except Exception as e:
-        print(f"Error in /findapi: {e}")
-        return jsonify({"error": str(e)}), 500
-
-#--------------------testpage-----------------------------
-import socket
-from datetime import datetime
-
-@app.route('/testpage')
-def test_page():
-    # Get some system info
-    hostname = socket.gethostname()
-    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    
-    return f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>Server Test Page</title>
-        <style>
-            body {{ font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }}
-            .success {{ color: #2ecc71; font-size: 24px; }}
-            .info {{ color: #34495e; margin-top: 10px; }}
-            .container {{ max-width: 600px; margin: 0 auto; text-align: left; }}
-        </style>
-    </head>
-    <body>
-        <div class="success">🚀 Flask Server is Running!</div>
-        <div class="container">
-            <p class="info"><strong>Hostname:</strong> {hostname}</p>
-            <p class="info"><strong>Server Time:</strong> {current_time}</p>
-            <p class="info"><strong>Endpoint:</strong> /testpage</p>
-            <p class="info"><strong>Status:</strong> <span style="color: #2ecc71;">Operational ✅</span></p>
-        </div>
-    </body>
-    </html>
-    """   
-
-# -------------------- Run --------------------   
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5000, debug=True)
+iface.launch()