added simple formatting

app.py

@@ -3,18 +3,19 @@ import os
 import tempfile
 import dwani
 import logging
+import re
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configure dwani API settings
+# Configure dwani API settings from environment variables
 dwani.api_key = os.getenv("DWANI_API_KEY")
 dwani.api_base = os.getenv("DWANI_API_BASE_URL")
 
-# Log API configuration for debugging
-logger.debug("DWANI_API_KEY: %s", "Set" if dwani.api_key else "Not set")
-logger.debug("DWANI_API_BASE_URL: %s", dwani.api_base)
+if not dwani.api_key or not dwani.api_base:
+    logger.error("API key or base URL not set. Please set DWANI_API_KEY and DWANI_API_BASE_URL environment variables.")
+    raise RuntimeError("Please set DWANI_API_KEY and DWANI_API_BASE_URL environment variables.")
 
 # Language options for dropdowns (display name and code)
 language_options = [
@@ -23,10 +24,7 @@ language_options = [
     ("Hindi", "hin_Deva")
 ]
 
-# Create lists for Gradio dropdowns (display names only)
 language_names = [lang[0] for lang in language_options]
-
-# Map display names to language codes
 lang_code_map = {lang[0]: lang[1] for lang in language_options}
 
 
@@ -58,10 +56,59 @@ def parse_page_numbers(pages_str):
     return sorted(pages)
 
 
+def simple_format_resume(text):
+    """
+    Basic formatting for resume text:
+    - Convert '** text **' to bold <b>text</b>
+    - Replace multiple dots or underscores with horizontal lines
+    - Preserve line breaks with <br>
+    """
+    # Convert ** bold ** to <b>bold</b>
+    text = re.sub(r"\*\*\s*(.*?)\s*\*\*", r"<b>\1</b>", text)
+
+    # Replace long sequences of dots or underscores with <hr>
+    text = re.sub(r"([.\-_])\1{5,}", "<hr>", text)
+
+    # Preserve line breaks
+    text = text.replace('\r\n', '\n').replace('\r', '\n')
+    text = text.replace('\n', '<br>')
+
+    return text
+
+
+def results_to_html(results):
+    """
+    Convert the results dictionary into an HTML formatted string,
+    applying basic formatting to preserve resume style.
+    """
+    html_lines = []
+    for page, content in results.items():
+        html_lines.append(f"<h2>{page}</h2>")
+        if "error" in content:
+            html_lines.append(f"<p style='color:red;'><b>Error:</b> {content['error']}</p>")
+        else:
+            html_lines.append("<h3>Original Text:</h3>")
+            original_html = simple_format_resume(content.get('Original Text', ''))
+            html_lines.append(f"<div style='background:#f0f0f0; padding:10px; border-radius:5px;'>{original_html}</div>")
+
+            response_text = content.get('Response', '')
+            if response_text:
+                html_lines.append(f"<p><b>Response:</b><br>{response_text}</p>")
+
+            html_lines.append(f"<p><b>Processed Page:</b> {content.get('Processed Page', '')}</p>")
+
+            translated_html = simple_format_resume(content.get('Translated Response', ''))
+            html_lines.append("<h3>Translated Resume:</h3>")
+            html_lines.append(f"<div style='background:#e8f5e9; padding:10px; border-radius:5px;'>{translated_html}</div>")
+
+        html_lines.append("<hr>")
+    return "\n".join(html_lines)
+
+
 def results_to_markdown(results):
     """
     Convert the results dictionary into a Markdown formatted string,
-    formatting the translated response to preserve structure using <pre> tags.
+    preserving the translated resume content in code blocks.
     """
     md_lines = []
     for page, content in results.items():
@@ -80,63 +127,47 @@ def results_to_markdown(results):
             md_lines.append("**Processed Page:** " + str(content.get('Processed Page', '')) + "\n")
 
             translated = content.get('Translated Response', '')
-
-            # Normalize newlines
-            translated = translated.replace('\r\n', '\n').replace('\r', '\n')
-
-            # Use <pre> tags to preserve formatting exactly
-            md_lines.append("**Translated Response:**\n\n<pre>")
-            md_lines.append(translated)
-            md_lines.append("</pre>")
+            md_lines.append("**Translated Resume:**\n\n```")
+            md_lines.append(translated + "\n")
+            md_lines.append("```\n")
 
         md_lines.append("\n---\n")
     return "\n".join(md_lines)
 
 
 def process_pdf(pdf_file, pages_str, prompt, src_lang, tgt_lang):
-    logger.debug("Received inputs - PDF: %s, Pages: %s, Prompt: %s, Source Lang: %s, Target Lang: %s",
-                 pdf_file, pages_str, prompt, src_lang, tgt_lang)
+    logger.info(f"Processing PDF: {pdf_file}, Pages: {pages_str}, Prompt: {prompt}, Source: {src_lang}, Target: {tgt_lang}")
 
-    # Validate inputs
     if not pdf_file:
-        logger.error("No PDF file provided")
         return "Error: Please upload a PDF file", None
 
     if not prompt.strip():
-        logger.error("Prompt is empty")
         return "Error: Please provide a non-empty prompt", None
 
     pages = parse_page_numbers(pages_str)
     if not pages:
-        logger.error("Invalid or empty page numbers input: %s", pages_str)
         return "Error: Please provide valid page numbers (e.g., 1,3,5 or 1-3)", None
 
-    # Get language codes
     src_lang_code = lang_code_map.get(src_lang)
     tgt_lang_code = lang_code_map.get(tgt_lang)
 
     if not src_lang_code or not tgt_lang_code:
-        logger.error("Invalid language selection - Source: %s, Target: %s", src_lang, tgt_lang)
         return "Error: Invalid source or target language selection", None
 
-    # Get file path from Gradio File object
     file_path = pdf_file.name if hasattr(pdf_file, 'name') else pdf_file
 
-    logger.debug("Calling API with file: %s, pages: %s, prompt: %s, src_lang: %s, tgt_lang: %s",
-                 file_path, pages, prompt, src_lang_code, tgt_lang_code)
-
     results = {}
     for page_number in pages:
         try:
+            # Call Dwani API (without 'prompt' arg as it's unsupported)
             result = dwani.Documents.run_extract(
                 file_path=file_path,
                 page_number=page_number,
                 src_lang=src_lang_code,
                 tgt_lang=tgt_lang_code
             )
-            logger.debug("API response for page %d: %s", page_number, result)
+            logger.debug(f"API response for page {page_number}: {result}")
 
-            # New response format: result contains 'pages' list
             page_data = None
             for p in result.get('pages', []):
                 if p.get('processed_page') == page_number:
@@ -151,47 +182,49 @@ def process_pdf(pdf_file, pages_str, prompt, src_lang, tgt_lang):
                 "Processed Page": page_data.get("processed_page", "N/A"),
                 "Original Text": page_data.get("page_content", "N/A"),
                 "Translated Response": page_data.get("translated_content", "N/A"),
-                # The old 'Response' key is not in new data; set empty string
                 "Response": ""
             }
-        except dwani.exceptions.DhwaniAPIError as e:
-            logger.error("Dhwani API error on page %d: %s", page_number, str(e))
+        except dwani.exceptions.DwaniAPIError as e:
+            logger.error(f"Dwani API error on page {page_number}: {e}")
             results[f"Page {page_number}"] = {"error": f"API error: {str(e)}"}
         except Exception as e:
-            logger.error("Unexpected error on page %d: %s", page_number, str(e))
+            logger.error(f"Unexpected error on page {page_number}: {e}")
             results[f"Page {page_number}"] = {"error": f"Unexpected error: {str(e)}"}
 
-    # Convert results to markdown text
-    markdown_text = results_to_markdown(results)
+    # Convert results to HTML for display
+    html_text = results_to_html(results)
 
-    # Save markdown to a temporary file for download
+    # Save markdown for download
+    markdown_text = results_to_markdown(results)
     temp_md_file = tempfile.NamedTemporaryFile(delete=False, suffix=".md", mode='w', encoding='utf-8')
     temp_md_file.write(markdown_text)
     temp_md_file.close()
 
-    # Return markdown text and file path for download
-    return markdown_text, temp_md_file.name
+    return html_text, temp_md_file.name
 
 
-# Define Gradio interface
-with gr.Blocks(title="PDF Custom Prompt Processor with Multi-Page Support") as demo:
-    gr.Markdown("# PDF Custom Prompt Processor")
-    gr.Markdown("Upload a PDF, specify page numbers (comma-separated or ranges), enter a prompt, and select source and target languages.")
+# Gradio UI
+with gr.Blocks(title="Resume Translator") as demo:
+    gr.Markdown("# Resume Translator")
+    gr.Markdown(
+        "Upload your resume PDF, specify pages to translate, enter a prompt (e.g., 'Translate the resume'), "
+        "and select source and target languages."
+    )
 
     with gr.Row():
         with gr.Column():
-            pdf_input = gr.File(label="Upload PDF", file_types=[".pdf"])
+            pdf_input = gr.File(label="Upload Resume PDF", file_types=[".pdf"])
             pages_input = gr.Textbox(
                 label="Page Numbers",
                 placeholder="e.g., 1,3,5 or 1-3",
                 value="1",
                 lines=1
             )
-            prompt = gr.Textbox(
+            prompt_input = gr.Textbox(
                 label="Custom Prompt",
-                placeholder="e.g., List the key points",
-                value="List the key points",
-                lines=3
+                placeholder="e.g., Translate the resume",
+                value="Translate the resume",
+                lines=2
             )
             src_lang_input = gr.Dropdown(
                 label="Source Language",
@@ -203,24 +236,18 @@ with gr.Blocks(title="PDF Custom Prompt Processor with Multi-Page Support") as d
                 choices=language_names,
                 value="Kannada"
             )
-            submit_btn = gr.Button("Process")
+            submit_btn = gr.Button("Translate")
 
         with gr.Column():
-            output_md = gr.Markdown(label="Response (Markdown)")
-            download_md = gr.File(label="Download Markdown File")
+            output_html = gr.HTML(label="Translated Resume Output")
+            download_md = gr.File(label="Download Translated Resume (Markdown)")
 
     submit_btn.click(
         fn=process_pdf,
-        inputs=[pdf_input, pages_input, prompt, src_lang_input, tgt_lang_input],
-        outputs=[output_md, download_md]
+        inputs=[pdf_input, pages_input, prompt_input, src_lang_input, tgt_lang_input],
+        outputs=[output_html, download_md]
     )
 
 
-# Launch the interface
 if __name__ == "__main__":
-    if not dwani.api_key or not dwani.api_base:
-        logger.error("API key or base URL not set. Please set DWANI_API_KEY and DWANI_API_BASE_URL environment variables.")
-        print("Error: Please set DWANI_API_KEY and DWANI_API_BASE_URL environment variables.")
-    else:
-        logger.debug("Starting Gradio interface...")
-        demo.launch()
+    demo.launch()