Update app2.py

app2.py

@@ -21,8 +21,9 @@ from bs4 import BeautifulSoup
 from fake_useragent import UserAgent
 from ratelimit import limits, sleep_and_retry
 from cleantext import clean
+import qrcode
 
-# Setup logging with detailed configuration
+# Setup logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s',
@@ -33,6 +34,9 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Ensure output directories exist
+Path('output/qr_codes').mkdir(parents=True, exist_ok=True)
+
 class URLProcessor:
     def __init__(self):
         self.session = requests.Session()
@@ -170,7 +174,7 @@ class URLProcessor:
         except Exception as e:
             logger.error(f"HTML processing failed: {e}")
             return None
-            
+
 class FileProcessor:
     """Class to handle file processing"""
     
@@ -234,70 +238,151 @@ class FileProcessor:
                             logger.error(f"Error reading file {filename}: {str(e)}")
         return results
 
-def _process_single_file(self, file) -> List[Dict]:
+    def _process_single_file(self, file) -> List[Dict]:
+        """Process a single file"""
+        try:
+            file_stat = os.stat(file.name)
+            
+            # For very large files, read in chunks and summarize
+            if file_stat.st_size > 100 * 1024 * 1024:  # 100MB
+                logger.info(f"Processing large file: {file.name} ({file_stat.st_size} bytes)")
+                
+                # Read first and last 1MB for extremely large files
+                content = ""
+                with open(file.name, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read(1 * 1024 * 1024)  # First 1MB
+                    content += "\n...[Content truncated due to large file size]...\n"
+                    
+                    # Seek to the last 1MB
+                    f.seek(max(0, file_stat.st_size - 1 * 1024 * 1024))
+                    content += f.read()  # Last 1MB
+            else:
+                # Regular file processing
+                with open(file.name, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+            
+            return [{
+                'source': 'file',
+                'filename': os.path.basename(file.name),
+                'file_size': file_stat.st_size,
+                'mime_type': mimetypes.guess_type(file.name)[0],
+                'created': datetime.fromtimestamp(file_stat.st_ctime).isoformat(),
+                'modified': datetime.fromtimestamp(file_stat.st_mtime).isoformat(),
+                'content': content,
+                'timestamp': datetime.now().isoformat()
+            }]
+        except Exception as e:
+            logger.error(f"File processing error: {e}")
+            return []
+
+def clean_json(data: Union[str, Dict]) -> Optional[Dict]:
+    """Clean and validate JSON data"""
     try:
-        file_stat = os.stat(file.name)
+        # If it's a string, try to parse it
+        if isinstance(data, str):
+            # Remove any existing content and extra whitespace
+            data = data.strip()
+            data = json.loads(data)
         
-        # For very large files, read in chunks and summarize
-        if file_stat.st_size > 100 * 1024 * 1024:  # 100MB
-            logger.info(f"Processing large file: {file.name} ({file_stat.st_size} bytes)")
-            
-            # Read first and last 1MB for extremely large files
-            content = ""
-            with open(file.name, 'r', encoding='utf-8', errors='ignore') as f:
-                content = f.read(1 * 1024 * 1024)  # First 1MB
-                content += "\n...[Content truncated due to large file size]...\n"
+        # Convert to string and back to ensure proper JSON format
+        cleaned = json.loads(json.dumps(data))
+        return cleaned
+    except json.JSONDecodeError as e:
+        logger.error(f"JSON cleaning error: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error while cleaning JSON: {e}")
+        return None
+
+def generate_qr_code(data: Union[str, Dict], combined: bool = True) -> List[str]:
+    """Generate QR code(s) from data"""
+    try:
+        output_dir = Path('output/qr_codes')
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        if combined:
+            # Generate single QR code for all data
+            cleaned_data = clean_json(data)
+            if cleaned_data:
+                qr = qrcode.QRCode(
+                    version=None,
+                    error_correction=qrcode.constants.ERROR_CORRECT_L,
+                    box_size=10,
+                    border=4,
+                )
+                json_str = json.dumps(cleaned_data, ensure_ascii=False)
+                qr.add_data(json_str)
+                qr.make(fit=True)
                 
-                # Seek to the last 1MB
-                f.seek(max(0, file_stat.st_size - 1 * 1024 * 1024))
-                content += f.read()  # Last 1MB
+                img = qr.make_image(fill_color="black", back_color="white")
+                output_path = output_dir / f'combined_qr_{int(time.time())}.png'
+                img.save(str(output_path))
+                return [str(output_path)]
         else:
-            # Regular file processing
-            with open(file.name, 'r', encoding='utf-8', errors='ignore') as f:
-                content = f.read()
+            # Generate separate QR codes for each item
+            if isinstance(data, list):
+                paths = []
+                for idx, item in enumerate(data):
+                    cleaned_item = clean_json(item)
+                    if cleaned_item:
+                        qr = qrcode.QRCode(
+                            version=None,
+                            error_correction=qrcode.constants.ERROR_CORRECT_L,
+                            box_size=10,
+                            border=4,
+                        )
+                        json_str = json.dumps(cleaned_item, ensure_ascii=False)
+                        qr.add_data(json_str)
+                        qr.make(fit=True)
+                        
+                        img = qr.make_image(fill_color="black", back_color="white")
+                        output_path = output_dir / f'item_{idx}_qr_{int(time.time())}.png'
+                        img.save(str(output_path))
+                        paths.append(str(output_path))
+                return paths
+            else:
+                # Single item, not combined
+                cleaned_item = clean_json(data)
+                if cleaned_item:
+                    qr = qrcode.QRCode(
+                        version=None,
+                        error_correction=qrcode.constants.ERROR_CORRECT_L,
+                        box_size=10,
+                        border=4,
+                    )
+                    json_str = json.dumps(cleaned_item, ensure_ascii=False)
+                    qr.add_data(json_str)
+                    qr.make(fit=True)
+                    
+                    img = qr.make_image(fill_color="black", back_color="white")
+                    output_path = output_dir / f'single_qr_{int(time.time())}.png'
+                    img.save(str(output_path))
+                    return [str(output_path)]
         
-        return [{
-            'source': 'file',
-            'filename': os.path.basename(file.name),
-            'file_size': file_stat.st_size,
-            'mime_type': mimetypes.guess_type(file.name)[0],
-            'created': datetime.fromtimestamp(file_stat.st_ctime).isoformat(),
-            'modified': datetime.fromtimestamp(file_stat.st_mtime).isoformat(),
-            'content': content,
-            'timestamp': datetime.now().isoformat()
-        }]
+        return []
     except Exception as e:
-        logger.error(f"File processing error: {e}")
+        logger.error(f"QR generation error: {e}")
         return []
 
-import qrcode  # Import the qrcode library
-
-def generate_qr(json_data):
-    """Generate QR code from JSON data and return the file path."""
-    if json_data:
-        qr = qrcode.make(json_data)
-        qr_path = f"output/qr_code_{int(time.time())}.png"
-        qr.save(qr_path)
-        return qr_path
-    return None
-
 def create_interface():
     """Create a comprehensive Gradio interface with advanced features"""
     
     css = """
     .container { max-width: 1200px; margin: auto; }
-    .warning { background-color: #fff3cd; color: #856404; }
-    .error { background-color: #f8d7da; color: #721c24; }
+    .warning { background-color: #fff3cd; color: #856404; padding: 10px; border-radius: 4px; }
+    .error { background-color: #f8d7da; color: #721c24; padding: 10px; border-radius: 4px; }
+    .success { background-color: #d4edda; color: #155724; padding: 10px; border-radius: 4px; }
     """
     
-    with gr.Blocks(css=css, title="Advanced Text & URL Processor") as interface:
-        gr.Markdown("# 🌐 Advanced URL & Text Processing Toolkit")
+    with gr.Blocks(css=css, title="Advanced Data Processor & QR Generator") as interface:
+        gr.Markdown("# 🌐 Advanced Data Processing & QR Code Generator")
         
         with gr.Tab("URL Processing"):
             url_input = gr.Textbox(
                 label="Enter URLs (comma or newline separated)", 
                 lines=5,
-                placeholder="https://example1.com\nhttps://example2.com"
+                placeholder="https://example1.com\nhttps://example2.com",
+                value=""
             )
         
         with gr.Tab("File Input"):
@@ -306,27 +391,82 @@ def create_interface():
                 file_types=[".txt", ".zip", ".md", ".csv", ".json", ".xml"]
             )
 
-        with gr.Tab("Text Input"):
-            text_input = gr.Textbox(
-                label="Raw Text Input", 
-                lines=5,
-                placeholder="Paste your text here..."
+        with gr.Tab("Notepad"):
+            text_input = gr.TextArea(
+                label="JSON Data Input", 
+                lines=15,
+                placeholder="Paste your JSON data here...",
+                value=""
+            )
+            
+            with gr.Row():
+                example_btn = gr.Button("📝 Load Example JSON", variant="secondary")
+                clear_btn = gr.Button("🗑️ Clear Input", variant="secondary")
+            
+        with gr.Row():
+            combine_data = gr.Checkbox(
+                label="Combine all data into single QR code", 
+                value=True,
+                info="Generate one QR code for all data, or separate QR codes for each item"
             )
+            process_btn = gr.Button("🔄 Process & Generate QR", variant="primary", scale=2)
         
-        process_btn = gr.Button("Process Input", variant="primary")
+        output_json = gr.JSON(label="Processed JSON Data")
+        output_gallery = gr.Gallery(label="Generated QR Codes", columns=2, height=400)
+        output_text = gr.Textbox(label="Processing Status", interactive=False)
         
-        output_text = gr.Textbox(label="Processing Results", interactive=False)
-        output_file = gr.File(label="Processed Output")
+        def load_example():
+            example_json = {
+                "type": "product_catalog",
+                "items": [
+                    {
+                        "id": "123",
+                        "name": "Test Product",
+                        "description": "This is a test product description",
+                        "price": 29.99,
+                        "category": "electronics",
+                        "tags": ["test", "sample", "demo"]
+                    },
+                    {
+                        "id": "456",
+                        "name": "Another Product",
+                        "description": "Another test product description",
+                        "price": 49.99,
+                        "category": "accessories",
+                        "tags": ["sample", "test"]
+                    }
+                ],
+                "metadata": {
+                    "timestamp": datetime.now().isoformat(),
+                    "version": "1.0",
+                    "source": "example"
+                }
+            }
+            return json.dumps(example_json, indent=2)
+        
+        def clear_input():
+            return ""
         
-        def process_all_inputs(urls, file, text):
-            """Process all input types with progress tracking"""
+        def process_all_inputs(urls, file, text, combine):
+            """Process all input types and generate QR codes"""
             try:
-                processor = URLProcessor()
-                file_processor = FileProcessor()
                 results = []
                 
-                # Process URLs
-                if urls:
+                # Process text input first (since it's direct JSON)
+                if text and text.strip():
+                    try:
+                        # Try to parse as JSON
+                        json_data = json.loads(text)
+                        if isinstance(json_data, list):
+                            results.extend(json_data)
+                        else:
+                            results.append(json_data)
+                    except json.JSONDecodeError as e:
+                        return None, [], f"❌ Invalid JSON format: {str(e)}"
+                
+                # Process URLs if provided
+                if urls and urls.strip():
+                    processor = URLProcessor()
                     url_list = re.split(r'[,\n]', urls)
                     url_list = [url.strip() for url in url_list if url.strip()]
                     
@@ -342,82 +482,77 @@ def create_interface():
                                     'timestamp': datetime.now().isoformat()
                                 })
                 
-                # Process files
+                # Process files if provided
                 if file:
-                    results.extend(file_processor.process_file(file))
-        
-                # Process text input
-                if text:
-                    cleaned_text = processor.advanced_text_cleaning(text)
-                    results.append({
-                        'source': 'direct_input',
-                        'content': cleaned_text,
-                        'timestamp': datetime.now().isoformat()
-                    })
+                    file_processor = FileProcessor()
+                    file_results = file_processor.process_file(file)
+                    if file_results:
+                        results.extend(file_results)
                 
-                # Generate output
+                # Generate QR codes
                 if results:
-                    output_dir = Path('output') / datetime.now().strftime('%Y-%m-%d')
-                    output_dir.mkdir(parents=True, exist_ok=True)
-                    output_path = output_dir / f'processed_{int(time.time())}.json'
-                    
-                    with open(output_path, 'w', encoding='utf-8') as f:
-                        json.dump(results, f, ensure_ascii=False, indent=2)
-                    
-                    summary = f"Processed {len(results)} items successfully!"
-                    # Convert Path object to string here
-                    return str(output_path), summary
+                    qr_paths = generate_qr_code(results, combined=combine)
+                    if qr_paths:
+                        return (
+                            results,
+                            [str(path) for path in qr_paths],
+                            f"✅ Successfully processed {len(results)} items and generated {len(qr_paths)} QR code(s)!"
+                        )
+                    else:
+                        return None, [], "❌ Failed to generate QR codes. Please check the input data."
                 else:
-                    return None, "No valid content to process."
+                    return None, [], "⚠️ No valid content to process. Please provide some input data."
             
             except Exception as e:
                 logger.error(f"Processing error: {e}")
-                return None, f"Error: {str(e)}"
+                return None, [], f"❌ Error: {str(e)}"
         
+        # Set up event handlers
+        example_btn.click(load_example, outputs=[text_input])
+        clear_btn.click(clear_input, outputs=[text_input])
         process_btn.click(
             process_all_inputs, 
-            inputs=[url_input, file_input, text_input], 
-            outputs=[output_file, output_text]
+            inputs=[url_input, file_input, text_input, combine_data], 
+            outputs=[output_json, output_gallery, output_text]
         )
         
         gr.Markdown("""
-        ### Usage Guidelines
-        - **URL Processing**: Enter valid HTTP/HTTPS URLs
-        - **File Input**: Upload text files or ZIP archives
-        - **Text Input**: Direct text processing
-        - Advanced cleaning and validation included
+        ### Features
+        - **URL Processing**: Extract content from websites
+        - **File Processing**: Handle text files and archives
+        - **Notepad**: Direct JSON data input/manipulation
+        - **JSON Cleaning**: Automatic JSON validation and formatting
+        - **QR Generation**: Generate QR codes with embedded JSON data
+        - **Flexible Output**: Choose between combined or separate QR codes
+        
+        ### Usage Tips
+        1. Use the **Notepad** tab for direct JSON input
+        2. Click "Load Example JSON" to see a sample format
+        3. Choose whether to combine all data into a single QR code
+        4. The generated QR codes will contain the complete JSON data
         """)
     
     return interface
 
-import qrcode  # Import the qrcode library
-
-def generate_qr(json_data):
-    """Generate QR code from JSON data and return the file path."""
-    if json_data:
-        qr = qrcode.make(json_data)
-        qr_path = f"output/qr_code_{int(time.time())}.png"
-        qr.save(qr_path)
-        return qr_path
-    return None
-
 def main():
     # Configure system settings
     mimetypes.init()
+    
+    # Create output directories
+    Path('output/qr_codes').mkdir(parents=True, exist_ok=True)
+    
     # Create and launch interface
     interface = create_interface()
-
+    
     # Launch with proper configuration
     interface.launch(
         server_name="0.0.0.0",
-        server_port=7860,
+        server_port=8000,
         show_error=True,
         share=False,
         inbrowser=True,
         debug=True
     )
 
-
 if __name__ == "__main__":
-    main()
-                
+    main()