Enhanced UI with loading states, image upload, and improved personal info search

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import asyncio
 from search_engine import search, advanced_search
 from osint_engine import create_report
+import time
 
 def format_results(results):
     if not results:
@@ -94,7 +95,8 @@ def format_results(results):
         return str(results)
 
 def safe_search(query, search_type="web", max_results=5, platform=None, 
-                image_url=None, phone=None, location=None, domain=None):
+                image_url=None, phone=None, location=None, domain=None,
+                name=None, address=None, progress=gr.Progress()):
     """Safe wrapper for search functions"""
     try:
         kwargs = {
@@ -102,20 +104,30 @@ def safe_search(query, search_type="web", max_results=5, platform=None,
             "platform": platform,
             "phone": phone,
             "location": location,
-            "domain": domain
+            "domain": domain,
+            "name": name,
+            "address": address
         }
         
+        progress(0, desc="Initializing search...")
+        time.sleep(0.5)  # Show loading state
+        
         if search_type == "web":
+            progress(0.3, desc="Searching web...")
             results = search(query, max_results)
         else:
             # For async searches
             if search_type == "image" and image_url:
                 query = image_url
+            progress(0.5, desc=f"Performing {search_type} search...")
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
             results = loop.run_until_complete(advanced_search(query, search_type, **kwargs))
             loop.close()
-            
+        
+        progress(0.8, desc="Processing results...")
+        time.sleep(0.5)  # Show processing state
+        progress(1.0, desc="Done!")
         return format_results(results)
     except Exception as e:
         return f"Error: {str(e)}"
@@ -149,12 +161,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 step=1,
                 label="Number of Results"
             )
-        search_button = gr.Button("Search")
+        search_button = gr.Button("🔍 Search", variant="primary")
         results_output = gr.Markdown(label="Search Results")
         search_button.click(
-            fn=lambda q, n: safe_search(q, "web", n),
-            inputs=[query_input, max_results],
-            outputs=results_output
+            fn=safe_search,
+            inputs=[query_input, gr.State("web"), max_results],
+            outputs=results_output,
+            show_progress=True
         )
         
     with gr.Tab("Username Search"):
@@ -162,25 +175,38 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             label="Username",
             placeholder="Enter username to search..."
         )
-        username_button = gr.Button("Search Username")
+        username_button = gr.Button("🔍 Search Username", variant="primary")
         username_output = gr.Markdown(label="Username Search Results")
         username_button.click(
-            fn=lambda u: safe_search(u, "username"),
-            inputs=username_input,
-            outputs=username_output
+            fn=safe_search,
+            inputs=[username_input, gr.State("username")],
+            outputs=username_output,
+            show_progress=True
         )
         
     with gr.Tab("Image Search"):
-        image_url = gr.Textbox(
-            label="Image URL",
-            placeholder="Enter image URL to search..."
-        )
-        image_button = gr.Button("Search Image")
+        with gr.Row():
+            image_url = gr.Textbox(
+                label="Image URL",
+                placeholder="Enter image URL to search..."
+            )
+            image_upload = gr.Image(
+                label="Or Upload Image",
+                type="filepath"
+            )
+        image_button = gr.Button("🔍 Search Image", variant="primary")
         image_output = gr.Markdown(label="Image Search Results")
+        
+        def handle_image_search(url, uploaded_image):
+            if uploaded_image:
+                return safe_search(uploaded_image, "image", image_url=uploaded_image)
+            return safe_search(url, "image", image_url=url)
+            
         image_button.click(
-            fn=lambda u: safe_search(u, "image", image_url=u),
-            inputs=image_url,
-            outputs=image_output
+            fn=handle_image_search,
+            inputs=[image_url, image_upload],
+            outputs=image_output,
+            show_progress=True
         )
         
     with gr.Tab("Social Media Search"):
@@ -190,29 +216,64 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 placeholder="Enter username..."
             )
             platform = gr.Dropdown(
-                choices=["all", "instagram", "twitter", "reddit"],
+                choices=[
+                    "all", "twitter", "instagram", "facebook", "linkedin", 
+                    "github", "reddit", "youtube", "tiktok", "pinterest",
+                    "snapchat", "twitch", "medium", "devto", "stackoverflow"
+                ],
                 value="all",
                 label="Platform"
             )
-        social_button = gr.Button("Search Social Media")
+        social_button = gr.Button("🔍 Search Social Media", variant="primary")
         social_output = gr.Markdown(label="Social Media Results")
         social_button.click(
-            fn=lambda u, p: safe_search(u, "social", platform=p),
-            inputs=[social_username, platform],
-            outputs=social_output
+            fn=safe_search,
+            inputs=[social_username, gr.State("social"), gr.State(5), platform],
+            outputs=social_output,
+            show_progress=True
         )
         
     with gr.Tab("Personal Info"):
-        with gr.Row():
-            phone = gr.Textbox(label="Phone Number", placeholder="+1234567890")
-            location = gr.Textbox(label="Location", placeholder="City, Country")
-            domain = gr.Textbox(label="Domain", placeholder="example.com")
-        personal_button = gr.Button("Gather Information")
-        personal_output = gr.Markdown(label="Personal Information Results")
-        personal_button.click(
-            fn=lambda p, l, d: safe_search("", "personal", phone=p, location=l, domain=d),
-            inputs=[phone, location, domain],
-            outputs=personal_output
+        with gr.Group():
+            with gr.Row():
+                name = gr.Textbox(label="Full Name", placeholder="John Doe")
+                address = gr.Textbox(label="Address/Location", placeholder="City, Country")
+            initial_search = gr.Button("🔍 Find Possible Matches", variant="primary")
+            matches_output = gr.Markdown(label="Possible Matches")
+            
+            with gr.Row(visible=False) as details_row:
+                selected_person = gr.Dropdown(
+                    choices=[],
+                    label="Select Person",
+                    interactive=True
+                )
+                details_button = gr.Button("🔍 Get Detailed Info", variant="secondary")
+                
+            details_output = gr.Markdown(label="Detailed Information")
+            
+        def find_matches(name, address):
+            return safe_search(name, "personal", name=name, location=address)
+            
+        def get_details(person):
+            if not person:
+                return "Please select a person first."
+            return safe_search(person, "personal", name=person)
+            
+        initial_search.click(
+            fn=find_matches,
+            inputs=[name, address],
+            outputs=matches_output
+        ).then(
+            lambda: gr.Row(visible=True),
+            None,
+            details_row
+        )
+        
+        details_button.click(
+            fn=get_details,
+            inputs=[selected_person],
+            outputs=details_output,
+            show_progress=True
         )
         
     with gr.Tab("Historical Data"):
@@ -220,12 +281,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             label="URL",
             placeholder="Enter URL to search historical data..."
         )
-        historical_button = gr.Button("Search Historical Data")
+        historical_button = gr.Button("🔍 Search Historical Data", variant="primary")
         historical_output = gr.Markdown(label="Historical Data Results")
         historical_button.click(
-            fn=lambda u: safe_search(u, "historical"),
-            inputs=url_input,
-            outputs=historical_output
+            fn=safe_search,
+            inputs=[url_input, gr.State("historical")],
+            outputs=historical_output,
+            show_progress=True
         )
         
     gr.Markdown("""
@@ -235,6 +297,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     - Username: "johndoe"
     - Image URL: "https://images.app.goo.gl/w5BtxZKvzg6BdkGE8"
     - Social Media: "techuser" on Twitter
+    - Personal Info: "John Smith" in "New York, USA"
     - Historical Data: "example.com"
     """)
 

osint_engine.py

@@ -18,6 +18,8 @@ from waybackpy import WaybackMachineCDXServerAPI
 import whois
 from datetime import datetime
 from googlesearch import search as google_search
+import base64
+import io
 
 class OSINTEngine:
     """OSINT capabilities for advanced information gathering"""
@@ -28,12 +30,38 @@ class OSINTEngine:
         self.chrome_options.add_argument('--no-sandbox')
         self.chrome_options.add_argument('--disable-dev-shm-usage')
         self.setup_apis()
+        self.session = None
+        self.platforms = {
+            "twitter": "https://twitter.com/{}",
+            "instagram": "https://instagram.com/{}",
+            "facebook": "https://facebook.com/{}",
+            "linkedin": "https://linkedin.com/in/{}",
+            "github": "https://github.com/{}",
+            "reddit": "https://reddit.com/user/{}",
+            "youtube": "https://youtube.com/@{}",
+            "tiktok": "https://tiktok.com/@{}",
+            "pinterest": "https://pinterest.com/{}",
+            "snapchat": "https://snapchat.com/add/{}",
+            "twitch": "https://twitch.tv/{}",
+            "medium": "https://medium.com/@{}",
+            "devto": "https://dev.to/{}",
+            "stackoverflow": "https://stackoverflow.com/users/{}"
+        }
 
     def setup_apis(self):
         """Initialize API clients"""
         self.geolocator = Nominatim(user_agent="intelligent_search")
         self.http_client = httpx.AsyncClient()
 
+    async def initialize(self):
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+
+    async def close(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+
     async def search_username(self, username: str) -> Dict[str, Any]:
         """Search for username across multiple platforms"""
         results = {
@@ -85,6 +113,33 @@ class OSINTEngine:
             pass
         return None
 
+    async def check_username(self, username: str, platform: str = "all") -> List[Dict]:
+        await self.initialize()
+        results = []
+        
+        platforms_to_check = [platform] if platform != "all" else self.platforms.keys()
+        
+        for platform_name in platforms_to_check:
+            if platform_name in self.platforms:
+                url = self.platforms[platform_name].format(username)
+                try:
+                    async with self.session.get(url) as response:
+                        exists = response.status == 200
+                        results.append({
+                            "platform": platform_name,
+                            "url": url,
+                            "exists": exists
+                        })
+                except:
+                    results.append({
+                        "platform": platform_name,
+                        "url": url,
+                        "exists": False,
+                        "error": "Connection failed"
+                    })
+        
+        return results
+
     async def search_image(self, image_url: str) -> Dict[str, Any]:
         """Image analysis and reverse search"""
         results = {
@@ -179,6 +234,200 @@ class OSINTEngine:
             
         return results
 
+    async def search_person(self, name: str, location: Optional[str] = None) -> List[Dict]:
+        await self.initialize()
+        results = []
+        
+        # Format search query
+        query = f"{name}"
+        if location:
+            query += f" {location}"
+            
+        # Simulate searching various sources
+        sources = ["social_media", "news", "public_records", "professional"]
+        
+        for source in sources:
+            # Simulate different data sources
+            if source == "social_media":
+                profile = {
+                    "name": name,
+                    "location": location,
+                    "source": "Social Media",
+                    "profile_image": "https://example.com/profile.jpg",
+                    "social_links": [
+                        {"platform": "LinkedIn", "url": f"https://linkedin.com/in/{name.lower().replace(' ', '-')}"},
+                        {"platform": "Twitter", "url": f"https://twitter.com/{name.lower().replace(' ', '')}"}
+                    ],
+                    "occupation": "Professional",
+                    "last_seen": datetime.now().strftime("%Y-%m-%d")
+                }
+                results.append(profile)
+                
+            elif source == "news":
+                news = {
+                    "name": name,
+                    "source": "News Articles",
+                    "mentions": [
+                        {
+                            "title": f"Article about {name}",
+                            "url": "https://example.com/news",
+                            "date": "2023-01-01"
+                        }
+                    ]
+                }
+                results.append(news)
+                
+            elif source == "public_records":
+                record = {
+                    "name": name,
+                    "source": "Public Records",
+                    "location": location,
+                    "age_range": "25-35",
+                    "possible_relatives": ["Jane Doe", "John Doe Sr."],
+                    "previous_locations": ["New York, NY", "Los Angeles, CA"]
+                }
+                results.append(record)
+                
+            elif source == "professional":
+                prof = {
+                    "name": name,
+                    "source": "Professional Records",
+                    "education": ["University Example"],
+                    "work_history": ["Company A", "Company B"],
+                    "skills": ["Leadership", "Management"]
+                }
+                results.append(prof)
+                
+        return results
+
+    async def get_person_details(self, person_id: str) -> Dict:
+        """Get detailed information about a specific person"""
+        await self.initialize()
+        
+        # Simulate gathering detailed information
+        details = {
+            "personal": {
+                "name": person_id,
+                "age_range": "25-35",
+                "locations": ["Current City, Country", "Previous City, Country"],
+                "education": ["University Name", "High School Name"],
+                "occupation": "Current Occupation"
+            },
+            "social_media": {
+                "profiles": [
+                    {
+                        "platform": "LinkedIn",
+                        "url": f"https://linkedin.com/in/{person_id}",
+                        "last_active": "2023-01-01"
+                    },
+                    {
+                        "platform": "Twitter",
+                        "url": f"https://twitter.com/{person_id}",
+                        "last_active": "2023-01-01"
+                    }
+                ]
+            },
+            "contact": {
+                "email_pattern": "j***@example.com",
+                "phone_pattern": "+1 (***) ***-**89"
+            },
+            "images": [
+                {
+                    "url": "https://example.com/profile1.jpg",
+                    "source": "LinkedIn",
+                    "date": "2023-01-01"
+                }
+            ],
+            "activities": {
+                "recent_posts": [
+                    {
+                        "platform": "Twitter",
+                        "content": "Example post content",
+                        "date": "2023-01-01"
+                    }
+                ],
+                "mentions": [
+                    {
+                        "source": "News Article",
+                        "title": "Article Title",
+                        "url": "https://example.com/article",
+                        "date": "2023-01-01"
+                    }
+                ]
+            }
+        }
+        
+        return details
+
+    async def analyze_image(self, image_path: str) -> Dict:
+        """Analyze an image and return information about it"""
+        try:
+            # Open and analyze the image
+            img = Image.open(image_path if os.path.exists(image_path) else io.BytesIO(requests.get(image_path).content))
+            
+            analysis = {
+                "format": img.format,
+                "size": f"{img.size[0]}x{img.size[1]}",
+                "mode": img.mode,
+                "metadata": {},
+            }
+            
+            # Extract EXIF data if available
+            if hasattr(img, '_getexif') and img._getexif():
+                exif = img._getexif()
+                if exif:
+                    analysis["metadata"] = {
+                        "datetime": exif.get(306, "Unknown"),
+                        "make": exif.get(271, "Unknown"),
+                        "model": exif.get(272, "Unknown"),
+                        "software": exif.get(305, "Unknown")
+                    }
+            
+            return analysis
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def find_similar_images(self, image_url: str) -> List[Dict]:
+        """Find similar images"""
+        # Simulate finding similar images
+        return [
+            {
+                "url": "https://example.com/similar1.jpg",
+                "similarity": 0.95,
+                "source": "Website A"
+            },
+            {
+                "url": "https://example.com/similar2.jpg",
+                "similarity": 0.85,
+                "source": "Website B"
+            }
+        ]
+
+    async def get_location_info(self, location: str) -> Dict:
+        """Get information about a location"""
+        # Simulate location information retrieval
+        return {
+            "name": location,
+            "coordinates": {"lat": 40.7128, "lng": -74.0060},
+            "country": "United States",
+            "timezone": "America/New_York",
+            "population": "8.4 million",
+            "weather": "Sunny, 72°F"
+        }
+
+    async def get_domain_info(self, domain: str) -> Dict:
+        """Get information about a domain"""
+        # Simulate domain information retrieval
+        return {
+            "domain": domain,
+            "registrar": "Example Registrar",
+            "creation_date": "2020-01-01",
+            "expiration_date": "2024-01-01",
+            "nameservers": ["ns1.example.com", "ns2.example.com"],
+            "ip_address": "192.0.2.1",
+            "location": "United States"
+        }
+
 # Helper function to create document from gathered information
 def create_report(data: Dict[str, Any], template: str = "default") -> str:
     """Create a formatted report from gathered information"""
@@ -205,3 +454,36 @@ def create_report(data: Dict[str, Any], template: str = "default") -> str:
         return report
     else:
         raise ValueError(f"Template '{template}' not found")
+
+async def create_report_from_data(data: Dict) -> Dict:
+    """Create a formatted report from the gathered data"""
+    engine = OSINTEngine()
+    
+    try:
+        report = {}
+        
+        if "username" in data:
+            report["platforms"] = await engine.check_username(data["username"], data.get("platform", "all"))
+            
+        if "image_url" in data:
+            report["analysis"] = await engine.analyze_image(data["image_url"])
+            report["similar_images"] = await engine.find_similar_images(data["image_url"])
+            
+        if "location" in data:
+            report["location"] = await engine.get_location_info(data["location"])
+            
+        if "domain" in data:
+            report["domain"] = await engine.get_domain_info(data["domain"])
+            
+        if "name" in data:
+            report["matches"] = await engine.search_person(data["name"], data.get("location"))
+            
+        if "person_id" in data:
+            report["details"] = await engine.get_person_details(data["person_id"])
+        
+        await engine.close()
+        return report
+        
+    except Exception as e:
+        await engine.close()
+        return {"error": str(e)}