Update app.py

app.py

@@ -3,51 +3,44 @@ import base64
 import json
 import re
 import html
-from typing import Dict, List, Union, Any
 
-def decode_proxy_entry(encoded_str: str) -> Dict[str, Any]:
-    """Decode a single proxy entry with better error handling"""
+def decode_proxy_entry(encoded_str):
     try:
-        # Remove padding if needed and decode
-        padding = len(encoded_str) % 4
-        if padding:
-            encoded_str += '=' * (4 - padding)
-            
+        # Step 1: Base64 decode
         decoded_bytes = base64.b64decode(encoded_str)
+        
+        # Step 2: Convert hex to ASCII
         hex_string = decoded_bytes.decode('ascii')
         json_string = bytes.fromhex(hex_string).decode('ascii')
+        
+        # Step 3: Parse JSON
         return json.loads(json_string)
     except Exception as e:
-        return {"error": f"Decoding failed: {str(e)}", "input_length": len(encoded_str)}
+        return {"error": f"Decoding failed: {str(e)}"}
 
-def extract_and_decode_html(html_content: str) -> Union[str, List[Dict]]:
-    """Extract and decode all entries from HTML with improved parsing"""
+def process_html_input(html_content):
     try:
+        # First, unescape HTML entities
         unescaped_html = html.unescape(html_content)
         
-        # Multiple patterns to catch different HTML formats
-        patterns = [
-            r'data-ss="\[(.*?)\]"',
-            r"data-ss='\[(.*?)\]'",
-            r'data-ss=\s*\[\s*(.*?)\s*\]'
-        ]
+        # Extract data-ss array using regex
+        pattern = r'data-ss="\[(.*?)\]"'
+        match = re.search(pattern, unescaped_html, re.DOTALL)
         
-        data_ss_content = None
-        for pattern in patterns:
-            match = re.search(pattern, unescaped_html, re.DOTALL)
-            if match:
-                data_ss_content = match.group(1)
-                break
+        if not match:
+            return {"error": "No data-ss attribute found in the HTML"}
         
-        if not data_ss_content:
-            return "No data-ss attribute found in the HTML"
+        data_ss_content = match.group(1)
         
-        # Improved regex for base64 strings
-        base64_pattern = r'["\']([A-Za-z0-9+/=]+)["\']'
-        entries = re.findall(base64_pattern, data_ss_content)
+        # Extract individual base64 strings
+        entries = re.findall(r'"([A-Za-z0-9+/=]+)"', data_ss_content)
         
+        # If no matches with ", try regular quotes
         if not entries:
-            return "No base64 encoded entries found in data-ss attribute"
+            entries = re.findall(r'"([A-Za-z0-9+/=]+)"', data_ss_content)
+        
+        if not entries:
+            return {"error": "No base64 encoded entries found in data-ss attribute"}
         
         results = []
         for i, entry in enumerate(entries):
@@ -55,156 +48,82 @@ def extract_and_decode_html(html_content: str) -> Union[str, List[Dict]]:
                 result = decode_proxy_entry(entry)
                 results.append({
                     "entry": i + 1,
-                    "encoded_string": entry[:30] + "..." + entry[-10:] if len(entry) > 50 else entry,
-                    "decoded_data": result,
-                    "status": "success"
+                    "decoded_data": result
                 })
             except Exception as e:
                 results.append({
                     "entry": i + 1,
-                    "encoded_string": entry[:30] + "..." + entry[-10:] if len(entry) > 50 else entry,
-                    "error": f"Failed to decode: {str(e)}",
-                    "status": "error"
+                    "error": f"Failed to decode: {str(e)}"
                 })
         
-        return results
+        return {"results": results, "total_entries": len(results)}
     except Exception as e:
-        return f"Error processing HTML: {str(e)}"
+        return {"error": f"Error processing HTML: {str(e)}"}
 
-def process_html_input(html_content: str) -> Dict[str, Any]:
-    """Process HTML input with statistics"""
-    results = extract_and_decode_html(html_content)
-    
-    if isinstance(results, str):
-        return {"error": results}
-    
-    # Add statistics
-    success_count = sum(1 for r in results if r.get('status') == 'success')
-    error_count = sum(1 for r in results if r.get('status') == 'error')
-    
-    formatted_results = {
-        "statistics": {
-            "total_entries": len(results),
-            "successful_decodes": success_count,
-            "failed_decodes": error_count
-        },
-        "entries": {}
-    }
-    
-    for result in results:
-        formatted_results["entries"][f"Entry {result['entry']}"] = result
-    
-    return formatted_results
+def decode_single_entry(encoded_string):
+    try:
+        result = decode_proxy_entry(encoded_string)
+        return result
+    except Exception as e:
+        return {"error": str(e)}
 
-# Your HTML data remains the same
-your_html_data = '''<script
+# Test HTML data (shortened for performance)
+test_html = '''<script
     id="serverSelectorScript"
-    data-u="&quot;https://adnade.net/ptp/?user=platformsincome&amp;subid=131370&quot;"
-    data-d="0"
-    data-ss="[&quot;N2IyMjY5NjQyMjNhMzIzMDMxMmMyMjc1NzI2YzIyM2EyMjY4NzQ3NDcwNzMzYTVjMmY1YzJmMzEzMDM4MmUzMTM4MzEyZTMxMzEyZTMxMzczMTVjMmY1ZjVmNjM3MDMyMmU3MDY4NzAyMjJjMjI2ZTYxNmQ2NTIyM2EyMjcwNzM3OTYzNjg3YTRjNmY3MzQxNmU2NzY1NmM2NTczMzI0ZDIyN2Q=&quot;,&quot;N2IyMjY5NjQyMjNhMzEzODM1MmMyMjc1NzI2YzIyM2EyMjY4NzQ3NDcwNzMzYTVjMmY1YzJmMzkzNTJlMzIzMTM0MmUzNTMzMmUzNDM4NWMyZjVmNWY2MzcwMzIyZTcwNjg3MDIyMmMyMjZlNjE2ZDY1MjIzYTIyNmQ2NTc2NTM3MDYxNjM2NTU3NjE3MjczNjE3NzUwMjI3ZA==&quot;,...]"
+    data-ss="[&quot;N2IyMjY5NjQyMjNhMzIzMDMxMmMyMjc1NzI2YzIyM2EyMjY4NzQ3NDcwNzMzYTVjMmY1YzJmMzEzMDM4MmUzMTM4MzEyZTMxMzEyZTMxMzczMTVjMmY1ZjVmNjM3MDMyMmU3MDY4NzAyMjJjMjI2ZTYxNmQ2NTIyM2EyMjcwNzM3OTYzNjg3YTRjNmY3MzQxNmU2NzY1NmM2NTczMzI0ZDIyN2Q=&quot;]"
 ></script>'''
 
-# Enhanced Gradio interface
-with gr.Blocks(title="Proxy Server Decoder", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🔍 Proxy Server Decoder
-    Decode base64-encoded proxy server information from HTML script tags.
-    """)
-    
-    with gr.Tab("🧩 Single Entry Decoder"):
-        gr.Markdown("Decode a single base64 encoded proxy entry")
-        with gr.Row():
-            with gr.Column():
-                single_input = gr.Textbox(
-                    label="Base64 Encoded String",
-                    placeholder="Paste your base64 string here...",
-                    lines=3,
-                    max_lines=5
-                )
-                single_decode_btn = gr.Button("🚀 Decode Entry", variant="primary")
-            with gr.Column():
-                single_output = gr.JSON(label="Decoded Result")
-    
-    with gr.Tab("🌐 HTML Parser"):
-        gr.Markdown("Parse HTML and extract all proxy entries from data-ss attribute")
-        with gr.Row():
-            with gr.Column():
-                html_input = gr.Textbox(
-                    label="HTML Script Tag",
-                    value=your_html_data,
-                    lines=15,
-                    max_lines=20
-                )
-                html_parse_btn = gr.Button("🔍 Parse HTML and Decode All Entries", variant="primary")
-            with gr.Column():
-                html_output = gr.JSON(label="Decoded Results")
-    
-    with gr.Tab("🧪 Test Your Data"):
-        gr.Markdown("Test the decoder with the provided sample data")
-        with gr.Row():
-            test_btn = gr.Button("🧪 Test with Provided HTML Data", variant="secondary")
-            clear_btn = gr.Button("🗑️ Clear Results")
-        test_output = gr.JSON(label="Test Results")
-    
-    with gr.Tab("📚 About"):
-        gr.Markdown("""
-        ## About This Tool
+# Create a much simpler interface
+def create_simple_interface():
+    with gr.Blocks(title="Proxy Decoder", css=".gradio-container {max-width: 1200px !important}") as demo:
+        gr.Markdown("# Proxy Server Decoder")
         
-        This decoder processes proxy server information encoded in HTML script tags.
+        with gr.Tab("Single Entry"):
+            with gr.Row():
+                with gr.Column():
+                    single_input = gr.Textbox(
+                        label="Base64 String",
+                        placeholder="Paste base64 string here...",
+                        lines=3
+                    )
+                    single_btn = gr.Button("Decode", variant="primary")
+                with gr.Column():
+                    single_output = gr.JSON(label="Result")
         
-        ### The Decoding Process:
-        1. **Base64 Decode** - Convert the base64 string to bytes
-        2. **Hex to ASCII** - Convert hex-encoded bytes to ASCII text  
-        3. **JSON Parse** - Parse the resulting JSON object
+        with gr.Tab("HTML Parser"):
+            with gr.Row():
+                with gr.Column():
+                    html_input = gr.Textbox(
+                        label="HTML Content",
+                        value=test_html,
+                        lines=10
+                    )
+                    html_btn = gr.Button("Parse HTML", variant="primary")
+                with gr.Column():
+                    html_output = gr.JSON(label="Results")
         
-        ### Input Format:
-        The tool expects HTML like:
-        ```html
-        <script
-            id="serverSelectorScript" 
-            data-ss="[&quot;BASE64_STRING_1&quot;,&quot;BASE64_STRING_2&quot;,...]"
-        ></script>
-        ```
+        # Connect functions
+        single_btn.click(
+            decode_single_entry,
+            inputs=single_input,
+            outputs=single_output
+        )
         
-        ### Features:
-        - Single entry decoding
-        - Bulk HTML parsing
-        - Error handling and statistics
-        - Clean, user-friendly interface
-        """)
-    
-    # Event handlers
-    single_decode_btn.click(
-        fn=decode_proxy_entry,
-        inputs=single_input,
-        outputs=single_output
-    )
-    
-    html_parse_btn.click(
-        fn=process_html_input,
-        inputs=html_input,
-        outputs=html_output
-    )
-    
-    def test_with_provided_data():
-        return process_html_input(your_html_data)
-    
-    test_btn.click(
-        fn=test_with_provided_data,
-        outputs=test_output
-    )
-    
-    def clear_all():
-        return None, None, None
+        html_btn.click(
+            process_html_input,
+            inputs=html_input,
+            outputs=html_output
+        )
     
-    clear_btn.click(
-        fn=clear_all,
-        outputs=[single_output, html_output, test_output]
-    )
+    return demo
 
+# Launch directly without complex setup
 if __name__ == "__main__":
+    demo = create_simple_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
+        share=False,
+        inbrowser=True,
+        show_error=True
     )