Update app2.py

app2.py

@@ -18,6 +18,7 @@ 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(
@@ -33,22 +34,10 @@ 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
-        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.timeout = 10  # seconds
         self.session.headers.update({
             'User-Agent': UserAgent().random,
             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
@@ -57,55 +46,6 @@ 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"""
@@ -127,9 +67,9 @@ 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)  # Remove control characters
-            text = text.encode('ascii', 'ignore').decode('ascii')  # Remove non-ASCII characters
-            text = re.sub(r'\s+', ' ', text)  # Normalize whitespace
+            text = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', text)  # Fixed regex
+            text = text.encode('ascii', 'ignore').decode('ascii')
+            text = re.sub(r'\s+', ' ', text)
             return text.strip()
 
     def validate_url(self, url: str) -> Dict:
@@ -226,7 +166,7 @@ class URLProcessor:
 class FileProcessor:
     """Class to handle file processing"""
     
-    def __init__(self, max_file_size: int = 2 * 1024 * 1024 * 1024):  # 2GB default
+    def __init__(self, max_file_size: int = 2 * 1024 * 1024 * 1024):
         self.max_file_size = max_file_size
         self.supported_text_extensions = {'.txt', '.md', '.csv', '.json', '.xml'}
         
@@ -235,7 +175,7 @@ class FileProcessor:
         try:
             mime_type, _ = mimetypes.guess_type(filepath)
             return (mime_type and mime_type.startswith('text/')) or \
-                   (os.path.splitext(filepath)[1].lower() in self.supported_text_extensions)
+                   (Path(filepath).suffix.lower() in self.supported_text_extensions)
         except Exception:
             return False
 
@@ -280,7 +220,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)}")
@@ -319,6 +259,7 @@ 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:
@@ -335,6 +276,7 @@ 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:
@@ -342,7 +284,7 @@ class FileProcessor:
             output_dir.mkdir(parents=True, exist_ok=True)
             
             if combined:
-                cleaned_data = clean_json(data)
+                cleaned_data = FileProcessor.clean_json(data)
                 if cleaned_data:
                     qr = qrcode.QRCode(
                         version=None,
@@ -359,10 +301,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 = clean_json(item)
+                        cleaned_item = FileProcessor.clean_json(item)
                         if cleaned_item:
                             qr = qrcode.QRCode(
                                 version=None,
@@ -378,9 +320,8 @@ 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 = clean_json(data)
+                    cleaned_item = FileProcessor.clean_json(data)
                     if cleaned_item:
                         qr = qrcode.QRCode(
                             version=None,
@@ -395,71 +336,32 @@ class FileProcessor:
                         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 []
+                        paths.append(str(output_path))
+                return paths
         except Exception as e:
             logger.error(f"QR generation error: {e}")
             return []
 
-    def decode_qr_code(image_path: str) -> Optional[str]:
-        """Decode QR code from an image file"""
-        try:
-            # Open and convert image to grayscale for better QR detection
-            img = Image.open(image_path).convert('L')
-            decoded_objects = decode(img)
-            
-            if decoded_objects:
-                return decoded_objects[0].data.decode('utf-8')
-            logger.warning("No QR code found in image")
-            return None
-        except Exception as e:
-            logger.error(f"QR decoding error: {e}")
-            return None
-
-    # Replace the existing decode_qr function with this one
-    def decode_qr(image) -> List[str]:
-        """Decode all QR codes found in an image"""
-        try:
-            # Convert to PIL Image if needed
-            if not isinstance(image, Image.Image):
-                image = Image.fromarray(image)
-            
-            # Convert to grayscale for better detection
-            image = image.convert('L')
-            
-            # Decode QR codes
-            decoded_objects = decode(image)
-            results = []
-            
-            for obj in decoded_objects:
-                try:
-                    decoded_text = obj.data.decode('utf-8')
-                    results.append(decoded_text)
-                except UnicodeDecodeError:
-                    logger.warning("Failed to decode QR code data as UTF-8")
-                    continue
-                    
-            return results
-        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 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 datachat_trained(data_input: str, query: str) -> str:
     """Handle trained data interaction logic"""
-    data = clean_json(data_input)
+    data = FileProcessor.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 = clean_json(data_input)
+    data = FileProcessor.clean_json(data_input)
     if not data:
         return "Invalid JSON data provided."
     return f"[Chat Mode]\nData: {json.dumps(data, indent=2)}\nQuestion: {query}"
@@ -467,15 +369,14 @@ 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":
-        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}"
+        decoded_data = decode_qr(qr_image)
+        if decoded_data:
+            data = decoded_data[0]
+        else:
+            return "Invalid QR code data provided"
     else:
         return "No valid data source selected."
 
@@ -504,34 +405,37 @@ 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")
-
-            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)
+            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
+            )
 
     return interface
 
 def main():
     mimetypes.init()
     Path('output/qr_codes').mkdir(parents=True, exist_ok=True)
-    
-iface = gr.Interface(fn=decode_qr, inputs="image", outputs="text")
-    iface.launch()
-
+    interface = create_interface()
+    interface.launch()
 
 if __name__ == "__main__":
-    main()
+    main()