lanscape 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

lanscape/libraries/web_browser.py

@@ -37,7 +37,7 @@ def open_webapp(url: str) -> bool:
 
         if time.time() - start < 2:
             log.debug(
-                f'Unable to hook into closure of UI, listening for flask shutdown')
+                'Unable to hook into closure of UI, listening for flask shutdown')
             return False
         return True
 
@@ -49,80 +49,26 @@ def open_webapp(url: str) -> bool:
             success = webbrowser.open(url)
             log.debug(f'Opened {url} in browser tab: {success}')
             if not success:
-                raise RuntimeError('Unknown error while opening browser tab')
-        except Exception as e:
+                # pylint: disable=raise-missing-from
+                raise RuntimeError(
+                    'Unknown error while opening browser tab') from e
+        except Exception as e2:
             log.warning(
-                f'Exhausted all options to open browser, you need to open manually')
-            log.debug(f'As tab error: {e}')
+                'Exhausted all options to open browser, you need to open manually')
+            log.debug(f'As tab error: {e2}')
             log.info(f'LANScape UI is running on {url}')
     return False
 
 
 def get_default_browser_executable() -> Optional[str]:
+    """Platform-agnostic method to get the default browser executable path."""
     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
+        return windows_get_browser_from_registry()
 
-        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
+    if sys.platform.startswith("linux"):
+        return linux_get_browser_executable()
 
-    elif sys.platform.startswith("darwin"):
+    if sys.platform.startswith("darwin"):
         # macOS: try to find Chrome first for app mode support, fallback to default
         try:
             p = subprocess.run(
@@ -138,5 +84,127 @@ def get_default_browser_executable() -> Optional[str]:
         # Fallback to system default
         return "/usr/bin/open"
 
-    else:
-        raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")
+    # Unsupported platform
+    return None
+
+
+def linux_get_browser_executable() -> Optional[str]:
+    """Get the default web browser executable path on 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",
+    ]
+
+    exec_cmd = None
+    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 exec_cmd
+
+
+def windows_get_browser_from_registry() -> Optional[str]:
+    """Get the default web browser executable path on Windows."""
+    # Import winreg only on Windows platforms
+    if not sys.platform.startswith("win"):
+        return None
+
+    try:
+        import winreg  # pylint: disable=import-outside-toplevel
+    except ImportError:
+        log.debug("winreg module not available")
+        return None
+
+    def get_reg(base, path, key=None):
+        """Helper function to read a registry key."""
+        try:
+            with winreg.OpenKey(base, path) as reg:
+                return winreg.QueryValueEx(reg, key)[0]
+        except FileNotFoundError:
+            return None
+
+    def extract_executable(cmd: str) -> Optional[str]:
+        """Extract the executable path from a command string."""
+        match = re.match(r'"?([^"]+)"?', cmd)
+        return match.group(1) if match else None
+
+    def get_user_preferred_browser():
+        """Get the user preferred browser from the registry."""
+        progid = get_reg(
+            winreg.HKEY_CURRENT_USER,
+            r'Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice',
+            'ProgId'
+        )
+        if not progid:
+            log.debug('No user preferred browser found in registry')
+            return None
+
+        browser_path = get_reg(
+            winreg.HKEY_CLASSES_ROOT,
+            f'{progid}\\shell\\open\\command'
+        )
+
+        if not browser_path:
+            log.debug(f'progid {progid} does not have a command in registry')
+            return None
+
+        return extract_executable(browser_path)
+
+    def get_system_default_browser():
+        """Get the system default browser from the registry."""
+        reg = get_reg(
+            winreg.HKEY_CLASSES_ROOT,
+            r'http\shell\open\command'
+        )
+        if not reg:
+            log.debug('No system default browser found in registry')
+            return None
+
+        return extract_executable(reg)
+
+    user_browser = get_user_preferred_browser()
+    if user_browser:
+        return extract_executable(user_browser)
+
+    system_browser = get_system_default_browser()
+    if system_browser:
+        return extract_executable(system_browser)

lanscape/resources/mac_addresses/convert_csv.py

@@ -1,10 +1,21 @@
-# Only used to import csv data - not during runtime
+"""
+CSV to JSON converter for MAC address vendor mappings.
+Processes vendor MAC address prefix data from CSV format to a simplified JSON lookup table
+for use in the LANscape application. Only used during development, not at runtime.
+"""
 
 import csv
 import json
 
 
 def main():
+    """
+    Main function to convert CSV MAC vendor data to a JSON mapping.
+
+    Reads MAC vendor information from a CSV file, processes it to extract
+    MAC address prefixes and vendor names, and writes the resulting mapping
+    to a JSON file for efficient lookup.
+    """
     ans = {}
     with open('mac-vendors-export.csv', 'r', encoding='utf-8') as f:
         data = csv.reader(f)
@@ -15,7 +26,7 @@ def main():
                 ans[service['Mac Prefix']] = service['Vendor Name']
             except BaseException:
                 pass
-    with open('mac_db.json', 'w') as f:
+    with open('mac_db.json', 'w', encoding='utf-8') as f:
         json.dump(ans, f, indent=2)
 
 

lanscape/resources/ports/convert_csv.py

@@ -1,12 +1,22 @@
-# Only used to import csv data - not during runtime
+"""
+CSV to JSON converter for port service mappings.
+Converts IANA service-names-port-numbers CSV file to a simplified JSON format
+for use in the LANscape application. Only used during development, not at runtime.
+"""
 
 import csv
 import json
 
 
 def main():
+    """
+    Main function to convert CSV port data to a JSON mapping.
+
+    Reads port information from a CSV file, processes it to extract port numbers
+    and service names, and writes the resulting mapping to a JSON file.
+    """
     ans = {}
-    with open('service-names-port-numbers.csv', 'r') as f:
+    with open('service-names-port-numbers.csv', 'r', encoding='utf-8') as f:
         data = csv.reader(f)
         services = csv_to_dict(data)
     for service in services:
@@ -15,7 +25,7 @@ def main():
                 ans[service['Port Number']] = service['Service Name']
             except BaseException:
                 pass
-    with open('valid_ports.json', 'w') as f:
+    with open('valid_ports.json', 'w', encoding='utf-8') as f:
         json.dump(ans, f, indent=2)
 
 

lanscape/ui/app.py

@@ -1,13 +1,20 @@
-from flask import Flask, render_template, request
+"""
+Flask application for LANscape web UI that provides device discovery and network monitoring.
+Handles initialization, routing, error handling, and web server management.
+"""
 import traceback
 import threading
 import logging
-import os
-
+from flask import Flask, render_template
+from lanscape.ui.blueprints.web import web_bp, routes  # pylint: disable=unused-import
+from lanscape.ui.blueprints.api import api_bp, tools, port, scan  # pylint: disable=unused-import
 from lanscape.libraries.runtime_args import RuntimeArgs, parse_args
-from lanscape.libraries.version_manager import is_update_available, get_installed_version, lookup_latest_version
+from lanscape.libraries.version_manager import (
+    is_update_available, get_installed_version, lookup_latest_version
+)
 from lanscape.libraries.app_scope import is_local_run
 from lanscape.libraries.net_tools import is_arp_supported
+from lanscape.ui.shutdown_handler import FlaskShutdownHandler
 
 app = Flask(
     __name__
@@ -15,9 +22,7 @@ app = Flask(
 log = logging.getLogger('flask')
 
 # Import and register BPs
-################################
-from lanscape.ui.blueprints.api import api_bp, tools, port, scan
-from lanscape.ui.blueprints.web import web_bp, routes
+#################################
 
 app.register_blueprint(api_bp)
 app.register_blueprint(web_bp)
@@ -27,6 +32,16 @@ app.register_blueprint(web_bp)
 
 
 def is_substring_in_values(results: dict, substring: str) -> bool:
+    """
+    Check if a substring exists in any value of a dictionary.
+
+    Args:
+        results: Dictionary to search through values
+        substring: String to search for
+
+    Returns:
+        Boolean indicating if substring was found in any value
+    """
     return any(substring.lower() in str(v).lower() for v in results.values()) if substring else True
 
 
@@ -65,41 +80,20 @@ set_global_safe('is_arp_supported', is_arp_supported)
 # External hook to kill flask server
 ################################
 
-exiting = False
-
-
-@app.route("/shutdown", methods=['GET', 'POST'])
-def exit_app():
-
-    req_type = request.args.get('type')
-    if req_type == 'browser-close':
-        args = parse_args()
-        if args.persistent:
-            log.info('Dectected browser close, not exiting flask.')
-            return "Ignored"
-        log.info('Web browser closed, terminating flask. (disable with --peristent)')
-    elif req_type == 'core':
-        log.info('Core requested exit, terminating flask.')
-    else:
-        log.info('Received external exit request. Terminating flask.')
-    global exiting
-    exiting = True
-    return "Done"
-
-
-@app.teardown_request
-def teardown(exception):
-    if exiting:
-        os._exit(0)
+shutdown_handler = FlaskShutdownHandler(app)
+shutdown_handler.register_endpoints()
 
 # Generalized error handling
 ################################
 
 
 @app.errorhandler(500)
-def internal_error(e):
+def internal_error(_):
     """
-    handle internal errors nicely
+    Handle internal errors by showing a formatted error page with traceback.
+
+    Returns:
+        Rendered error template with traceback information
     """
     tb = traceback.format_exc()
     return render_template('error.html',
@@ -111,14 +105,16 @@ def internal_error(e):
 
 
 def start_webserver_daemon(args: RuntimeArgs) -> threading.Thread:
+    """Start the web server in a daemon 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')
+    log.info('Flask server initializing as daemon')
     return proc
 
 
 def start_webserver(args: RuntimeArgs) -> int:
+    """Start webserver (blocking)"""
     run_args = {
         'host': '0.0.0.0',
         'port': args.port,

lanscape/ui/blueprints/__init__.py

@@ -1,5 +1,8 @@
-from lanscape.libraries.subnet_scan import ScanManager
+"""Source for all things blueprint related in LANscape UI"""
 import logging
+
+from lanscape.libraries.subnet_scan import ScanManager
+
 # defining here so blueprints can access the same
 # manager instance
 scan_manager = ScanManager()

lanscape/ui/blueprints/api/__init__.py

@@ -1,3 +1,5 @@
+"""API blueprint def for lanscape"""
+
 from flask import Blueprint
 
 api_bp = Blueprint('api', __name__)

lanscape/ui/blueprints/api/port.py

@@ -1,3 +1,7 @@
+"""
+API endpoints for port list management in the LANscape application.
+Provides CRUD operations for managing port lists used in network scans.
+"""
 from flask import request, jsonify
 from lanscape.ui.blueprints.api import api_bp
 from lanscape.libraries.port_manager import PortManager
@@ -8,26 +12,68 @@ from lanscape.libraries.port_manager import PortManager
 
 @api_bp.route('/api/port/list', methods=['GET'])
 def get_port_lists():
+    """
+    Get all available port lists.
+
+    Returns:
+        JSON array of port list names
+    """
     return jsonify(PortManager().get_port_lists())
 
 
 @api_bp.route('/api/port/list/<port_list>', methods=['GET'])
 def get_port_list(port_list):
+    """
+    Get a specific port list by name.
+
+    Args:
+        port_list: Name of the port list to retrieve
+
+    Returns:
+        JSON object mapping port numbers to service names
+    """
     return jsonify(PortManager().get_port_list(port_list))
 
 
 @api_bp.route('/api/port/list/<port_list>', methods=['POST'])
 def create_port_list(port_list):
+    """
+    Create a new port list.
+
+    Args:
+        port_list: Name for the new port list
+
+    Returns:
+        JSON response indicating success or failure
+    """
     data = request.get_json()
     return jsonify(PortManager().create_port_list(port_list, data))
 
 
 @api_bp.route('/api/port/list/<port_list>', methods=['PUT'])
 def update_port_list(port_list):
+    """
+    Update an existing port list.
+
+    Args:
+        port_list: Name of the port list to update
+
+    Returns:
+        JSON response indicating success or failure
+    """
     data = request.get_json()
     return jsonify(PortManager().update_port_list(port_list, data))
 
 
 @api_bp.route('/api/port/list/<port_list>', methods=['DELETE'])
 def delete_port_list(port_list):
+    """
+    Delete a port list.
+
+    Args:
+        port_list: Name of the port list to delete
+
+    Returns:
+        JSON response indicating success or failure
+    """
     return jsonify(PortManager().delete_port_list(port_list))

lanscape/ui/blueprints/api/scan.py

@@ -1,11 +1,17 @@
-from lanscape.ui.blueprints.api import api_bp
-from lanscape.libraries.subnet_scan import ScanConfig
-from lanscape.ui.blueprints import scan_manager
+"""
+API endpoints for network scanning functionality in the LANscape application.
+Provides routes for initiating, monitoring, and retrieving network scan results.
+"""
 
-from flask import request, jsonify
 import json
 import traceback
 
+from flask import request, jsonify
+
+from lanscape.ui.blueprints.api import api_bp
+from lanscape.libraries.subnet_scan import ScanConfig
+from lanscape.ui.blueprints import scan_manager
+
 # Subnet Scanner API
 ############################################
 
@@ -13,6 +19,14 @@ import traceback
 @api_bp.route('/api/scan', methods=['POST'])
 @api_bp.route('/api/scan/threaded', methods=['POST'])
 def scan_subnet_threaded():
+    """
+    Start a new network scan in a separate thread.
+
+    Accepts scan configuration as JSON in the request body.
+
+    Returns:
+        JSON response with scan status and ID
+    """
     try:
         config = get_scan_config()
         scan = scan_manager.new_scan(config)
@@ -24,6 +38,14 @@ def scan_subnet_threaded():
 
 @api_bp.route('/api/scan/async', methods=['POST'])
 def scan_subnet_async():
+    """
+    Start a scan and wait for it to complete before returning.
+
+    Accepts scan configuration as JSON in the request body.
+
+    Returns:
+        JSON response with scan status and ID after completion
+    """
     config = get_scan_config()
     scan = scan_manager.new_scan(config)
     scan_manager.wait_until_complete(scan.uid)
@@ -33,6 +55,15 @@ def scan_subnet_async():
 
 @api_bp.route('/api/scan/<scan_id>', methods=['GET'])
 def get_scan(scan_id):
+    """
+    Retrieve the full results of a completed scan.
+
+    Args:
+        scan_id: Unique identifier for the scan
+
+    Returns:
+        JSON representation of scan results
+    """
     scan = scan_manager.get_scan(scan_id)
     # cast to str and back to handle custom JSON serialization
     return jsonify(json.loads(scan.results.export(str)))
@@ -40,6 +71,15 @@ def get_scan(scan_id):
 
 @api_bp.route('/api/scan/<scan_id>/summary', methods=['GET'])
 def get_scan_summary(scan_id):
+    """
+    Retrieve a summary of the scan results.
+
+    Args:
+        scan_id: Unique identifier for the scan
+
+    Returns:
+        JSON representation of scan summary
+    """
     scan = scan_manager.get_scan(scan_id)
     if not scan:
         return jsonify({'error': 'scan not found'}), 404
@@ -58,6 +98,15 @@ def get_scan_summary(scan_id):
 
 @api_bp.route('/api/scan/<scan_id>/terminate', methods=['GET'])
 def terminate_scan(scan_id):
+    """Terminate a running scan.
+
+    Args:
+        scan_id (str): Unique identifier for the scan
+
+    Returns:
+        JSON response indicating success or failure
+    """
+
     scan = scan_manager.get_scan(scan_id)
     scan.terminate()
     return jsonify({'success': True})
@@ -65,11 +114,10 @@ def terminate_scan(scan_id):
 
 def get_scan_config():
     """
-    pulls config from the request body
+    Extract and parse scan configuration from the request body.
+
+    Returns:
+        ScanConfig object constructed from the request JSON data
     """
     data = request.get_json()
-    return ScanConfig(
-        subnet=data['subnet'],
-        port_list=data['port_list'],
-        t_multiplier=data.get('parallelism', 1.0)
-    )
+    return ScanConfig.from_dict(data)

lanscape/ui/blueprints/api/tools.py

@@ -1,13 +1,19 @@
+"""
+API endpoints for subnet testing and listing.
+"""
+
+import traceback
 from flask import request, jsonify
 from lanscape.ui.blueprints.api import api_bp
 from lanscape.libraries.net_tools import get_all_network_subnets
 from lanscape.libraries.ip_parser import parse_ip_input
 from lanscape.libraries.errors import SubnetTooLargeError
-import traceback
+from lanscape.libraries.scan_config import DEFAULT_CONFIGS
 
 
 @api_bp.route('/api/tools/subnet/test')
 def test_subnet():
+    """check validity of a subnet"""
     subnet = request.args.get('subnet')
     if not subnet:
         return jsonify({'valid': False, 'msg': 'Subnet cannot be blank', 'count': -1})
@@ -34,3 +40,13 @@ def list_subnet():
         return jsonify(get_all_network_subnets())
     except BaseException:
         return jsonify({'error': traceback.format_exc()})
+
+
+@api_bp.route('/api/tools/config/defaults')
+def get_default_configs():
+    """
+    Get default scan configurations.
+    """
+    return jsonify(
+        {key: config.to_dict() for key, config in DEFAULT_CONFIGS.items()}
+    )

lanscape/ui/blueprints/web/__init__.py

@@ -1,3 +1,7 @@
+"""
+Blueprint for web-related routes and views.
+"""
+
 from flask import Blueprint
 
 web_bp = Blueprint('web', __name__)