Update app2.py

app2.py

@@ -18,7 +18,6 @@ import gradio as gr
 from bs4 import BeautifulSoup
 from fake_useragent import UserAgent
 from cleantext import clean
-import qrcode  # Added missing import
 
 # Setup logging
 logging.basicConfig(
@@ -34,10 +33,22 @@ logger = logging.getLogger(__name__)
 # Ensure output directories exist
 Path('output/qr_codes').mkdir(parents=True, exist_ok=True)
 
+# At the top of the file, remove these imports:
+# from config import Config
+# from proxy_handler import ProxyHandler
+# from robots_handler import RobotsHandler
+
 class URLProcessor:
     def __init__(self):
         self.session = requests.Session()
-        self.timeout = 10  # seconds
+        self.timeout = 10
+        self.max_retries = 3
+        self.request_delay = 1.0
+        self.respect_robots = True
+        self.use_proxy = False
+        self.proxy_url = None
+        
+        # Update session headers
         self.session.headers.update({
             'User-Agent': UserAgent().random,
             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
@@ -46,6 +57,55 @@ class URLProcessor:
             'Connection': 'keep-alive',
             'Upgrade-Insecure-Requests': '1'
         })
+        
+        if self.use_proxy and self.proxy_url:
+            self.session.proxies = {
+                'http': self.proxy_url,
+                'https': self.proxy_url
+            }
+
+    def check_robots_txt(self, url: str) -> bool:
+        """Check if URL is allowed by robots.txt"""
+        if not self.respect_robots:
+            return True
+            
+        try:
+            from urllib.parse import urlparse
+            from urllib.robotparser import RobotFileParser
+            
+            parsed_url = urlparse(url)
+            robots_url = f"{parsed_url.scheme}://{parsed_url.netloc}/robots.txt"
+            
+            rp = RobotFileParser()
+            rp.set_url(robots_url)
+            rp.read()
+            
+            return rp.can_fetch(self.session.headers['User-Agent'], url)
+        except Exception as e:
+            logger.warning(f"Error checking robots.txt: {e}")
+            return True
+
+    def fetch_content(self, url: str) -> Optional[Dict]:
+        """Fetch content with built-in rate limiting and robots.txt checking"""
+        if not self.check_robots_txt(url):
+            logger.warning(f"URL {url} is disallowed by robots.txt")
+            return None
+            
+        time.sleep(self.request_delay)  # Basic rate limiting
+        
+        for attempt in range(self.max_retries):
+            try:
+                if 'drive.google.com' in url:
+                    return self._handle_google_drive(url)
+                if 'calendar.google.com' in url:
+                    return self._handle_google_calendar(url)
+                return self._fetch_html_content(url)
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1} failed: {e}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.request_delay * (attempt + 1))
+                    
+        return None
 
     def advanced_text_cleaning(self, text: str) -> str:
         """Robust text cleaning with version compatibility"""
@@ -67,7 +127,7 @@ class URLProcessor:
             return cleaned_text
         except Exception as e:
             logger.warning(f"Text cleaning error: {e}. Using fallback method.")
-            text = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', text)  # Fixed regex
+            text = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', text)
             text = text.encode('ascii', 'ignore').decode('ascii')
             text = re.sub(r'\s+', ' ', text)
             return text.strip()
@@ -166,7 +226,7 @@ class URLProcessor:
 class FileProcessor:
     """Class to handle file processing"""
     
-    def __init__(self, max_file_size: int = 2 * 1024 * 1024 * 1024):
+    def __init__(self, max_file_size: int = 2 * 1024 * 1024 * 1024):  # 2GB default
         self.max_file_size = max_file_size
         self.supported_text_extensions = {'.txt', '.md', '.csv', '.json', '.xml'}
         
@@ -175,7 +235,7 @@ class FileProcessor:
         try:
             mime_type, _ = mimetypes.guess_type(filepath)
             return (mime_type and mime_type.startswith('text/')) or \
-                   (Path(filepath).suffix.lower() in self.supported_text_extensions)
+                   (os.path.splitext(filepath)[1].lower() in self.supported_text_extensions)
         except Exception:
             return False
 
@@ -220,7 +280,7 @@ class FileProcessor:
                                     "source": "file",
                                     "filename": filename,
                                     "content": content,
-                                    "timestamp": datetime.now().isoformat()
+                                    "timestamp": datetime.now ().isoformat()
                                 })
                         except Exception as e:
                             logger.error(f"Error reading file {filename}: {str(e)}")
@@ -259,7 +319,6 @@ class FileProcessor:
             logger.error(f"File processing error: {e}")
             return []
 
-    @staticmethod
     def clean_json(data: Union[str, Dict]) -> Optional[Dict]:
         """Clean and validate JSON data"""
         try:
@@ -276,7 +335,6 @@ class FileProcessor:
             logger.error(f"Unexpected error while cleaning JSON: {e}")
             return None
     
-    @staticmethod
     def generate_qr_code(data: Union[str, Dict], combined: bool = True) -> List[str]:
         """Generate QR code(s) from data"""
         try:
@@ -284,7 +342,7 @@ class FileProcessor:
             output_dir.mkdir(parents=True, exist_ok=True)
             
             if combined:
-                cleaned_data = FileProcessor.clean_json(data)
+                cleaned_data = clean_json(data)
                 if cleaned_data:
                     qr = qrcode.QRCode(
                         version=None,
@@ -301,10 +359,10 @@ class FileProcessor:
                     img.save(str(output_path))
                     return [str(output_path)]
             else:
-                paths = []
                 if isinstance(data, list):
+                    paths = []
                     for idx, item in enumerate(data):
-                        cleaned_item = FileProcessor.clean_json(item)
+                        cleaned_item = clean_json(item)
                         if cleaned_item:
                             qr = qrcode.QRCode(
                                 version=None,
@@ -320,8 +378,9 @@ class FileProcessor:
                             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:
-                    cleaned_item = FileProcessor.clean_json(data)
+                    cleaned_item = clean_json(data)
                     if cleaned_item:
                         qr = qrcode.QRCode(
                             version=None,
@@ -333,35 +392,66 @@ class FileProcessor:
                         qr.add_data(json_str)
                         qr.make(fit=True)
                         
-                        img = qr.make_image(fill_color="black", back_color="white")
+                        img = qrcode.make_image(fill_color="black", back_color="white")
                         output_path = output_dir / f'single_qr_{int(time.time())}.png'
                         img.save(str(output_path))
-                        paths.append(str(output_path))
-                return paths
+                        return [str(output_path)]
+            
+                return []
         except Exception as e:
             logger.error(f"QR generation error: {e}")
             return []
 
-def decode_qr(image_path: str) -> List[str]:
-    """Decode QR code from image file"""
-    try:
-        image = Image.open(image_path)
-        decoded_objects = decode(image)
-        return [obj.data.decode('utf-8') for obj in decoded_objects]
-    except Exception as e:
-        logger.error(f"QR decoding error: {e}")
-        return []
+    def decode_qr_code(image_path: str) -> Optional[str]:
+        """Decode QR code from an image file using ZXing"""
+        try:
+            reader = zxing.BarCodeReader()
+            result = reader.decode(image_path)
+            
+            if result and result.parsed:
+                return result.parsed
+            logger.warning("No QR code found in image")
+            return None
+        except Exception as e:
+            logger.error(f"QR decoding error: {e}")
+            return None
+
+    def decode_qr(image) -> List[str]:
+        """Decode all QR codes found in an image using ZXing"""
+        try:
+            if isinstance(image, str):
+                image_path = image
+            else:
+                # Save temporary image if input is not a path
+                with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                    Image.fromarray(image).save(tmp.name)
+                    image_path = tmp.name
+
+            reader = zxing.BarCodeReader()
+            result = reader.decode(image_path)
+            
+            if result and result.parsed:
+                return [result.parsed]
+            return []
+        except Exception as e:
+            logger.error(f"QR decoding error: {e}")
+            return []
+            
+            raise ValueError("Unable to decode QR code")
+        except Exception as e:
+            logger.error(f"QR decoding error: {e}")
+            return None, None  # Return None for both data and resolution in case of error
 
 def datachat_trained(data_input: str, query: str) -> str:
     """Handle trained data interaction logic"""
-    data = FileProcessor.clean_json(data_input)
+    data = clean_json(data_input)
     if not data:
         return "Invalid JSON data provided."
     return f"[Trained Mode]\nData: {json.dumps(data, indent=2)}\nQuery: {query}"
 
 def datachat_simple(data_input: str, query: str) -> str:
     """Handle simple chat interaction logic"""
-    data = FileProcessor.clean_json(data_input)
+    data = clean_json(data_input)
     if not data:
         return "Invalid JSON data provided."
     return f"[Chat Mode]\nData: {json.dumps(data, indent=2)}\nQuestion: {query}"
@@ -369,14 +459,15 @@ def datachat_simple(data_input: str, query: str) -> str:
 def datachat_interface(mode: str, data_source: str, json_input: str, qr_image: str, query: str) -> str:
     """Interface for DataChat functionality"""
     data = None
+    resolution = None  # Initialize resolution variable
     if data_source == "JSON Input":
         data = json_input
     elif data_source == "QR Code":
-        decoded_data = decode_qr(qr_image)
-        if decoded_data:
-            data = decoded_data[0]
-        else:
-            return "Invalid QR code data provided"
+        try:
+            decoded_data, resolution = decode_qr_code(qr_image)  # Get both data and resolution
+            data = decoded_data
+        except Exception as e:
+            return f"Invalid QR code data provided: {e}"
     else:
         return "No valid data source selected."
 
@@ -405,29 +496,24 @@ def create_interface():
             json_input = gr.Textbox(lines=8, label="JSON Data")
             qr_image = gr.Image(label="QR Code Image", type="filepath")
             query = gr.Textbox(label="Query")
+
             submit_btn = gr.Button("Submit")
             output = gr.Textbox(label="Response")
+
             submit_btn.click(datachat_interface, [mode, data_source, json_input, qr_image, query], output)
 
         with gr.Tab("QR Generator"):
             qr_input = gr.Textbox(lines=8, label="Input JSON for QR")
             generate_btn = gr.Button("Generate QR")
             qr_output = gr.Image(label="Generated QR Code")
-            generate_btn.click(
-                lambda x: FileProcessor.generate_qr_code(x)[0] if x else None,
-                inputs=qr_input,
-                outputs=qr_output
-            )
-
-        with gr.Tab("QR Decoder"):
-            qr_upload = gr.Image(label="Upload QR Code", type="filepath")
-            decode_btn = gr.Button("Decode QR")
-            decoded_output = gr.Textbox(label="Decoded Data")
-            decode_btn.click(
-                lambda x: "\n".join(decode_qr(x)),
-                inputs=qr_upload,
-                outputs=decoded_output
-            )
+
+            def generate_qr(json_data):
+                data = clean_json(json_data)
+                if data:
+                    return generate_qr_code(data)
+                return None
+
+            generate_btn.click(generate_qr, qr_input, qr_output)
 
     return interface
 
@@ -435,7 +521,11 @@ def main():
     mimetypes.init()
     Path('output/qr_codes').mkdir(parents=True, exist_ok=True)
     interface = create_interface()
-    interface.launch()
-
-if __name__ == "__main__":
-    main()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False,
+        inbrowser=True,
+        debug=True
+    )