lanscape 1.2.10a1__py3-none-any.whl → 1.3.0a1__py3-none-any.whl

lanscape/libraries/errors.py

@@ -10,3 +10,20 @@ class SubnetTooLargeError(Exception):
 class SubnetScanTerminationFailure(Exception):
     def __init__(self,running_threads):
         super().__init__(f'Unable to terminate active threads: {running_threads}')
+
+class DeviceError(Exception):
+    def __init__(self, e:Exception):
+        self.base: Exception = e
+        self.method = self._attempt_extract_method()
+    
+    def _attempt_extract_method(self):
+        try:
+            tb = self.base.__traceback__
+            frame = tb.tb_frame
+            return frame.f_code.co_name
+        except Exception as e:
+            print(e)
+            return 'unknown'
+        
+    def __str__(self):
+        return f'Error(source={self.method}, msg={self.base})'

lanscape/libraries/logger.py

@@ -3,7 +3,7 @@ from logging.handlers import RotatingFileHandler
 import click
 
 
-def configure_logging(loglevel:str, logfile:bool):
+def configure_logging(loglevel:str, logfile:bool, flask_logging:bool=False) -> None:
     numeric_level = getattr(logging, loglevel.upper(), None)
     if not isinstance(numeric_level, int):
         raise ValueError(f'Invalid log level: {loglevel}')
@@ -12,7 +12,7 @@ def configure_logging(loglevel:str, logfile:bool):
     logging.basicConfig(level=numeric_level, format='[%(name)s] %(levelname)s - %(message)s')
 
     # flask spams too much on info
-    if numeric_level > logging.DEBUG:
+    if not flask_logging:
         disable_flask_logging()
     
     if logfile:

lanscape/libraries/net_tools.py

@@ -10,58 +10,86 @@ import subprocess
 from time import sleep
 from typing import List, Dict
 from scapy.all import ARP, Ether, srp
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from .service_scan import scan_service
 from .mac_lookup import lookup_mac, get_macs
 from .ip_parser import get_address_count, MAX_IPS_ALLOWED
+from .errors import DeviceError
 
 log = logging.getLogger('NetTools')
 
 
 class IPAlive:
-    
-    def is_alive(self,ip:str) -> bool:
-        try:
-            self.alive = self._arp_lookup(ip)
-        except:
-            self.log.debug('failed ARP, falling back to ping')
-            self.alive = self._ping_lookup(ip)
-
-        return self.alive
-
-    def _arp_lookup(self,ip,timeout=4):
-        arp_request = ARP(pdst=ip)
-        broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")
-        arp_request_broadcast = broadcast / arp_request
+    caught_errors: List[DeviceError] = []
 
-        # Send the packet and receive the response
-        answered, _ = srp(arp_request_broadcast, timeout=timeout, verbose=False)
-
-        for sent, received in answered:
-            if received.psrc == ip:
-                return True
+    def is_alive(self, ip: str) -> bool:
+        """
+        Run ARP and ping in parallel. As soon as one returns True, we shut
+        down the executor (without waiting) and return True. Exceptions
+        from either lookup are caught and treated as False.
+        """
+        executor = ThreadPoolExecutor(max_workers=2)
+        futures = [
+            executor.submit(self._arp_lookup,  ip),
+            executor.submit(self._ping_lookup, ip),
+        ]
+
+        for future in as_completed(futures):
+            try:
+                if future.result():
+                    # one check succeeded — don’t block on the other
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    return True
+            except Exception as e:
+                # treat any error as a False response
+                self.caught_errors.append(DeviceError(e))
+                pass
+
+        # neither check found the host alive
+        executor.shutdown()
         return False
 
-    def _ping_lookup(self,host, retries=1, retry_delay=1, ping_count=2, timeout=2):
-            """
-            Ping the given host and return True if it's reachable, False otherwise.
-            """
-            os = platform.system().lower()
-            if os == "windows":
-                ping_command = ['ping', '-n', str(ping_count), '-w', str(timeout*1000)]  
-            else:
-                ping_command = ['ping', '-c', str(ping_count), '-W', str(timeout)]
-                
-            for _ in range(retries):
-                try:
-                    output = subprocess.check_output(ping_command + [host], stderr=subprocess.STDOUT, universal_newlines=True)
-                    # Check if 'TTL' or 'time' is in the output to determine success
-                    if 'TTL' in output.upper():
-                        return True
-                except subprocess.CalledProcessError:
-                    pass  # Ping failed
+    def _arp_lookup(self, ip: str, timeout: int = 3) -> bool:
+        arp_request = ARP(pdst=ip)
+        broadcast   = Ether(dst="ff:ff:ff:ff:ff:ff")
+        packet      = broadcast / arp_request
+
+        answered, _ = srp(packet, timeout=timeout, verbose=False)
+        return any(resp.psrc == ip for _, resp in answered)
+
+    def _ping_lookup(
+        self, host: str,
+        retries: int = 1,
+        retry_delay: int = .25,
+        ping_count: int = 2,
+        timeout: int = 2
+    ) -> bool:
+        cmd = []
+        os_name = platform.system().lower()
+        if os_name == "windows":
+            # -n count, -w timeout in ms
+            cmd = ['ping', '-n', str(ping_count), '-w', str(timeout*1000)]
+        else:
+            # -c count, -W timeout in s
+            cmd = ['ping', '-c', str(ping_count), '-W', str(timeout)]
+
+        for r in range(retries):
+            try:
+                output = subprocess.check_output(
+                    cmd + [host],
+                    stderr=subprocess.STDOUT,
+                    universal_newlines=True
+                )
+                # Windows/Linux both include “TTL” on a successful reply
+                if 'TTL' in output.upper():
+                    return True
+            except subprocess.CalledProcessError as e:
+                self.caught_errors.append(DeviceError(e))
+                pass
+            if r < retries - 1:
                 sleep(retry_delay)
-            return False
+        return False
     
 
 
@@ -75,6 +103,7 @@ class Device(IPAlive):
         self.ports: List[int] = []
         self.stage: str = 'found'
         self.services: Dict[str,List[int]] = {}
+        self.caught_errors: List[DeviceError] = []
         self.log = logging.getLogger('Device')
 
     def get_metadata(self):
@@ -128,7 +157,8 @@ class Device(IPAlive):
         try:
             hostname = socket.gethostbyaddr(self.ip)[0]
             return hostname
-        except socket.herror:
+        except socket.herror as e:
+            self.caught_errors.append(DeviceError(e))
             return None
         
     def _get_manufacturer(self,mac_addr=None):

lanscape/libraries/runtime_args.py

@@ -9,6 +9,7 @@ class RuntimeArgs:
     port: int = 5001
     logfile: bool = False
     loglevel: str = 'INFO'
+    flask_logging: bool = False
 
 def parse_args() -> RuntimeArgs:
     parser = argparse.ArgumentParser(description='LANscape')
@@ -17,6 +18,7 @@ def parse_args() -> RuntimeArgs:
     parser.add_argument('--port', type=int, default=5001, help='Port to run the webserver on')
     parser.add_argument('--logfile', action='store_true', help='Log output to lanscape.log')
     parser.add_argument('--loglevel', default='INFO', help='Set the log level')
+    parser.add_argument('--flask-logging', action='store_true', help='Enable flask logging (disables click output)')
 
     # Parse the arguments
     args = parser.parse_args()

lanscape/libraries/subnet_scan.py

@@ -10,7 +10,7 @@ from time import sleep
 from typing import List, Union
 from tabulate import tabulate
 from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from .net_tools import Device
 from .ip_parser import parse_ip_input
@@ -57,6 +57,9 @@ class ScanConfig:
     
     def parse_subnet(self) -> List[ipaddress.IPv4Network]:
         return parse_ip_input(self.subnet)
+    
+    def __str__(self):
+        return f'ScanCfg(subnet={self.subnet}, ports={self.port_list}, multiplier={self.t_multiplier})'
 
 
 
@@ -91,7 +94,7 @@ class SubnetScanner:
         self.running = True
         with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('isalive')) as executor:
             futures = {executor.submit(self._get_host_details, str(ip)): str(ip) for ip in self.subnet}
-            for future in futures:
+            for future in as_completed(futures):
                 ip = futures[future]
                 try:
                     future.result()
@@ -183,12 +186,11 @@ class SubnetScanner:
         Get the MAC address and open ports of the given host.
         """
         device = Device(host)
-        is_alive = self._ping(device)
+        device.alive = self._ping(device)
         self.results.scanned()
-        if not is_alive:
+        if not device.alive:
             return None
         self.log.debug(f'[{host}] is alive, getting metadata')
-        
         device.get_metadata()
         self.results.devices.append(device)
         return True
@@ -290,7 +292,7 @@ class ScannerResults:
         out['devices'] = [device.dict() for device in sortedDevices]
 
         if out_type == str:
-            return json.dumps(out, indent=2)
+            return json.dumps(out,default=str, indent=2)
         # otherwise return dict
         return out
     
@@ -317,44 +319,53 @@ class ScannerResults:
 class ScanManager:
     """
     Maintain active and completed scans in memory for 
-    future reference
+    future reference. Singleton implementation.
     """
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(ScanManager, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
     def __init__(self):
-        self.scans: List[SubnetScanner] = []
+        if not hasattr(self, 'scans'):  # Prevent reinitialization
+            self.scans: List[SubnetScanner] = []
+            self.log = logging.getLogger('ScanManager')
 
     def new_scan(self, config: ScanConfig) -> SubnetScanner:
         scan = SubnetScanner(config)
         self._start(scan)
+        self.log.info(f'Scan started - {config}')
         self.scans.append(scan)
         return scan
 
-    def get_scan(self,scan_id:str) -> SubnetScanner:
+    def get_scan(self, scan_id: str) -> SubnetScanner:
         """
         Get scan by scan.uid
         """
         for scan in self.scans:
             if scan.uid == scan_id:
                 return scan
-            
+
     def terminate_scans(self):
         """
-        terminate all active scans
+        Terminate all active scans
         """
         for scan in self.scans:
             if scan.running:
                 scan.terminate()
 
-    def wait_until_complete(self,scan_id:str) -> SubnetScanner:
+    def wait_until_complete(self, scan_id: str) -> SubnetScanner:
         scan = self.get_scan(scan_id)
         while scan.running:
             sleep(.5)
         return scan
 
-    def _start(self,scan:SubnetScanner):
+    def _start(self, scan: SubnetScanner):
         t = threading.Thread(target=scan.start)
         t.start()
         return t
-    
 
 
     

lanscape/libraries/version_manager.py

@@ -16,10 +16,14 @@ latest = None # used to 'remember' pypi version each runtime
 def is_update_available(package=PACKAGE) -> bool:
     installed = get_installed_version(package)
     available = lookup_latest_version(package)
-    if installed == LOCAL_VERSION: return False # local
-    if 'a' in installed: return False # alpha
-    if 'b' in installed: return False # beta
 
+    is_update_exempt = (
+        'a' in installed, 'b' in installed, # pre-release
+        installed == LOCAL_VERSION
+    )
+    if any(is_update_exempt): return False
+
+    log.debug(f'Installed: {installed} | Available: {available}')
     return installed != available
 
 def lookup_latest_version(package=PACKAGE):

lanscape/libraries/web_browser.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Get the executable path of the system’s default web browser.
+
+Supports:
+  - Windows (reads from the registry)
+  - Linux   (uses xdg-mime / xdg-settings + .desktop file parsing)
+"""
+
+import sys
+import os
+import subprocess
+import webbrowser
+import logging
+import re
+import time
+import traceback
+from ..ui.app import app
+
+log = logging.getLogger('WebBrowser')
+
+
+def open_webapp(url: str) -> bool:
+    """
+    will try to open the web page as an app
+    on failure, will open as a tab in default browser
+
+    returns: 
+    """
+    start = time.time()
+    try:
+        exe = get_default_browser_executable()
+        if not exe:
+            raise RuntimeError('Unable to find browser binary')
+        
+        #this is blocking until closed
+        subprocess.run(f'{exe} --app="{url}"')
+        if time.time() - start < 2:
+            log.debug(f'Unable to hook into closure of UI, listening for flask shutdown')
+            return False
+        return True
+        
+    except Exception as e:
+        log.warning('Failed to open webpage as app, falling back to browser tab')
+        log.debug(e)
+        webbrowser.open(url, new=2)
+    return False
+    
+
+def get_default_browser_executable() -> str | None:
+    if sys.platform.startswith("win"):
+        try:
+            import winreg
+            # On Windows the HKEY_CLASSES_ROOT\http\shell\open\command key
+            # holds the command for opening HTTP URLs.
+            with winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"http\shell\open\command") as key:
+                cmd, _ = winreg.QueryValueEx(key, None)
+        except Exception:
+            return None
+
+        # cmd usually looks like: '"C:\\Program Files\\Foo\\foo.exe" %1'
+        m = re.match(r'\"?(.+?\.exe)\"?', cmd)
+        return m.group(1) if m else None
+
+    elif sys.platform.startswith("linux"):
+        # First, find the .desktop file name
+        desktop_file = None
+        try:
+            # Try xdg-mime
+            p = subprocess.run(
+                ["xdg-mime", "query", "default", "x-scheme-handler/http"],
+                capture_output=True, text=True,
+                check=True
+            )
+            desktop_file = p.stdout.strip()
+        except subprocess.CalledProcessError:
+            pass
+
+        if not desktop_file:
+            # Fallback to xdg-settings
+            try:
+                p = subprocess.run(
+                    ["xdg-settings", "get", "default-web-browser"],
+                    capture_output=True, text=True,
+                    check=True
+                )
+                desktop_file = p.stdout.strip()
+            except subprocess.CalledProcessError:
+                pass
+
+        # Final fallback: BROWSER environment variable
+        if not desktop_file:
+            return os.environ.get("BROWSER")
+
+        # Look for that .desktop file in standard locations
+        search_paths = [
+            os.path.expanduser("~/.local/share/applications"),
+            "/usr/local/share/applications",
+            "/usr/share/applications",
+        ]
+        for path in search_paths:
+            full_path = os.path.join(path, desktop_file)
+            if os.path.isfile(full_path):
+                with open(full_path, encoding="utf-8", errors="ignore") as f:
+                    for line in f:
+                        if line.startswith("Exec="):
+                            exec_cmd = line[len("Exec="):].strip()
+                            # strip arguments like “%u”, “--flag”, etc.
+                            exec_cmd = exec_cmd.split()[0]
+                            exec_cmd = exec_cmd.split("%")[0]
+                            return exec_cmd
+        return None
+
+    else:
+        raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")

lanscape/tests/test_api.py

@@ -3,6 +3,7 @@ import json
 from ..ui.app import app
 from ..libraries.net_tools import get_network_subnet
 from ._helpers import right_size_subnet
+import time
 
 
 
@@ -89,6 +90,7 @@ class ApiTestCase(unittest.TestCase):
         ]
         for uri in uris:
             response = self.app.get(uri)
+            print(uri, response.status_code)
             self.assertEqual(response.status_code,200)
 
 
@@ -143,7 +145,47 @@ class ApiTestCase(unittest.TestCase):
             self.assertIsNotNone(data.get('msg'))
             if count == -1:
                 self.assertFalse(data.get('valid'))
-            
+    
+    def test_scan_api(self):
+        """
+        Test the scan API endpoints
+        """
+        # Create a new scan
+        new_scan = {
+            'subnet': right_size_subnet(get_network_subnet()),
+            'port_list': 'small',
+            'parallelism': 1
+        }
+        response = self.app.post('/api/scan', json=new_scan)
+        self.assertEqual(response.status_code, 200)
+        scan_info = json.loads(response.data)
+        self.assertEqual(scan_info['status'], 'running')
+        scan_id = scan_info['scan_id']
+        self.assertIsNotNone(scan_id)
+
+        percent_complete = 0
+        while percent_complete < 100:
+            # Get scan summary
+            response = self.app.get(f'/api/scan/{scan_id}/summary')
+            self.assertEqual(response.status_code, 200)
+            summary = json.loads(response.data)
+            self.assertTrue(summary['running'] or summary['stage'] == 'complete')
+            percent_complete = summary['percent_complete']
+            self.assertGreaterEqual(percent_complete, 0)
+            self.assertLessEqual(percent_complete, 100)
+            # Wait for a bit before checking again
+            time.sleep(2)
+        
+        self.assertEqual(summary['running'], False)
+        self.assertEqual(summary['stage'], 'complete')
+        self.assertGreater(summary['runtime'], 0)
+
+        devices_alive = summary['devices']['alive']
+        devices_scanned = summary['devices']['scanned']
+        devices_total = summary['devices']['total']
+
+        self.assertEqual(devices_scanned, devices_total)
+        self.assertGreater(devices_alive, 0)
 
 
 

lanscape/ui/app.py

@@ -13,7 +13,7 @@ from ..libraries.app_scope import is_local_run
 app = Flask(
     __name__
 )
-log = logging.getLogger('core')
+log = logging.getLogger('flask')
 
 ## Import and register BPs
 ################################
@@ -89,12 +89,12 @@ def internal_error(e):
 ## Webserver creation functions
 ################################
 
-def start_webserver_dameon(args: RuntimeArgs) -> multiprocessing.Process:
+def start_webserver_dameon(args: RuntimeArgs) -> threading.Thread:
     proc = threading.Thread(target=start_webserver, args=(args,))
     proc.daemon = True # Kill thread when main thread exits
     proc.start()
     log.info('Flask server initializing as dameon')
-    sleep(2)
+    return proc
 
 def start_webserver(args: RuntimeArgs) -> int:
     run_args = {
@@ -103,10 +103,7 @@ def start_webserver(args: RuntimeArgs) -> int:
         'debug':args.reloader,
         'use_reloader':args.reloader
     }
-
     app.run(**run_args)
 
-if __name__ == "__main__":
-    start_webserver(True)
 
 

lanscape/ui/blueprints/api/scan.py

@@ -3,6 +3,7 @@ from ....libraries.subnet_scan import ScanConfig
 from .. import scan_manager
 
 from flask import request, jsonify
+import json
 import traceback
 
 # Subnet Scanner API
@@ -30,7 +31,8 @@ def scan_subnet_async():
 @api_bp.route('/api/scan/<scan_id>', methods=['GET'])
 def get_scan(scan_id):
     scan = scan_manager.get_scan(scan_id)
-    return jsonify(scan.results.export())
+    # cast to str and back to handle custom JSON serialization
+    return jsonify(json.loads(scan.results.export(str)))
 
 @api_bp.route('/api/scan/<scan_id>/summary',methods=['GET'])
 def get_scan_summary(scan_id):

lanscape/ui/blueprints/web/routes.py

@@ -16,47 +16,54 @@ def index():
     subnet = smart_select_primary_subnet(subnets)
     
     port_list = 'medium'
-    parallelism = 0.7
+    parallelism = 1
     if scan_id := request.args.get('scan_id'): 
-        if scanner := scan_manager.get_scan(scan_id):
-            scan = scanner.results.export()
-            subnet = scan['subnet']
-            port_list = scan['port_list']
-            parallelism = scan['cfg']['t_multiplier']
+        if scan := scan_manager.get_scan(scan_id):
+            subnet = scan.cfg.subnet
+            port_list = scan.cfg.port_list
+            parallelism = scan.cfg.t_multiplier
+            
         else:
             log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
             return redirect('/')
     return render_template(
-        'main.html',
-        subnet=subnet, 
-        port_list=port_list, 
-        parallelism=parallelism,
-        alternate_subnets=subnets
-    )
+            'main.html',
+            subnet=subnet, 
+            port_list=port_list, 
+            parallelism=parallelism,
+            alternate_subnets=subnets
+        )
+    
 
 @web_bp.route('/scan/<scan_id>', methods=['GET'])
 @web_bp.route('/scan/<scan_id>/<section>', methods=['GET'])
 def render_scan(scan_id, section='all'):
-    scanner = scan_manager.get_scan(scan_id)
-    data = scanner.results.export()
-    filter = request.args.get('filter')
-    return render_template('scan.html', data=data, section=section, filter=filter)
+    if scanner := scan_manager.get_scan(scan_id):
+        data = scanner.results.export()
+        filter = request.args.get('filter')
+        return render_template('scan.html', data=data, section=section, filter=filter)
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
 
 @web_bp.route('/errors/<scan_id>')
 def view_errors(scan_id):
-    scanner = scan_manager.get_scan(scan_id)
-    data = scanner.results.export()
-    return render_template('scan/scan-error.html',data=data)
+    if scanner := scan_manager.get_scan(scan_id):
+        data = scanner.results.export()
+        return render_template('scan/scan-error.html',data=data)
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
 
 @web_bp.route('/export/<scan_id>')
 def export_scan(scan_id):
-    scanner = scan_manager.get_scan(scan_id)
-    export_json = scanner.results.export(str)
-    return render_template(
-        'scan/export.html',
-        scan=scanner,
-        export_json=export_json
-    )
+    if scanner := scan_manager.get_scan(scan_id):
+        export_json = scanner.results.export(str)
+        return render_template(
+            'scan/export.html',
+            scan=scanner,
+            export_json=export_json
+        )
+    log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
+    return redirect('/')
 
 @web_bp.route('/shutdown-ui')
 def shutdown_ui():

lanscape/ui/main.py

@@ -1,18 +1,18 @@
 
 import threading
-import webbrowser
 import time
 import logging
 import traceback
 import os
 from ..libraries.logger import configure_logging
 from ..libraries.runtime_args import parse_args, RuntimeArgs
+from ..libraries.web_browser import open_webapp
 # do this so any logs generated on import are displayed
 args = parse_args()
-configure_logging(args.loglevel, args.logfile)
+configure_logging(args.loglevel, args.logfile, args.flask_logging)
 
 from ..libraries.version_manager import get_installed_version, is_update_available
-from .app import start_webserver
+from .app import start_webserver_dameon, start_webserver
 import socket
 
 
@@ -22,9 +22,19 @@ log = logging.getLogger('core')
 IS_FLASK_RELOAD = os.environ.get("WERKZEUG_RUN_MAIN")
 
 
+def main():
+    try:
+        _main()
+    except KeyboardInterrupt:
+        log.info('Keyboard interrupt received, terminating...')
+        terminate()
+    except Exception as e:
+        log.critical(f'Unexpected error: {e}')
+        log.debug(traceback.format_exc())
+        terminate()
 
 
-def main():
+def _main():
     if not IS_FLASK_RELOAD:
         log.info(f'LANscape v{get_installed_version()}')
         try_check_update()
@@ -36,12 +46,11 @@ def main():
         
         
     try:
-        
-        no_gui(args)
-
+        start_webserver_ui(args)
         log.info('Exiting...')
-    except Exception:
+    except Exception as e:
         # showing error in debug only because this is handled gracefully
+        log.critical(f'Failed to start app. Error: {e}')
         log.debug('Failed to start. Traceback below')
         log.debug(traceback.format_exc())
 
@@ -57,31 +66,52 @@ def try_check_update():
         log.warning('Unable to check for updates.')
     
 
-def open_browser(url: str,wait=2):
+def open_browser(url: str, wait=2) -> bool:
     """
     Open a browser window to the specified
     url after waiting for the server to start
     """
-    def do_open():
-        try:
-            time.sleep(wait)
-            webbrowser.open(url, new=2)
-        except:
-            log.debug(traceback.format_exc())
-            log.info(f'Unable to open web browser, server running on {url}')
-
-    threading.Thread(target=do_open).start()
-
-def no_gui(args: RuntimeArgs):
-    # determine if it was reloaded by flask debug reloader
-    # if it was, dont open the browser again
-    if not IS_FLASK_RELOAD:
-        open_browser(f'http://127.0.0.1:{args.port}')
-        log.info(f'Flask started: http://127.0.0.1:{args.port}')
+    try:
+        time.sleep(wait)
+        log.info(f'Starting UI - http://127.0.0.1:{args.port}')
+        return open_webapp(url)
+        
+    except:
+        log.debug(traceback.format_exc())
+        log.info(f'Unable to open web browser, server running on {url}')
+    return False
+
+
+
+def start_webserver_ui(args: RuntimeArgs):
+    uri = f'http://127.0.0.1:{args.port}'
+
+    # running reloader requires flask to run in main thread
+    # this decouples UI from main process
+    if args.reloader:
+        # determine if it was reloaded by flask debug reloader
+        # if it was, dont open the browser again
+        log.info('Opening UI as daemon')
+        if not IS_FLASK_RELOAD:
+            threading.Thread(
+                target=open_browser, 
+                args=(uri,),
+                daemon=True
+            ).start()
+        start_webserver(args)
+    else: 
+        flask_thread = start_webserver_dameon(args)
+        app_closed = open_browser(uri)
+
+        # depending on env, open_browser may or
+        # may not be coupled with the closure of UI
+        # (if in browser tab, it's uncoupled)
+        if not app_closed:
+            # not doing a direct join so i can still 
+            # terminate the app with ctrl+c
+            while flask_thread.is_alive():
+                time.sleep(1)
     
-    start_webserver(
-        args
-    )
 
 def get_valid_port(port: int):
     """
@@ -93,6 +123,12 @@ def get_valid_port(port: int):
                 return port
             port += 1
 
+def terminate():
+    import requests
+    log.info('Attempting flask shutdown')
+    requests.get(f'http://127.0.0.1:{args.port}/shutdown')
+
+
+
 if __name__ == "__main__":
-    main()
-        
+    main()

lanscape/ui/static/css/style.css

@@ -670,7 +670,9 @@ html {
 
 #scan-devices-alive, 
 #scan-devices-scanned,
-#scan-devices-total {
+#scan-devices-total,
+#scan-run-time,
+#scan-remain-time {
     margin: 3px;
 }
 

lanscape/ui/static/js/main.js

@@ -187,10 +187,44 @@ function pollScanSummary(id) {
 }
 
 function updateOverviewUI(summary) {
-    $('#scan-devices-alive').text(summary.devices.alive);
-    $('#scan-devices-scanned').text(summary.devices.scanned);
-    $('#scan-devices-total').text(summary.devices.total);
-    $('#scan-run-time').text(summary.runtime);
+    // helper to turn a number of seconds into "MM:SS"
+    function formatMMSS(totalSeconds) {
+      const secs = Math.floor(totalSeconds);
+      const m = Math.floor(secs / 60);
+      const s = secs % 60;
+      // pad minutes and seconds to 2 digits
+      const mm = String(m).padStart(2, '0');
+      const ss = String(s).padStart(2, '0');
+      return `${mm}:${ss}`;
+    }
+  
+    const alive       = summary.devices.alive;
+    const scanned     = summary.devices.scanned;
+    const total       = summary.devices.total;
+  
+    // ensure we have a number of elapsed seconds
+    const runtimeSec  = parseFloat(summary.runtime) || 0;
+    const pctComplete = Number(summary.percent_complete) || 0;
+  
+    // compute remaining seconds correctly
+    const remainingSec = pctComplete > 0
+      ? (runtimeSec * (100 - pctComplete)) / pctComplete
+      : 0;
+  
+    // update everything…
+    $('#scan-devices-alive').text(alive);
+    $('#scan-devices-scanned').text(scanned);
+    $('#scan-devices-total').text(total);
+  
+    // …but format runtime and remaining as MM:SS
+    $('#scan-run-time').text(formatMMSS(runtimeSec));
+    if (pctComplete < 10) {
+        $('#scan-remain-time').text('??:??');
+    } else {
+        $('#scan-remain-time').text(formatMMSS(remainingSec));
+    }
+    
+  
     $('#scan-stage').text(summary.stage);
 }
 

lanscape/ui/templates/scan/overview.html

@@ -11,9 +11,10 @@
     </div>
     <div class="col-4">
         <div class="card text-white overview-card" id="runtime-card">
-            <div class="card-header text-center">Runtime</div>
+            <div class="card-header text-center">Runtime / Remain</div>
             <div class="card-body text-center">
-                <span id="scan-run-time"></span>s
+                <span id="scan-run-time"></span> / 
+                <span id="scan-remain-time"></span>
             </div>
         </div>
     </div>

{lanscape-1.2.10a1.dist-info → lanscape-1.3.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.2.10a1
+Version: 1.3.0a1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 Project-URL: Homepage, https://github.com/mdennis281/py-lanscape
@@ -36,7 +36,7 @@ python -m lanscape
  - `--reloader` essentially flask debug mode- good for local development (default: false)
  - `--logfile` save log output to lanscape.log
  - `--loglevel <level>` set the logger's log level (default: INFO)
- 
+ - `--flask-logging` turn on flask logging (default: false)
 
 Examples:
 ```shell

{lanscape-1.2.10a1.dist-info → lanscape-1.3.0a1.dist-info}/RECORD

@@ -2,16 +2,17 @@ lanscape/__init__.py,sha256=_8FoHQKR0s9B_stjs5e5CnytwbSK1JgNvE2kZBDrWbw,180
 lanscape/__main__.py,sha256=Im2Qc9AIScEvjRik_X4x63n0Rie67-myQbuIEU7I-Ac,129
 lanscape/libraries/app_scope.py,sha256=oPRrYIXOn914gF1DTVCDcy1d97hjReFlAxJNBjseBIo,2447
 lanscape/libraries/decorators.py,sha256=Birxor-ae-CQRlBVOyB5DggHnuMQR98IYZ1FVHdGZzE,2448
-lanscape/libraries/errors.py,sha256=zvfqvJbIUsUWsEmw6XmUWXZsktbVachGIkYOdo1nR8s,447
+lanscape/libraries/errors.py,sha256=DaercNEZD_tUuXF7KsNk3SD6AqAwT-S7fvzpEybVn08,964
 lanscape/libraries/ip_parser.py,sha256=ElXz3LU5CUYWqKOHEyrj5Y4Iv6OBtoSlbCcxhCsibfQ,2226
-lanscape/libraries/logger.py,sha256=hGbnj1cTGZT5elwdXUBVyLg_E2Pnocs2IfWumUkHj7M,1385
+lanscape/libraries/logger.py,sha256=doD8KKb4TNWDwVXc1VR7NK4UdharrAoRHl8vZnSAupI,1407
 lanscape/libraries/mac_lookup.py,sha256=-dRV0ygtjjh3JkgL3GTi_5-w7pcZ1oj4XVH4chjsmRs,2121
-lanscape/libraries/net_tools.py,sha256=dUuLsxS_ypi9joZjlkn0dfzxwtT__85gOUkBCXvKBXM,10436
+lanscape/libraries/net_tools.py,sha256=boiccYtpv3v37l239b9jQvYUBgz_ynm0W149ceVCSBU,11473
 lanscape/libraries/port_manager.py,sha256=fNext3FNfGnGYRZK9RhTEwQ2K0e0YmmMlhK4zVAvoCw,1977
-lanscape/libraries/runtime_args.py,sha256=JJTzWgQ-0aRh7Ce5efIwBmHZv1LfWjFagtNUNlLN7Uo,1660
+lanscape/libraries/runtime_args.py,sha256=zL8QB_Y69OBGjScytuuyHqdy2XimwpypMSPM3_etz7g,1811
 lanscape/libraries/service_scan.py,sha256=jLU84ZoJnqSQbE30Zly2lm2zHrCGutNXjla1sEvp1hE,1949
-lanscape/libraries/subnet_scan.py,sha256=qgyiOcnZt56gRS-Dn52Y4YL3KuqNEQ-BadrxgX3_AII,12542
-lanscape/libraries/version_manager.py,sha256=wdB5DPW8IjHJfgvT4mUKz7ndEV922WgVEqbwd6jfun4,1599
+lanscape/libraries/subnet_scan.py,sha256=0LW_xdoL-PRp59rJr6r6pSL3LiXEO_SJnjdrgEF_pO8,13120
+lanscape/libraries/version_manager.py,sha256=Mh8VptGmv03d0tCpS-DFVgsxD5qWMA8iIG1KVcWOp4A,1690
+lanscape/libraries/web_browser.py,sha256=xL2nGnqDTYJ1joMg2mT4uKX0Yq-4mI9svMjjrWyzkRg,3879
 lanscape/resources/mac_addresses/convert_csv.py,sha256=w3Heed5z2mHYDEZNBep3_hNg4dbrp_N6J54MGxnrq4s,721
 lanscape/resources/mac_addresses/mac_db.json,sha256=ygtFSwNwJzDlg6hmAujdgCyzUjxt9Di75J8SO4xYIs8,2187804
 lanscape/resources/ports/convert_csv.py,sha256=mWe8zucWVfnlNEx_ZzH5Vc3tJJbdi-Ih4nm2yKNrRN0,720
@@ -22,30 +23,30 @@ lanscape/resources/ports/small.json,sha256=Mj3zGVG1F2eqZx2YkrLpTL8STeLcqB8_65IR6
 lanscape/resources/services/definitions.jsonc,sha256=71w9Q7r4RoBYiIMkzzO2KdEJXaSIchNccYQueqAhD4E,8842
 lanscape/tests/__init__.py,sha256=xYPeceOF-ppTS0wnq7CkVYQMwupmeSHxbYLbGj_imZ0,113
 lanscape/tests/_helpers.py,sha256=wXJfUwzL3Fq4XBsC3dValCbXsf0U8FisuM_yo1de4QQ,371
-lanscape/tests/test_api.py,sha256=fIVIA6O9ssPRjofTHLS6z7XPNTkvv2rl2jDaxVCjFGU,5669
+lanscape/tests/test_api.py,sha256=881eHwSHT5GnOB61zbt3BRzCZnSwN2lndwCM5kIHLgo,7359
 lanscape/tests/test_env.py,sha256=ivFhCcemJ9vbe0_KtUkbqDY4r9nsDB8rVLUVjV-sNj8,673
 lanscape/tests/test_library.py,sha256=OPcTsUoR5IureSNDbePxid2BG98mfNNIJmCIY0BVz3w,1553
-lanscape/ui/app.py,sha256=hGmzoyH4YW2WmQsqZ6v-9r5DYzWi2KYP6_toZSxQqFg,3186
-lanscape/ui/main.py,sha256=HMQythH0fijX1Mt9fGQBcqmY37dQQ19ROC99JbCNAvs,2701
+lanscape/ui/app.py,sha256=Efa9gJnAcA_a3taCne9EHU4YxTCoRDd1M6UGa3rb2Qw,3126
+lanscape/ui/main.py,sha256=zDs7epDeXRoxZAHt9aLXB3kypXdZa1pSeqCIitwN7Ig,3998
 lanscape/ui/blueprints/__init__.py,sha256=agvgPOSVbrxddaw6EY64ZZr1CQi1Qzwcs1t0lZMv5oY,206
 lanscape/ui/blueprints/api/__init__.py,sha256=t0QOq3vHFWmlZm_3YFPQbQzCn1a_a5cmRchtIxwy4eY,103
 lanscape/ui/blueprints/api/port.py,sha256=2UA38umzXE8pMitx1E-_wJHyL1dYYbtM6Kg5zVtfj6A,1019
-lanscape/ui/blueprints/api/scan.py,sha256=ch4AcZ2nJLAXj0skHo3dMibpAIg4A_BSa2pZ0U782Wo,2137
+lanscape/ui/blueprints/api/scan.py,sha256=vNHH5XIVM8hWsHpkBX2okNFXWSFWz0E1RQuom8D-9TI,2229
 lanscape/ui/blueprints/api/tools.py,sha256=CD0NDSX8kN6_lpl0jEw-ULLsDx7pKODCMFQiaK4GCzM,1153
 lanscape/ui/blueprints/web/__init__.py,sha256=-WRjENG8D99NfaiSDk9uAa8OX6XJq9Zmq1ck29ARL-w,92
-lanscape/ui/blueprints/web/routes.py,sha256=Cd_XpDCSt02_K1hoJoegacA_eMhmqZdz0R0QMsZ2K0s,2174
+lanscape/ui/blueprints/web/routes.py,sha256=hl89T5_oRbTlA9Cde_xh9zAQDGRRH-Dpwm74B1_NM1Y,2511
 lanscape/ui/static/lanscape.webmanifest,sha256=0aauJk_Bybd0B2iwzJfvPcs7AX43kVHs0dtpV6_jSWk,459
-lanscape/ui/static/css/style.css,sha256=LbQ4O98uttwY2Msxv9XnniOTzZApGsqkFg8PCoe1ZcQ,15801
-lanscape/ui/static/img/ico/android-chrome-192x192.png,sha256=DxM2E9GjpKX-hSaSmAoW0GxLJ2fdXKJ-WOgoxYlDybw,24130
-lanscape/ui/static/img/ico/android-chrome-512x512.png,sha256=UoL_8UdhGU1q2_XkJ2T7QojgcNnz7FrBChlVRaMOWIs,73788
-lanscape/ui/static/img/ico/apple-touch-icon.png,sha256=Yhzhva3J_wjnC3zk2e7GXhEVNLozGVE_IjQkg4R5Ip4,21664
-lanscape/ui/static/img/ico/favicon-16x16.png,sha256=IRCDDp-lTndprI1-hMY8Cyg1OvJhOkzX73i5i246p50,808
-lanscape/ui/static/img/ico/favicon-32x32.png,sha256=pbG3WlLqIHHRGy-0JbsJ7ybBL6enl8NV79b_SybxiGg,2137
-lanscape/ui/static/img/ico/favicon.ico,sha256=2fKhUCOFv7vH_WwGPhemSHoJeIXQl0-iq8cJ0QBewng,15406
+lanscape/ui/static/css/style.css,sha256=ZoROzQmBIZlMdz0i9YHkx0Eomo87nQcDLJnGiiC0S3Y,15838
+lanscape/ui/static/img/ico/android-chrome-192x192.png,sha256=JmFT6KBCCuoyxMV-mLNtF9_QJbVBvfWPUizKN700fi8,18255
+lanscape/ui/static/img/ico/android-chrome-512x512.png,sha256=88Jjx_1-4XAnZYz64KP6FdTl_kYkNG2_kQIKteQwSh4,138055
+lanscape/ui/static/img/ico/apple-touch-icon.png,sha256=tEJlLwBZtF4v-NC90YCfRJQ2prTsF4i3VQLK_hnv2Mw,16523
+lanscape/ui/static/img/ico/favicon-16x16.png,sha256=HpQOZk3rziZjT1xQxKuy5WourXsfrdwuzQY1hChzBJQ,573
+lanscape/ui/static/img/ico/favicon-32x32.png,sha256=UpgiDPIHckK19udHtACiaI3ZPbmImUUcN1GcrjpEg9s,1302
+lanscape/ui/static/img/ico/favicon.ico,sha256=rs5vq0MPJ1LzzioOzOz5aQLVfrtS2nLRc920dOeReTw,15406
 lanscape/ui/static/img/ico/site.webmanifest,sha256=ep4Hzh9zhmiZF2At3Fp1dQrYQuYF_3ZPZxc1KcGBvwQ,263
 lanscape/ui/static/js/core.js,sha256=y-f8iQPIetllUY0lSCwnGbPCk5fTJbbU6Pxm3rw1EBU,1111
 lanscape/ui/static/js/layout-sizing.js,sha256=23UuKdEmRChg6fyqj3DRvcsNfMoa6MRt6dkaT0k7_UY,841
-lanscape/ui/static/js/main.js,sha256=qKy_dukRbn5t9qBiL1TNS3wyiH-F2sE6WtSSRjOprKw,6583
+lanscape/ui/static/js/main.js,sha256=s0ipGqmuuFHnH9KKoUVaDRJ10_YqYoJ-9r_YnbsH8Mw,7676
 lanscape/ui/static/js/quietReload.js,sha256=_mHzpUsGL4Lm1hNsr3VYSOGVcgGA2y1-eZHacssTXGs,724
 lanscape/ui/static/js/shutdown-server.js,sha256=WkO7_SNSHM_6kReUoCoExIdCf7Sl7IPiSiNxpbI-r0s,469
 lanscape/ui/static/js/subnet-info.js,sha256=aytt0LkBx4FVq36TxiMEw3aM7XQLHg_ng1U2WDwZVF4,577
@@ -61,10 +62,10 @@ lanscape/ui/templates/core/scripts.html,sha256=TRW74VUDasOTFYkaDhKKFnEwHyNx-_rmz
 lanscape/ui/templates/scan/export.html,sha256=Qi0m2xJPbC5I2rxzekXjvQ6q9gm2Lr4VJW6riLhIaU0,776
 lanscape/ui/templates/scan/ip-table-row.html,sha256=ptY24rxJRaA4PEEQRDncaq6Q0ql5RJ87Kn0zKRCzOHw,4842
 lanscape/ui/templates/scan/ip-table.html,sha256=ds__UP9JiTKf5IxCmTMzw--eN_yg1Pvn3Nj1KvQxeZg,940
-lanscape/ui/templates/scan/overview.html,sha256=Q0gmkVI-xNLZ-zWA9qm4H14cv_eF_bQs1KYPyAaoHLY,1141
+lanscape/ui/templates/scan/overview.html,sha256=FsX-jSFhGKwCxZGKE8AMKk328UuawN6O9RNTzYvIOts,1205
 lanscape/ui/templates/scan/scan-error.html,sha256=Q4eZM5ThrxnFaWOSTUpK8hA2ksHwhxOBTaVUCLALhyA,1032
-lanscape-1.2.10a1.dist-info/licenses/LICENSE,sha256=cCO-NbS01Ilwc6djHjZ7LIgPFRkRmWdr0fH2ysXKioA,1090
-lanscape-1.2.10a1.dist-info/METADATA,sha256=1bUCVjTGALGEVANjuWWfoMtfKFYcZ1XU-47bmYtdCx0,2063
-lanscape-1.2.10a1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-lanscape-1.2.10a1.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
-lanscape-1.2.10a1.dist-info/RECORD,,
+lanscape-1.3.0a1.dist-info/licenses/LICENSE,sha256=cCO-NbS01Ilwc6djHjZ7LIgPFRkRmWdr0fH2ysXKioA,1090
+lanscape-1.3.0a1.dist-info/METADATA,sha256=Vig-rxR7BRUlyBcpIJDeA4mPsS9HIIQHPoJIVOof5IA,2120
+lanscape-1.3.0a1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lanscape-1.3.0a1.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
+lanscape-1.3.0a1.dist-info/RECORD,,

{lanscape-1.2.10a1.dist-info → lanscape-1.3.0a1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any