Create app.py

app.py

@@ -0,0 +1,287 @@
+# app.py
+import gradio as gr
+from bs4 import BeautifulSoup
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from geopy.geocoders import Nominatim, ArcGIS
+from geopy.exc import GeocoderTimedOut, GeocoderUnavailable, GeocoderServiceError
+import time
+import pandas as pd
+import re
+import os
+import shutil # For finding chromedriver
+
+def driversetup_huggingface():
+    """Custom driver setup for Hugging Face Spaces (headless)."""
+    options = ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--window-size=1920,1080")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("lang=en")
+    options.add_argument("start-maximized")
+    options.add_argument("disable-infobars")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("user-agent=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36")
+
+    # Attempt to find chromedriver - Hugging Face Spaces might have it in specific locations
+    # or it might need to be installed via packages.txt or a Dockerfile.
+    # For Gradio apps on Spaces, it's often pre-configured or easily installable.
+    # Let's try common paths or rely on it being in PATH.
+    
+    # Check if chromedriver is in PATH or use a common location
+    chromedriver_path = shutil.which("chromedriver")
+    if chromedriver_path:
+        print(f"Using chromedriver found at: {chromedriver_path}")
+        service = ChromeService(executable_path=chromedriver_path)
+    else:
+        # Fallback if not in PATH - this might fail on HF if not installed correctly
+        print("Chromedriver not found in PATH. Attempting to use 'chromedriver' directly (might fail).")
+        print("For Hugging Face Spaces, ensure Chrome & Chromedriver are available in the environment.")
+        print("You might need to add 'chromium-chromedriver' to a packages.txt file if using a Docker Space.")
+        # As a last resort, try initializing without explicit path, hoping Selenium finds it.
+        # This part is crucial for HF deployment and might need adjustment based on the HF Space environment.
+        # For many Gradio spaces, simply having 'selenium' and 'chromedriver-binary' (or similar)
+        # in requirements.txt might work if the base image is well-configured.
+        # However, for full Chrome, system-level install is better.
+        # For now, we'll proceed assuming it might be found or will error out gracefully.
+        try:
+            # This assumes chromedriver is globally available or Selenium can find it.
+            # On Hugging Face, if using default Docker runtime, you might need to specify
+            # apt packages like 'chromium-driver' or 'google-chrome-stable' + 'chromedriver'
+            # in a packages.txt file or use a custom Dockerfile.
+            # For simplicity, let's assume it can be found or will fail here.
+            # A common path if installed via apt in a container:
+            if os.path.exists("/usr/bin/chromedriver"):
+                 service = ChromeService(executable_path="/usr/bin/chromedriver")
+            elif os.path.exists("/usr/local/bin/chromedriver"):
+                 service = ChromeService(executable_path="/usr/local/bin/chromedriver")
+            else:
+                # This will likely fail if chromedriver isn't installed and in PATH
+                # On HF Spaces, you typically ensure this via environment setup (e.g. packages.txt)
+                print("Attempting to initialize ChromeService without explicit path...")
+                service = ChromeService() # May fail if chromedriver not in PATH
+        except Exception as e:
+            print(f"Could not initialize ChromeService: {e}. Ensure chromedriver is installed and in PATH.")
+            return None
+
+
+    try:
+        print("Setting up ChromeDriver for Hugging Face environment...")
+        driver = webdriver.Chrome(service=service, options=options)
+        print("ChromeDriver setup successful.")
+    except Exception as e:
+        print(f"Error setting up ChromeDriver: {e}")
+        return None
+
+    driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined});")
+    return driver
+
+def clean_address(address_str):
+    if not isinstance(address_str, str):
+        return ""
+    cleaned_address = ' '.join(address_str.split())
+    cleaned_address = re.sub(r'floor-\s*[\w\s]+,?', '', cleaned_address, flags=re.IGNORECASE)
+    cleaned_address = cleaned_address.replace(' ,', ',').replace(',,', ',')
+    cleaned_address = ', '.join(filter(None, (s.strip() for s in cleaned_address.split(','))))
+    if "india" not in cleaned_address.lower() and ("mumbai" in cleaned_address.lower() or "maharashtra" in cleaned_address.lower()):
+         cleaned_address += ", India"
+    return cleaned_address
+
+def geocode_address_with_fallbacks(address_str, attempt_count=0):
+    if not address_str or not address_str.strip():
+        print("Address string is empty, cannot geocode.")
+        return None, None
+    cleaned_address = clean_address(address_str)
+    print(f"Attempting to geocode cleaned address: '{cleaned_address}' (Attempt {attempt_count + 1})")
+    nominatim_user_agent = f"gstin_gradio_app_hf_{int(time.time())}"
+    geocoders_to_try = [
+        ("Nominatim", Nominatim(user_agent=nominatim_user_agent)),
+        ("ArcGIS", ArcGIS(timeout=10))
+    ]
+    for name, geolocator in geocoders_to_try:
+        try:
+            print(f"Trying geocoder: {name}...")
+            location = geolocator.geocode(cleaned_address, timeout=15)
+            if location:
+                print(f"Success with {name}: Lat: {location.latitude}, Lon: {location.longitude}")
+                return location.latitude, location.longitude
+            else:
+                print(f"{name} could not geocode the address.")
+        except (GeocoderTimedOut, GeocoderUnavailable, GeocoderServiceError) as e:
+            print(f"{name} geocoding error: {e}")
+        except Exception as e:
+            print(f"An unexpected error occurred with {name}: {e}")
+        time.sleep(1)
+    if attempt_count == 0:
+        parts = [s.strip() for s in cleaned_address.split(',') if s.strip()]
+        if len(parts) > 3:
+            generic_address = ', '.join(parts[1:])
+            print(f"Trying a more generic address (v1): '{generic_address}'")
+            lat, lon = geocode_address_with_fallbacks(generic_address, attempt_count + 1)
+            if lat is not None: return lat, lon
+            if len(parts) > 4:
+                generic_address_v2 = ', '.join(parts[2:])
+                print(f"Trying a more generic address (v2): '{generic_address_v2}'")
+                return geocode_address_with_fallbacks(generic_address_v2, attempt_count + 1)
+    print("All geocoding attempts failed for the address.")
+    return None, None
+
+def get_gstin_details_for_gradio(gstin_number_input):
+    """
+    Main function for Gradio: takes GSTIN, scrapes, and returns data as DataFrame.
+    """
+    gstin_number = str(gstin_number_input).strip().upper()
+    if not (len(gstin_number) == 15 and gstin_number.isalnum()):
+        return pd.DataFrame({"Error": ["Invalid GSTIN format. Must be 15 alphanumeric characters."]})
+
+    print(f"Initiating scraper for GSTIN: {gstin_number}")
+    driver = driversetup_huggingface()
+
+    if driver is None:
+        print("WebDriver not initialized for scraper.")
+        return pd.DataFrame({"Error": ["WebDriver initialization failed. Check server logs."]})
+
+    extracted_data = {"GSTIN Queried": gstin_number}
+    wait_time = 30
+    url = "https://www.mastersindia.co/gst-number-search-and-gstin-verification/"
+
+    try:
+        driver.get(url)
+        print(f"Navigated to URL: {url}")
+
+        gstin_input_css_selector = 'input[placeholder="XXXAAAYYYYZ01Z5"]'
+        WebDriverWait(driver, wait_time).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, gstin_input_css_selector))
+        )
+        gstin_input = driver.find_element(By.CSS_SELECTOR, gstin_input_css_selector)
+        gstin_input.clear()
+        gstin_input.send_keys(gstin_number)
+        print(f"Entered GSTIN: {gstin_number}")
+
+        search_button_css_selector = 'button[aria-label="Search"]'
+        WebDriverWait(driver, wait_time).until(
+            EC.element_to_be_clickable((By.CSS_SELECTOR, search_button_css_selector))
+        )
+        search_button = driver.find_element(By.CSS_SELECTOR, search_button_css_selector)
+        driver.execute_script("arguments[0].click();", search_button)
+        print("Clicked Search button.")
+
+        results_table_container_css_selector_for_wait = "div.eaKoeQ table"
+        WebDriverWait(driver, wait_time).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, results_table_container_css_selector_for_wait))
+        )
+        print("Results table container found.")
+        time.sleep(4)
+
+        page_source = driver.page_source
+        soup = BeautifulSoup(page_source, 'html.parser')
+
+        table_container_div = soup.select_one("div.eaKoeQ")
+        table = None
+        if table_container_div: table = table_container_div.find('table')
+        if not table: table = soup.find('table')
+
+        if not table:
+            msg = "No data table found on the page after search."
+            if "captcha" in page_source.lower(): msg = "CAPTCHA detected during scraping."
+            elif "No details found" in page_source or "Invalid GSTIN" in page_source:
+                msg = f"No details found for GSTIN {gstin_number} or invalid GSTIN."
+            print(msg)
+            return pd.DataFrame({"Error": [msg]})
+        
+        rows = table.find_all('tr')
+        raw_data = {}
+        for row in rows:
+            header_element = row.find('th', class_=lambda x: x and 'eLVLDP' in x.split())
+            value_element = row.find('td', class_=lambda x: x and 'jdgLDg' in x.split())
+            if header_element and value_element:
+                raw_data[header_element.get_text(strip=True)] = value_element.get_text(strip=True)
+            elif len(row.find_all('td')) == 2:
+                cells = row.find_all('td')
+                if cells[0].get_text(strip=True):
+                    raw_data[cells[0].get_text(strip=True)] = cells[1].get_text(strip=True)
+
+        if not raw_data:
+            print("Could not parse any data from the table rows.")
+            return pd.DataFrame({"Error": ["Failed to parse data from table."]})
+
+        fields_to_extract_map = {
+            "Principal Place of Business": "Principal Business Address",
+            "Additional Place of Business": "Additional Business Address(es)",
+            "State Jurisdiction": "State Jurisdiction",
+            "Centre Jurisdiction": "Centre Jurisdiction",
+            "Date of Registration": "Registration Date",
+            "Constitution of Business": "Business Constitution",
+            "Taxpayer Type": "Taxpayer Type",
+            "GSTIN Status": "GSTIN Status"
+        }
+        for web_key, display_key in fields_to_extract_map.items():
+            extracted_data[display_key] = raw_data.get(web_key, "Not Found")
+
+        address_to_geocode = extracted_data.get("Principal Business Address")
+        if address_to_geocode not in [None, "Not Found", ""]:
+            lat, lon = geocode_address_with_fallbacks(address_to_geocode)
+            extracted_data["Address Latitude"] = lat if lat is not None else "N/A"
+            extracted_data["Address Longitude"] = lon if lon is not None else "N/A"
+        else:
+            extracted_data["Address Latitude"] = "N/A"
+            extracted_data["Address Longitude"] = "N/A"
+            if extracted_data.get("Principal Business Address"):
+                 print("Principal Place of Business not found or empty, skipping geocoding.")
+        
+        print(f"Successfully scraped data for {gstin_number}")
+        # Convert dictionary to a 2-column DataFrame for Gradio
+        df_output = pd.DataFrame(list(extracted_data.items()), columns=["Field", "Value"])
+        return df_output
+
+    except Exception as e:
+        print(f"An error occurred during scraping process for {gstin_number}: {e}")
+        # import traceback
+        # traceback.print_exc()
+        return pd.DataFrame({"Error": [f"Scraping process failed: {str(e)}"]})
+    finally:
+        if 'driver' in locals() and driver is not None:
+            try:
+                driver.quit()
+                print("Browser closed.")
+            except Exception as e:
+                print(f"Error quitting driver: {e}")
+
+# --- Gradio Interface ---
+iface = gr.Interface(
+    fn=get_gstin_details_for_gradio,
+    inputs=gr.Textbox(
+        label="Enter GSTIN",
+        placeholder="Enter 15-character GSTIN (e.g., 27AAFCD5562R1Z5)",
+        max_lines=1,
+        info="The scraper will fetch details for the provided GSTIN from Masters India."
+    ),
+    outputs=gr.DataFrame(
+        label="GSTIN Details",
+        headers=["Field", "Value"],
+        wrap=True
+    ),
+    title="🧾 GSTIN Details Scraper & Verifier",
+    description="Enter a valid 15-character Indian GSTIN to fetch its registration details and attempt to geocode the principal place of business. Uses Masters India for scraping.",
+    article="<p style='text-align: center;'>Powered by Selenium, BeautifulSoup, Geopy, and Gradio. <br>Note: Scraping may take 20-40 seconds. Geocoding accuracy may vary.</p>",
+    examples=[["27AAFCD5562R1Z5"], ["07AAFCM6072R1Z8"]], # Example GSTINs
+    allow_flagging="never",
+    theme=gr.themes.Soft() # Using a soft theme
+)
+
+if __name__ == '__main__':
+    # For Hugging Face Spaces, Gradio typically handles the server.
+    # This launch(share=True) is more for local testing if you want a public link temporarily.
+    # On HF Spaces, just `iface.launch()` is enough.
+    # To run locally: python app.py
+    if os.environ.get("SYSTEM") == "spaces": # Check if running in Hugging Face Spaces
+         iface.launch(debug=False)
+    else:
+         iface.launch(debug=True, share=True)