pip install pywin32  # Windows वातावरण में Excel स्वचालित संचालन के लिए 'pythoncom' आदि शामिल हैं
pip install xlwings   # Excel के साथ इंटरैक्शन के लिए उपयोग किया जाता है

python excellan.py

import socket
import platform
import subprocess
import os
import sys
import time
import threading
from datetime import datetime
import xlwings as xw
import ipaddress
import re
from concurrent.futures import ThreadPoolExecutor, as_completed

def get_shared_folders(ip_address: str) -> str:
    """
    Retrieve a list of shared folders for the specified IP address.
    For Windows, use the 'net view' command.
    """
    if platform.system().lower() == "windows":
        cmd = f'net view \\\\{ip_address}'
        try:
            output = subprocess.check_output(cmd, shell=True, universal_newlines=True, stderr=subprocess.DEVNULL)
            shares = re.findall(r'\\\\\S+\s+(\S+)', output)
            return ", ".join(shares) if shares else ""
        except subprocess.CalledProcessError:
            return ""
        except Exception:
            return ""
    else:
        return ""

class ImprovedNetworkMonitor:
    def __init__(self, excel_file='improved_lan_monitor.xlsx'):
        self.excel_file = excel_file
        self.should_run = False
        self.monitor_thread = None
        self.refresh_interval = 30  # Regular refresh interval (seconds)
        self.full_scan_interval = 600  # Full scan interval (seconds)
        self.known_devices = {}       # Dictionary of known devices keyed by IP address
        self.active_ips = set()       # Set of active IPs
        self.priority_ips = set()     # IPs to scan with priority
        self.check_shared_folders = False  # Whether to detect shared folders (toggle in settings)
        self.thread_app = None      # Excel app for background thread
        self.monitor_wb = None      # Workbook kept open continuously
        self.close_excel_on_stop = True  # Close Excel on exit (True on exit, False on stop)

        # If the Excel file does not exist, create a template; otherwise, load settings.
        if not os.path.exists(self.excel_file):
            self.create_excel_template()
        else:
            self.load_settings()
    
    def create_excel_template(self):
        """Create an Excel template for monitoring (performed in the main thread)"""
        try:
            app = xw.App(visible=False)
            wb = app.books.add()
            try:
                main_sheet = wb.sheets['Network Monitor']
            except Exception:
                main_sheet = wb.sheets.add(name='Network Monitor')
            try:
                status_sheet = wb.sheets['Status History']
            except Exception:
                status_sheet = wb.sheets.add(name='Status History')
            try:
                config_sheet = wb.sheets['Settings']
            except Exception:
                config_sheet = wb.sheets.add(name='Settings')
            
            main_sheet.range('A1').value = [
                'IP', 'Hostname', 'Device Type', 'Status', 'Response Time (ms)', 'Last Seen', 'Detection Count', 'Shared Folders'
            ]
            main_sheet.range('A1:H1').api.Font.Bold = True
            main_sheet.range('A1:H1').color = (200, 200, 250)
            
            status_sheet.range('A1').value = ['Timestamp', 'Online Devices', 'Offline Devices', 'Network Status', 'Scan Mode']
            status_sheet.range('A1:E1').api.Font.Bold = True
            status_sheet.range('A1:E1').color = (200, 200, 250)
            
            network_info = self.get_network_info()
            config_sheet.range('A1').value = 'Regular Refresh Interval (seconds)'
            config_sheet.range('B1').value = 30
            config_sheet.range('A2').value = 'Full Scan Interval (seconds)'
            config_sheet.range('B2').value = 600
            config_sheet.range('A3').value = 'Network Range'
            config_sheet.range('B3').value = network_info['network_range']
            config_sheet.range('A4').value = 'DHCP Range Start'
            config_sheet.range('B4').value = 100
            config_sheet.range('A5').value = 'DHCP Range End'
            config_sheet.range('B5').value = 200
            config_sheet.range('A6').value = 'Priority IP Addresses (comma-separated)'
            config_sheet.range('B6').value = f"{network_info['gateway']},{network_info['local_ip']}"
            config_sheet.range('A7').value = 'Detailed Display'
            config_sheet.range('B7').value = False
            config_sheet.range('A8').value = 'Shared Folder Detection'
            config_sheet.range('B8').value = False
            config_sheet.range('C8').value = 'Note: Set to True to retrieve shared folder information'
            
            config_sheet.range('C1').value = 'Note: Too short intervals increase load (minimum 10 seconds)'
            config_sheet.range('C2').value = 'Note: Interval for detecting all devices on the network'
            config_sheet.range('C4').value = "Note: Router's DHCP configuration range"
            config_sheet.range('C6').value = 'Note: IP addresses to always scan'
            config_sheet.range('C7').value = 'Note: If True, display debug information in Excel'
            
            main_sheet.autofit()
            status_sheet.autofit()
            config_sheet.autofit()
            
            for sheet in wb.sheets:
                if sheet.name not in ['Network Monitor', 'Status History', 'Settings']:
                    sheet.delete()
            
            wb.save(self.excel_file)
            wb.close()
            app.quit()
            print(f"Template created: {self.excel_file}")
            self.load_settings()
        except Exception as e:
            print(f"Template creation error: {e}")
    
    def load_settings(self):
        """Load settings from the Excel file (performed in the main thread)"""
        try:
            app = xw.App(visible=False)
            wb = app.books.open(self.excel_file)
            config_sheet = wb.sheets['Settings']
            try:
                interval = config_sheet.range('B1').value
                if isinstance(interval, (int, float)) and interval >= 10:
                    self.refresh_interval = int(interval)
            except:
                pass
            try:
                full_interval = config_sheet.range('B2').value
                if isinstance(full_interval, (int, float)) and full_interval >= 60:
                    self.full_scan_interval = int(full_interval)
            except:
                pass
            try:
                priority_ips_str = config_sheet.range('B6').value
                if priority_ips_str and isinstance(priority_ips_str, str):
                    for ip in priority_ips_str.split(','):
                        ip = ip.strip()
                        if self.is_valid_ip(ip):
                            self.priority_ips.add(ip)
            except:
                pass
            network_info = self.get_network_info()
            self.priority_ips.add(network_info['local_ip'])
            if network_info['gateway'] != "Unknown":
                self.priority_ips.add(network_info['gateway'])
            try:
                shared_option = config_sheet.range('B8').value
                self.check_shared_folders = bool(shared_option)
            except:
                pass
            wb.close()
            app.quit()
        except Exception as e:
            print(f"Error reading settings: {e}")
    
    def is_valid_ip(self, ip):
        pattern = re.compile(r'^(\d{1,3}\.){3}\d{1,3}$')
        if not pattern.match(ip):
            return False
        return all(0 <= int(octet) <= 255 for octet in ip.split('.'))
    
    def get_network_info(self):
        # Get local hostname from environment variables (e.g., n4060)
        hostname = os.environ.get("COMPUTERNAME", socket.gethostname())
        try:
            local_ip = socket.gethostbyname(hostname)
        except:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            try:
                s.connect(('8.8.8.8', 1))
                local_ip = s.getsockname()[0]
            except:
                local_ip = '127.0.0.1'
            finally:
                s.close()
        gateway = "Unknown"
        try:
            if platform.system() == "Windows":
                output = subprocess.check_output("ipconfig", universal_newlines=True)
                for line in output.split('\n'):
                    if "Default Gateway" in line or "デフォルト ゲートウェイ" in line:
                        gw = line.split(":")[-1].strip()
                        if gw:
                            gateway = gw
                            break
            else:
                try:
                    output = subprocess.check_output("ip route | grep default", shell=True, universal_newlines=True)
                    gateway = output.split()[2]
                except:
                    output = subprocess.check_output("netstat -nr | grep default", shell=True, universal_newlines=True)
                    gateway = output.split()[1]
        except:
            pass
        ip_parts = local_ip.split('.')
        network_prefix = '.'.join(ip_parts[:3]) + '.'
        network_range = f"{network_prefix}0/24"
        return {
            "hostname": hostname,
            "local_ip": local_ip,
            "gateway": gateway,
            "network_range": network_range,
            "network_prefix": network_prefix,
            "scan_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
    
    def ping_device(self, ip_address, count=1):
        try:
            if platform.system().lower() == "windows":
                ping_cmd = f"ping -n {count} -w 500 {ip_address}"
            else:
                ping_cmd = f"ping -c {count} -W 0.5 {ip_address}"
            start_time = time.time()
            result = subprocess.run(ping_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, universal_newlines=True)
            response_time_ms = round((time.time() - start_time) * 1000)
            if result.returncode == 0:
                return {"status": "Online", "response_time_ms": response_time_ms}
            else:
                return {"status": "Offline", "response_time_ms": None}
        except Exception as e:
            print(f"Ping error ({ip_address}): {e}")
            return {"status": "Error", "response_time_ms": None}
    
    def get_hostname(self, ip_address):
        try:
            socket.setdefaulttimeout(1)
            hostname = socket.getfqdn(ip_address)
            if hostname == ip_address:
                return "Unknown"
            return hostname
        except:
            return "Unknown"
    
    def get_device_type(self, ip_address, network_info):
        if ip_address == network_info["local_ip"]:
            return "This PC"
        elif ip_address == network_info["gateway"]:
            return "Gateway"
        if ip_address in self.known_devices:
            hostname = self.known_devices[ip_address].get("hostname_base", "").lower()
            if "printer" in hostname or "print" in hostname:
                return "Printer"
            elif "phone" in hostname or "mobile" in hostname or "android" in hostname or "iphone" in hostname:
                return "Mobile"
            elif "tv" in hostname or "television" in hostname or "smart-tv" in hostname:
                return "TV/Media"
        return "Other"
    
    def get_scan_targets(self, network_info, mode="regular"):
        targets = set()
        network_prefix = network_info["network_prefix"]
        if mode == "full":
            try:
                network = ipaddress.IPv4Network(network_info["network_range"])
                for ip in network.hosts():
                    targets.add(str(ip))
            except Exception as e:
                print(f"IP network analysis error: {e}")
                for i in range(1, 255):
                    targets.add(f"{network_prefix}{i}")
        elif mode == "dhcp":
            try:
                config_sheet = self.monitor_wb.sheets['Settings']
                start_range = int(config_sheet.range('B4').value or 100)
                end_range = int(config_sheet.range('B5').value or 200)
                if start_range < 1:
                    start_range = 1
                if end_range > 254:
                    end_range = 254
                for i in range(start_range, end_range + 1):
                    targets.add(f"{network_prefix}{i}")
            except Exception as e:
                for i in range(100, 201):
                    targets.add(f"{network_prefix}{i}")
        else:  # regular
            targets.update(self.active_ips)
            targets.update(self.priority_ips)
        targets.update(self.priority_ips)
        return list(targets)
    
    def scan_network(self, mode="regular"):
        network_info = self.get_network_info()
        targets = self.get_scan_targets(network_info, mode)
        print(f"Scanning network: {mode} mode ({len(targets)} IPs)...")
        devices = []
        new_active_ips = set()
        results = {}
        # Execute ping in parallel using a thread pool
        with ThreadPoolExecutor(max_workers=min(50, len(targets))) as executor:
            future_to_ip = {executor.submit(self.ping_device, ip): ip for ip in targets}
            for future in as_completed(future_to_ip):
                ip = future_to_ip[future]
                try:
                    results[ip] = future.result()
                except Exception as e:
                    results[ip] = {"status": "Error", "response_time_ms": None}
        # Update device information based on results
        for ip in targets:
            ping_result = results.get(ip, {"status": "Error", "response_time_ms": None})
            if ping_result["status"] == "Online":
                new_active_ips.add(ip)
                if ip not in self.known_devices or self.known_devices[ip].get("status") != "Online":
                    hostname_base = self.get_hostname(ip)
                else:
                    hostname_base = self.known_devices[ip].get("hostname_base", "Unknown")
                device_type = self.get_device_type(ip, network_info)
                device = {
                    "ip": ip,
                    "hostname": hostname_base,
                    "hostname_base": hostname_base,
                    "device_type": device_type,
                    "status": ping_result["status"],
                    "response_time_ms": ping_result["response_time_ms"],
                    "last_seen": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                    "detection_count": self.known_devices.get(ip, {}).get("detection_count", 0) + 1
                }
                self.known_devices[ip] = device
                devices.append(device)
            elif ip in self.known_devices:
                offline_device = self.known_devices[ip].copy()
                offline_device["status"] = "Offline"
                offline_device["response_time_ms"] = None
                offline_device["last_seen"] = self.known_devices[ip].get("last_seen", "Unknown")
                devices.append(offline_device)
        self.active_ips = new_active_ips
        return devices
    
    def update_excel(self, devices, scan_mode):
        max_retries = 5
        while max_retries > 0:
            try:
                wb = self.monitor_wb
                app = wb.app
                app.screen_updating = False
                try:
                    sheet = wb.sheets['Network Monitor']
                except Exception:
                    sheet = wb.sheets.add(name='Network Monitor')
                sheet.range("A2:H1000").clear()
                unique_devices = {}
                for device in devices:
                    ip = device.get('ip')
                    if ip not in unique_devices or device.get('detection_count', 0) > unique_devices[ip].get('detection_count', 0):
                        unique_devices[ip] = device
                device_data = []
                for device in unique_devices.values():
                    if self.check_shared_folders and device.get('status') == 'Online':
                        shared_folders = get_shared_folders(device.get('ip'))
                    else:
                        shared_folders = ""
                    device_data.append([
                        device.get('ip', 'Unknown'),
                        device.get('hostname', 'Unknown'),
                        device.get('device_type', 'Other'),
                        device.get('status', 'Unknown'),
                        device.get('response_time_ms', '-'),
                        device.get('last_seen', datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
                        device.get('detection_count', 1),
                        shared_folders
                    ])
                if device_data:
                    device_data.sort(key=lambda x: [int(octet) for octet in x[0].split('.')])
                    sheet.range('A2').value = device_data
                    for i, row_data in enumerate(device_data, start=2):
                        status = row_data[3]
                        if status == 'Online':
                            sheet.range(f'D{i}').color = (198, 239, 206)
                        else:
                            sheet.range(f'D{i}').color = (255, 199, 206)
                        device_type = row_data[2]
                        if device_type == 'Gateway':
                            sheet.range(f'C{i}').color = (255, 230, 153)
                        elif device_type == 'This PC':
                            sheet.range(f'C{i}').color = (197, 217, 241)
                        elif device_type == 'Printer':
                            sheet.range(f'C{i}').color = (216, 191, 216)
                        elif device_type == 'Mobile':
                            sheet.range(f'C{i}').color = (255, 204, 153)
                try:
                    status_sheet = wb.sheets['Status History']
                except Exception:
                    try:
                        status_sheet = wb.sheets.add(name='Status History')
                        status_sheet.range('A1').value = ['Timestamp', 'Online Devices', 'Offline Devices', 'Network Status', 'Scan Mode']
                        status_sheet.range('A1:E1').api.Font.Bold = True
                        status_sheet.range('A1:E1').color = (200, 200, 250)
                    except:
                        status_sheet = None
                if status_sheet:
                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                    online_count = sum(1 for d in unique_devices.values() if d['status'] == 'Online')
                    offline_count = sum(1 for d in unique_devices.values() if d['status'] == 'Offline')
                    if online_count == 0:
                        network_status = "No network connection"
                    elif online_count < 2:
                        network_status = "Issues - Too few devices found"
                    else:
                        network_status = "Normal"
                    last_status_row = status_sheet.range('A' + str(status_sheet.cells.last_cell.row)).end('up').row
                    status_sheet.range(f'A{last_status_row+1}').value = [timestamp, online_count, offline_count, network_status, scan_mode]
                    if last_status_row > 30:
                        status_sheet.range(f'A2:E{last_status_row-29}').delete()
                try:
                    config_sheet = wb.sheets['Settings']
                    show_details = bool(config_sheet.range('B7').value)
                except:
                    show_details = False
                current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                try:
                    info_text = f"Last update: {current_time} ({scan_mode} scan)"
                    if show_details:
                        info_text += f" | Active IPs: {len(self.active_ips)} | Priority IPs: {len(self.priority_ips)}"
                    sheet.range('A1').offset(-1, 0).value = info_text
                except:
                    pass
                wb.save()
                app.screen_updating = True
                print(f"Excel updated: {current_time} ({scan_mode} mode)")
                return True
            except Exception as e:
                if "0x800ac472" in str(e):
                    print("Excel is busy. Retrying.")
                    time.sleep(1)
                    max_retries -= 1
                    continue
                else:
                    print(f"Excel update error: {e}")
                    return False
        print("Failed to update Excel after retrying.")
        return False
    
    def monitor_loop(self):
        import pythoncom
        pythoncom.CoInitialize()
        self.thread_app = xw.App(visible=True)
        try:
            self.monitor_wb = self.thread_app.books.open(self.excel_file)
            last_scan_time = 0
            last_full_scan_time = 0
            while self.should_run:
                try:
                    current_time = time.time()
                    scan_mode = "regular"
                    if current_time - last_full_scan_time >= self.full_scan_interval:
                        scan_mode = "full"
                        last_full_scan_time = current_time
                    elif len(self.active_ips) < 3 and current_time - last_full_scan_time >= 60:
                        scan_mode = "dhcp"
                    if (current_time - last_scan_time >= self.refresh_interval) or scan_mode != "regular":
                        try:
                            devices = self.scan_network(mode=scan_mode)
                            if devices:
                                self.update_excel(devices, scan_mode)
                            last_scan_time = current_time
                        except Exception as e:
                            print(f"Monitoring cycle error: {e}")
                    time.sleep(5)
                except Exception as e:
                    print(f"Monitoring loop error: {e}")
                    time.sleep(10)
        finally:
            if self.close_excel_on_stop:
                if self.monitor_wb:
                    self.monitor_wb.save()
                    self.monitor_wb.close()
                    self.monitor_wb = None
                self.thread_app.quit()
                self.thread_app = None
            else:
                if self.monitor_wb:
                    self.monitor_wb.save()
            pythoncom.CoUninitialize()
    
    def start_monitoring(self):
        if self.monitor_thread and self.monitor_thread.is_alive():
            print("Monitoring is already running")
            return False
        self.load_settings()
        self.close_excel_on_stop = True
        self.should_run = True
        self.monitor_thread = threading.Thread(target=self.monitor_loop)
        self.monitor_thread.start()
        print("Network monitoring started")
        return True
    
    def stop_monitoring(self, close_excel=False):
        self.close_excel_on_stop = close_excel
        self.should_run = False
        if self.monitor_thread:
            try:
                self.monitor_thread.join(timeout=5)
            except:
                pass
        print("Network monitoring stopped")
        return True

def main():
    run_now = False
    excel_file = 'improved_lan_monitor.xlsx'
    if len(sys.argv) > 1:
        for arg in sys.argv[1:]:
            if arg == '--run':
                run_now = True
            elif arg.startswith('--excel='):
                excel_file = arg.split('=')[1]
    monitor = ImprovedNetworkMonitor(excel_file=excel_file)
    if run_now:
        monitor.start_monitoring()
        try:
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            print("Exiting...")
            monitor.stop_monitoring(close_excel=True)
            sys.exit(0)
    else:
        print(f"Improved LAN Monitoring Tool v1.0")
        print(f"Excel file: {monitor.excel_file}")
        print("Commands: start - start monitoring, stop - stop monitoring (Excel remains open), exit - exit (closes Excel)")
        while True:
            try:
                cmd = input("> ").strip().lower()
                if cmd == "start":
                    monitor.start_monitoring()
                elif cmd == "stop":
                    monitor.stop_monitoring(close_excel=False)
                elif cmd == "exit":
                    if monitor.should_run:
                        monitor.stop_monitoring(close_excel=True)
                    sys.exit(0)
                else:
                    print("Unknown command. Please enter one of start, stop, exit.")
            except EOFError:
                break
            except KeyboardInterrupt:
                print("\nExiting...")
                if monitor.should_run:
                    monitor.stop_monitoring(close_excel=True)
                sys.exit(0)

if __name__ == "__main__":
    main()

def get_shared_folders(ip_address: str) -> str:
    # यहां get_shared_folders फ़ंक्शन का कोड शामिल करें

class ImprovedNetworkMonitor:
    # यहां ImprovedNetworkMonitor क्लास का कोड शामिल करें

with ThreadPoolExecutor(max_workers=min(50, len(targets))) as executor:
    future_to_ip = {executor.submit(self.ping_device, ip): ip for ip in targets}
    # अन्य कोड यहां...

python -m venv venv

venv/scripts/activate

pip install openpyxl netifaces

pip install streamlit pandas streamlit_autorefresh

python realtime_lan_monitor.py

cd\
cd lan
venv/scripts/activate
streamlit run app.py

import os
import sys
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

import logging
import time
import pandas as pd
import streamlit as st
from streamlit_autorefresh import st_autorefresh

from realtime_lan_monitor_csv import ImprovedNetworkMonitorCSV

# --------------------------------
# लॉग कॉन्फिगरेशन: INFO स्तर और उससे ऊपर
# --------------------------------
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")

# --------------------------------
# Streamlit पेज कॉन्फिगरेशन
# --------------------------------
st.set_page_config(
    page_title="LAN मॉनिटरिंग",
    layout="wide"
)

# --------------------------------
# ऑटो रिफ्रेश (5 सेकंड)
# --------------------------------
st_autorefresh(interval=5000, limit=100, key="fizzbuzz")

# --------------------------------
# सेशन स्टेट से मॉनिटर प्रबंधन
# --------------------------------
if 'monitor' not in st.session_state:
    try:
        monitor = ImprovedNetworkMonitorCSV()
        monitor.start_monitoring()
        st.session_state.monitor = monitor
    except Exception as e:
        st.error(f"नेटवर्क मॉनिटर इनिशियलाइजेशन त्रुटि: {e}")

st.title("रीयल-टाइम नेटवर्क मॉनिटरिंग (CSV संस्करण)")

monitor = st.session_state.get('monitor', None)
if monitor is None:
    st.error("नेटवर्क मॉनिटर इनिशियलाइज नहीं किया गया है।")
else:
    # स्थिति प्रदर्शन
    if monitor.should_run:
        st.success("मॉनिटरिंग वर्तमान स्थिति: चल रहा है")
    else:
        st.warning("मॉनिटरिंग वर्तमान स्थिति: रुका हुआ है")

    # रोकने का बटन
    if st.button("मॉनिटरिंग बंद करें"):
        monitor.stop_monitoring()
        st.warning("मॉनिटरिंग बंद कर दी गई है। यदि आवश्यक हो तो ऐप को बंद करें।")

    # पुनः प्रारंभ बटन
    if st.button("मॉनिटरिंग फिर से शुरू करें"):
        if not monitor.should_run:
            monitor.start_monitoring()
            st.success("मॉनिटरिंग फिर से शुरू कर दी गई है।")
        else:
            st.info("मॉनिटरिंग पहले से ही चल रही है।")

    # डिवाइस सूची प्रदर्शन
    devices = monitor.last_devices if hasattr(monitor, "last_devices") else []
    if devices:
        df = pd.DataFrame(devices)
        st.dataframe(df)
    else:
        st.info("अभी तक कोई डिवाइस जानकारी प्राप्त नहीं हुई है। स्कैन होने तक प्रतीक्षा करें।")

    st.write(f"अंतिम अपडेट: {time.strftime('%Y-%m-%d %H:%M:%S')}")

st_autorefresh(interval=5000, limit=100, key="fizzbuzz")

if 'monitor' not in st.session_state:
    monitor = ImprovedNetworkMonitorCSV()
    # ...

if st.button("मॉनिटरिंग बंद करें"):
    monitor.stop_monitoring()

df = pd.DataFrame(devices)
st.dataframe(df)

import logging
logging.basicConfig(
    filename='lan_monitor.log',
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    encoding='utf-8'
)

CONFIG_FILE = "config.json"

def load_config():
    config = {
        "excel_file": "improved_lan_monitor.xlsx",
        "refresh_interval": 30,
        "full_scan_interval": 600,
        "dhcp_range_start": 100,
        "dhcp_range_end": 200,
        "priority_ips": [],
        "check_shared_folders": True
    }
    # यदि कॉन्फिग फाइल मौजूद हो तो उसे लोड करें
    if os.path.exists(CONFIG_FILE):
        try:
            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                file_conf = json.load(f)
            config.update(file_conf)
        except Exception as e:
            logging.error(f"कॉन्फिग फाइल लोडिंग त्रुटि: {e}", exc_info=True)
    return config

def scan_network(self, mode="regular"):
    net_info = get_network_info()
    targets = self.get_scan_targets(net_info, mode)
    devices = []
    new_active = set()

    with ThreadPoolExecutor(max_workers=20) as executor:
        futures = {executor.submit(ping_and_collect, ip, net_info, 
                  self.known_devices, self.check_shared_folders): ip 
                  for ip in targets}
        for future in as_completed(futures):
            ip = futures[future]
            try:
                _, status, device = future.result()
                if status == "ऑनलाइन" and device:
                    new_active.add(ip)
                    self.known_devices[ip] = device
                    devices.append(device)

def get_scan_targets(self, network_info, mode="regular"):
    targets = set()
    prefix = network_info["network_prefix"]
    
    if mode == "full":
        try:
            net = ipaddress.IPv4Network(network_info["network_range"])
            for ip in net.hosts():
                targets.add(str(ip))
        except Exception as e:
            logging.error(f"फुल स्कैन त्रुटि: {e}", exc_info=True)
            # फॉलबैक मैन्युअल स्कैन रेंज
            for i in range(1, 255):
                targets.add(f"{prefix}{i}")

def monitor_loop(self):
    last_scan_time = 0
    last_full_scan_time = 0

    while self.should_run:
        try:
            now = time.time()
            scan_mode = "regular"
            # फुल स्कैन निर्धारण
            if now - last_full_scan_time >= self.full_scan_interval:
                scan_mode = "full"
                last_full_scan_time = now
            # DHCP स्कैन निर्धारण
            elif len(self.active_ips) < 3 and now - last_full_scan_time >= 60:
                scan_mode = "dhcp"

def scan_network(self, mode="regular"):
    # ...
    with self.lock:  # थ्रेड लॉक का उपयोग 
        old_status = self.known_devices.get(ip, {}).get("status", "अज्ञात")
    # ...
    with self.lock:  # थ्रेड लॉक का उपयोग
        self.known_devices[ip] = dev_info

# स्वयं समायोजित करने वाली स्कैन आवृत्ति
if network_load > 80:  # नेटवर्क लोड अधिक है
    current_refresh_interval = min(self.refresh_interval * 2, 120)  # दोगुना करें, अधिकतम 2 मिनट 
elif network_load < 20:  # नेटवर्क लोड कम है
    current_refresh_interval = max(self.refresh_interval / 2, 15)  # आधा करें, न्यूनतम 15 सेकंड
else:
    current_refresh_interval = self.refresh_interval  # सामान्य आवृत्ति

CONFIG = {
    "EVENT_LOG_FILE": "event_log.csv",       # स्थिति परिवर्तन का इतिहास
    "SNAPSHOT_LOG_FILE": "snapshot_log.csv", # स्नैपशॉट का इतिहास
    "CSV_ENCODING": "utf-8-sig",
    "REFRESH_INTERVAL": 30,       # सामान्य अपडेट अंतराल (सेकंड)
    "FULL_SCAN_INTERVAL": 600,    # फुल स्कैन अंतराल (सेकंड)
    "SNAPSHOT_INTERVAL": 600,     # स्नैपशॉट अंतराल (सेकंड)
    "DHCP_RANGE_START": 100,
    "DHCP_RANGE_END": 200,
    "PRIORITY_IPS": ["192.168.1.1"],  # उदाहरण: राउटर आदि, हमेशा स्कैन करने वाले IP
    "CHECK_SHARED_FOLDERS": True,
    "EXCEL_FILE": "improved_lan_monitor.xlsx",
    "PING_CONCURRENCY": 20,  # एक साथ Ping करने के लिए थ्रेड्स की संख्या
}

def append_event_log(ip, old_status, new_status, response_time, shared):
    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    file_exists = os.path.exists(CONFIG["EVENT_LOG_FILE"])
    try:
        with open(CONFIG["EVENT_LOG_FILE"], "a", newline="", encoding=CONFIG["CSV_ENCODING"]) as f:
            writer = csv.writer(f)
            if not file_exists:
                writer.writerow(["timestamp", "ip", "old_status", "new_status", "response_time_ms", "shared"])
            writer.writerow([now_str, ip, old_status, new_status, response_time, shared])
    except Exception as e:
        logging.error(f"IP {ip} के लिए घटना लॉग जोड़ने में विफलता: {e}")

def append_snapshot(devices, scan_mode):
    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    online = [d for d in devices if d["status"] == "ऑनलाइन"]
    offline = [d for d in devices if d["status"] == "ऑफलाइन"]

    total_online = len(online)
    total_offline = len(offline)
    online_ips_str = ",".join([d["ip"] for d in online])

    file_exists = os.path.exists(CONFIG["SNAPSHOT_LOG_FILE"])
    try:
        with open(CONFIG["SNAPSHOT_LOG_FILE"], "a", newline="", encoding=CONFIG["CSV_ENCODING"]) as f:
            writer = csv.writer(f)
            if not file_exists:
                writer.writerow(["timestamp", "total_online", "total_offline", "online_ips", "scan_mode"])
            writer.writerow([now_str, total_online, total_offline, online_ips_str, scan_mode])
    except Exception as e:
        logging.error(f"स्नैपशॉट लॉग जोड़ने में विफलता: {e}")

import pandas as pd
import matplotlib.pyplot as plt

# स्नैपशॉट डेटा लोड करें
df = pd.read_csv('snapshot_log.csv')
df['timestamp'] = pd.to_datetime(df['timestamp'])

# ऑनलाइन डिवाइसों का ग्राफ
plt.figure(figsize=(12, 6))
plt.plot(df['timestamp'], df['total_online'], 'g-', label='ऑनलाइन डिवाइस')
plt.plot(df['timestamp'], df['total_offline'], 'r--', label='ऑफलाइन डिवाइस')
plt.xlabel('समय')
plt.ylabel('डिवाइस की संख्या')
plt.title('नेटवर्क डिवाइस की स्थिति समय के साथ')
plt.legend()
plt.grid(True)
plt.savefig('network_trend.png')

def scan_network(self, mode="regular"):
    # ...
    with self.lock:
        old_status = self.known_devices.get(ip, {}).get("status", "अज्ञात")
    # ...
    with self.lock:
        self.known_devices[ip] = dev_info
    # ...

import pandas as pd

# घटना लॉग विश्लेषण
events_df = pd.read_csv('event_log.csv')

# महीने के अनुसार स्थिति परिवर्तन की संख्या
events_df['timestamp'] = pd.to_datetime(events_df['timestamp'])
events_df['month'] = events_df['timestamp'].dt.month
monthly_status_changes = events_df.groupby(['month', 'ip']).size().reset_index(name='changes')

# अस्थिर डिवाइस (जो बार-बार ऑनलाइन/ऑफलाइन होते हैं)
unstable_devices = events_df.groupby('ip').size().reset_index(name='status_changes')
problematic = unstable_devices[unstable_devices['status_changes'] > 10]  # दिन में 10 से अधिक परिवर्तन

# स्नैपशॉट से समय के अनुसार नेटवर्क उपयोग पैटर्न
snapshots_df = pd.read_csv('snapshot_log.csv')
snapshots_df['timestamp'] = pd.to_datetime(snapshots_df['timestamp'])
snapshots_df['hour'] = snapshots_df['timestamp'].dt.hour

# घंटे के अनुसार औसत ऑनलाइन डिवाइस
hourly_pattern = snapshots_df.groupby('hour')['total_online'].mean()

def __init__(self):
    self.config = load_config()
    self.excel_file = self.config["excel_file"]
    self.refresh_interval = self.config["refresh_interval"]
    self.full_scan_interval = self.config["full_scan_interval"]
    self.dhcp_range_start = self.config["dhcp_range_start"]
    self.dhcp_range_end = self.config["dhcp_range_end"]
    self.priority_ips = set(self.config["priority_ips"])
    self.check_shared_folders = self.config["check_shared_folders"]

def load_config():
    """
    कॉन्फिगरेशन लोड करता है। त्रुटि होने पर डिफॉल्ट मान का उपयोग करता है।
    """
    config = {
        "excel_file": "improved_lan_monitor.xlsx",    # यहां बदलें
        "refresh_interval": 30,                       # यहां बदलें (सेकंड में)
        "full_scan_interval": 600,                    # यहां बदलें (सेकंड में)
        "dhcp_range_start": 100,                      # यहां बदलें
        "dhcp_range_end": 200,                        # यहां बदलें
        "priority_ips": [],                           # यहां बदलें (उदाहरण: ["192.168.1.1", "192.168.1.5"])
        "check_shared_folders": True                  # यहां बदलें (True/False)
    }
    # ...बाकी कोड समान

{
  "excel_file": "network_monitor.xlsx",
  "refresh_interval": 60,
  "full_scan_interval": 1800,
  "dhcp_range_start": 50,
  "dhcp_range_end": 150,
  "priority_ips": ["192.168.1.1", "192.168.1.100"],
  "check_shared_folders": false
}

"dhcp_range_start": 50,
"dhcp_range_end": 150,
"priority_ips": ["192.168.1.1", "192.168.1.10", "192.168.1.20"],

@echo off
cd C:\lan
call venv\Scripts\activate
start pythonw realtime_lan_monitor.py --run
timeout /t 5
start pythonw -m streamlit run app.py

NETWORKS = [
    {"name": "मुख्य कार्यालय", "range": "192.168.1.0/24", "priority": ["192.168.1.1", "192.168.1.10"]},
    {"name": "विकास टीम", "range": "192.168.2.0/24", "priority": ["192.168.2.1", "192.168.2.5"]},
    {"name": "वित्त विभाग", "range": "192.168.3.0/24", "priority": ["192.168.3.1"]}
]

logging.basicConfig(
    filename='lan_monitor.log',
    level=logging.WARNING,  # INFO → WARNING में बदलें
    format='%(asctime)s [%(levelname)s] %(message)s',
    encoding='utf-8'
)

def send_notification(device):
    # स्लैक या ईमेल के माध्यम से सूचित करने की प्रक्रिया
    if device["status"] == "ऑफलाइन" and device["device_type"] == "सर्वर":
        send_alert_email(
            subject=f"सर्वर डाउन अलर्ट: {device['ip']}",
            body=f"सर्वर {device['hostname']} ({device['ip']}) {device['last_seen']} के बाद से ऑफलाइन है।"
        )

def save_statistics(devices):
    # डेटाबेस में रिकॉर्ड करें
    conn = sqlite3.connect('network_stats.db')
    cursor = conn.cursor()
    for device in devices:
        if device["status"] == "ऑनलाइन":
            cursor.execute(
                "INSERT INTO device_history (ip, hostname, timestamp, response_time) VALUES (?, ?, ?, ?)",
                (device["ip"], device["hostname"], datetime.now(), device["response_time_ms"])
            )
    conn.commit()
    conn.close()

def detect_suspicious_devices(devices):
    # ज्ञात डिवाइसों की सूची से तुलना करें
    known_devices = load_known_devices_list()
    unknown_devices = []
    
    for device in devices:
        if device["status"] == "ऑनलाइन" and device["ip"] not in known_devices:
            unknown_devices.append(device)
            logging.warning(f"अज्ञात डिवाइस पाया गया: {device['ip']} ({device['hostname']})")
    
    # अज्ञात डिवाइस मिलने पर अलर्ट
    if unknown_devices:
        send_security_alert(unknown_devices)

def check_internet_connection():
    # बाहरी सर्वर के साथ कनेक्शन टेस्ट करें
    external_hosts = ["8.8.8.8", "1.1.1.1", "google.com"]
    
    for host in external_hosts:
        try:
            result = subprocess.run(["ping", "-c", "1", host], 
                                  stdout=subprocess.PIPE, 
                                  stderr=subprocess.PIPE,
                                  timeout=2)
            if result.returncode == 0:
                return True
        except:
            continue
    
    # सभी होस्ट फेल होने पर
    logging.error("इंटरनेट कनेक्शन डाउन है!")
    send_notification("इंटरनेट कनेक्शन निगरानी", "नेटवर्क का इंटरनेट कनेक्शन वर्तमान में अनुपलब्ध है।")
    return False

def rotate_log_files():
    """पुरानी लॉग फ़ाइलों को आर्काइव करता है"""
    today = datetime.now().strftime("%Y-%m-%d")
    
    for log_file in [CONFIG["EVENT_LOG_FILE"], CONFIG["SNAPSHOT_LOG_FILE"]]:
        if os.path.exists(log_file) and os.path.getsize(log_file) > 1024 * 1024:  # 1MB से बड़ी
            archive_name = f"{os.path.splitext(log_file)[0]}_{today}.csv"
            try:
                shutil.copy(log_file, archive_name)
                # फ़ाइल को खाली करें पर हेडर रखें
                with open(log_file, 'r', encoding=CONFIG["CSV_ENCODING"]) as src:
                    header = src.readline()
                with open(log_file, 'w', encoding=CONFIG["CSV_ENCODING"]) as dest:
                    dest.write(header)
                logging.info(f"लॉग फ़ाइल रोटेट की गई: {archive_name}")
            except Exception as e:
                logging.error(f"फ़ाइल रोटेशन त्रुटि: {e}")

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta

def generate_network_health_report(output_file="network_report.html"):
    """संपूर्ण नेटवर्क स्वास्थ्य रिपोर्ट उत्पन्न करता है"""
    
    # डेटा लोड करें
    events_df = pd.read_csv(CONFIG["EVENT_LOG_FILE"])
    snapshots_df = pd.read_csv(CONFIG["SNAPSHOT_LOG_FILE"])
    
    # तिथि स्तंभों को सही प्रारूप में परिवर्तित करें
    events_df['timestamp'] = pd.to_datetime(events_df['timestamp'])
    snapshots_df['timestamp'] = pd.to_datetime(snapshots_df['timestamp'])
    
    # आज की तारीख़ प्राप्त करें और कल के लिए फ़िल्टर बनाएँ
    today = datetime.now().date()
    yesterday = today - timedelta(days=1)
    today_filter = events_df['timestamp'].dt.date == today
    yesterday_filter = events_df['timestamp'].dt.date == yesterday
    
    # आधारभूत स्थिरता मेट्रिक्स गणना
    total_devices = len(events_df['ip'].unique())
    stability_score = calculate_network_stability(events_df)
    
    # रिपोर्ट जेनरेट करें
    with open(output_file, 'w') as f:
        f.write("<html><head><title>नेटवर्क स्वास्थ्य रिपोर्ट</title></head><body>")
        f.write(f"<h1>नेटवर्क स्वास्थ्य रिपोर्ट - {today}</h1>")
        
        # सारांश अनुभाग
        f.write("<h2>सारांश</h2>")
        f.write(f"<p>कुल ट्रैक किए गए डिवाइस: {total_devices}</p>")
        f.write(f"<p>नेटवर्क स्थिरता स्कोर: {stability_score:.2f}%</p>")
        
        # ... अधिक रिपोर्ट विवरण ...
        
        f.write("</body></html>")
    
    # विज़ुअलाइज़ेशन भी उत्पन्न करें
    generate_visualizations(events_df, snapshots_df)
    
    return output_file

def get_hostname(ip_address, force_lookup=False):
    """IP पते से होस्टनेम प्राप्त करता है, कैशिंग के साथ"""
    if not force_lookup and ip_address in self.hostname_cache:
        return self.hostname_cache[ip_address]
        
    try:
        socket.setdefaulttimeout(1)
        hostname = socket.getfqdn(ip_address)
        if hostname == ip_address:
            hostname = "अज्ञात"
        self.hostname_cache[ip_address] = hostname
        return hostname
    except:
        return "अज्ञात"

def batch_append_events(events, batch_size=50):
    """कई घटनाओं को एक ही बार में अपेंड करें"""
    if not events:
        return
        
    try:
        file_exists = os.path.exists(CONFIG["EVENT_LOG_FILE"])
        with open(CONFIG["EVENT_LOG_FILE"], "a", newline="", encoding=CONFIG["CSV_ENCODING"]) as f:
            writer = csv.writer(f)
            
            if not file_exists:
                writer.writerow(["timestamp", "ip", "old_status", "new_status", "response_time_ms", "shared"])
                
            # सभी घटनाओं को एक साथ लिखें
            writer.writerows(events)
    except Exception as e:
        logging.error(f"बैच इवेंट अपेंड त्रुटि: {e}")

def adaptive_scan_scheduling(self):
    """नेटवर्क की स्थिति के आधार पर स्कैन आवृत्ति को अनुकूलित करता है"""
    
    # ऑनलाइन डिवाइसों की संख्या और उपयोग पैटर्न के आधार पर आवृत्ति निर्धारित करें
    online_percentage = len(self.active_ips) / max(len(self.known_devices), 1) * 100
    
    if online_percentage < 20:  # अधिकांश डिवाइस ऑफलाइन हैं
        return max(self.refresh_interval / 2, 15)  # अधिक बार जांचें, लेकिन कम से कम 15 सेकंड
    elif online_percentage > 90:  # अधिकांश डिवाइस ऑनलाइन हैं
        return min(self.refresh_interval * 1.5, 60)  # कम बार जांचें, अधिकतम 60 सेकंड
    else:
        return self.refresh_interval  # सामान्य आवृत्ति का उपयोग करें

def generate_availability_report(days=7):
    """अंतिम N दिनों के लिए डिवाइस उपलब्धता रिपोर्ट उत्पन्न करता है"""
    # इवेंट लॉग से डेटा लोड करें
    events_df = pd.read_csv(CONFIG["EVENT_LOG_FILE"])
    events_df['timestamp'] = pd.to_datetime(events_df['timestamp'])
    
    # समय सीमा निर्धारित करें
    end_date = datetime.now()
    start_date = end_date - timedelta(days=days)
    mask = (events_df['timestamp'] >= start_date) & (events_df['timestamp'] <= end_date)
    recent_events = events_df.loc[mask]
    
    # प्रत्येक डिवाइस के लिए अपटाइम कैलकुलेट करें
    device_stats = {}
    
    for ip in recent_events['ip'].unique():
        device_events = recent_events[recent_events['ip'] == ip].sort_values('timestamp')
        
        # समय अवधि की गणना करें
        uptime_minutes = 0
        last_online_time = None
        
        for _, row in device_events.iterrows():
            if row['new_status'] == 'ऑनलाइन':
                last_online_time = row['timestamp']
            elif row['new_status'] == 'ऑफलाइन' and last_online_time is not None:
                uptime_minutes += (row['timestamp'] - last_online_time).total_seconds() / 60
                last_online_time = None
                
        # अभी भी ऑनलाइन डिवाइसों के लिए अंतिम पॉइंट जोड़ें
        if last_online_time is not None:
            uptime_minutes += (end_date - last_online_time).total_seconds() / 60
            
        # कुल अवधि की गणना करें
        total_minutes = (end_date - start_date).total_seconds() / 60
        uptime_percentage = min(uptime_minutes / total_minutes * 100, 100) if total_minutes > 0 else 0
        
        # प्रतिक्रिया समय का औसत
        avg_response = device_events[device_events['response_time_ms'].notna()]['response_time_ms'].mean()
        
        device_stats[ip] = {
            'उपलब्धता_प्रतिशत': round(uptime_percentage, 2),
            'औसत_प्रतिक्रिया_ms': round(avg_response, 2) if not pd.isna(avg_response) else None,
            'स्थिति_परिवर्तन': len(device_events)
        }
    
    # डेटाफ्रेम में परिवर्तित करें और वापस करें
    result_df = pd.DataFrame.from_dict(device_stats, orient='index')
    result_df.index.name = 'ip'
    result_df.reset_index(inplace=True)
    
    return result_df

def log_security_event(event_type, details, severity="मध्यम"):
    """सुरक्षा संबंधित घटनाओं को लॉग करता है"""
    now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    security_log_file = "security_events.csv"
    file_exists = os.path.exists(security_log_file)
    
    try:
        with open(security_log_file, "a", newline="", encoding=CONFIG["CSV_ENCODING"]) as f:
            writer = csv.writer(f)
            if not file_exists:
                writer.writerow(["timestamp", "event_type", "severity", "details"])
            writer.writerow([now_str, event_type, severity, details])
            
        # गंभीर घटनाओं के लिए तुरंत अलर्ट भेजें
        if severity == "उच्च":
            send_security_alert(event_type, details)
    except Exception as e:
        logging.error(f"सुरक्षा घटना लॉगिंग त्रुटि: {e}")