lanscape 1.3.5a1__py3-none-any.whl → 1.3.6__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,70 +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"):
         return windows_get_browser_from_registry()
 
+    if sys.platform.startswith("linux"):
+        return linux_get_browser_executable()
 
-    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
-
-    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(
@@ -128,14 +84,75 @@ 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
 
-    import winreg # pylint: disable=import-outside-toplevel
+    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."""

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,12 +1,17 @@
-
+"""
+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
 from flask import Flask, render_template
-from lanscape.ui.blueprints.web import web_bp, routes # pylint: ignore=unused-import
-from lanscape.ui.blueprints.api import api_bp, tools, port, scan # pylint: ignore=unused-import
+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
@@ -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
 
 
@@ -73,9 +88,12 @@ shutdown_handler.register_endpoints()
 
 
 @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',

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,7 +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.from_dict(data)

lanscape/ui/blueprints/api/tools.py

@@ -13,6 +13,7 @@ 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})

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__)

lanscape/ui/blueprints/web/routes.py

@@ -1,3 +1,7 @@
+"""
+Web blueprint routes for the LANscape application.
+Handles UI views including the main dashboard, scan results, error display, and exports.
+"""
 from flask import render_template, request, redirect
 from lanscape.ui.blueprints.web import web_bp
 from lanscape.libraries.net_tools import (
@@ -12,6 +16,12 @@ from lanscape.ui.blueprints import scan_manager, log
 
 @web_bp.route('/', methods=['GET'])
 def index():
+    """
+    Render the main application interface.
+
+    Displays the primary network subnet selection interface and existing scan results.
+    If a scan_id is provided, it loads the configuration from that scan.
+    """
     subnets = get_all_network_subnets()
     subnet = smart_select_primary_subnet(subnets)
 
@@ -35,16 +45,35 @@ def index():
 @web_bp.route('/scan/<scan_id>', methods=['GET'])
 @web_bp.route('/scan/<scan_id>/<section>', methods=['GET'])
 def render_scan(scan_id, section='all'):
+    """
+    Render a specific scan result.
+
+    Args:
+        scan_id: Unique identifier for the scan
+        section: Section of the scan results to display (default: 'all')
+
+    Returns:
+        Rendered scan template or redirect to home if scan not found
+    """
     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)
+        filter_text = request.args.get('filter')
+        return render_template('scan.html', data=data, section=section, filter=filter_text)
     log.debug(f'Redirecting, scan {scan_id} doesnt exist in memory')
     return redirect('/')
 
 
 @web_bp.route('/errors/<scan_id>')
 def view_errors(scan_id):
+    """
+    Display errors that occurred during a scan.
+
+    Args:
+        scan_id: Unique identifier for the scan
+
+    Returns:
+        Rendered error template or redirect to home if scan not found
+    """
     if scanner := scan_manager.get_scan(scan_id):
         data = scanner.results.export()
         return render_template('scan/scan-error.html', data=data)
@@ -54,6 +83,15 @@ def view_errors(scan_id):
 
 @web_bp.route('/export/<scan_id>')
 def export_scan(scan_id):
+    """
+    Provide an exportable view of scan results.
+
+    Args:
+        scan_id: Unique identifier for the scan
+
+    Returns:
+        Rendered export template or redirect to home if scan not found
+    """
     if scanner := scan_manager.get_scan(scan_id):
         export_json = scanner.results.export(str)
         return render_template(
@@ -67,9 +105,21 @@ def export_scan(scan_id):
 
 @web_bp.route('/shutdown-ui')
 def shutdown_ui():
+    """
+    Display the shutdown confirmation page.
+
+    Returns:
+        Rendered shutdown template
+    """
     return render_template('shutdown.html')
 
 
 @web_bp.route('/info')
 def app_info():
+    """
+    Display application information and version details.
+
+    Returns:
+        Rendered info template
+    """
     return render_template('info.html')

lanscape/ui/main.py

@@ -1,4 +1,4 @@
-
+"""Main entry point for the LANscape application when running as a module."""
 import socket
 
 
@@ -12,7 +12,6 @@ import requests
 from lanscape.libraries.logger import configure_logging
 from lanscape.libraries.runtime_args import parse_args
 from lanscape.libraries.web_browser import open_webapp
-from lanscape.libraries.net_tools import is_arp_supported
 from lanscape.libraries.version_manager import get_installed_version, is_update_available
 from lanscape.ui.app import start_webserver_daemon, start_webserver
 # do this so any logs generated on import are displayed
@@ -49,14 +48,6 @@ def _main():
 
     args.port = get_valid_port(args.port)
 
-    if not is_arp_supported():
-        warn = (
-            'ARP is not supported, device discovery is degraded. ',
-            'For more information, see the help guide: ',
-            'https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md'
-        )
-        log.warning(''.join(warn))
-
     try:
         start_webserver_ui()
         log.info('Exiting...')

lanscape/ui/shutdown_handler.py

@@ -1,3 +1,5 @@
+"""Logic for handling shutdown requests in a Flask application."""
+
 import logging
 import os
 from flask import request
@@ -40,12 +42,14 @@ class FlaskShutdownHandler:
             if args.persistent:
                 log.info('Detected browser close, not exiting flask.')
                 return "Ignored"
-            log.info('Web browser closed, terminating flask. (disable with --persistent)')
+            log.info(
+                'Web browser closed, terminating flask. (disable with --persistent)')
         elif req_type == 'core':
             log.info('Core requested exit, terminating flask.')
         else:
             log.info('Received external exit request. Terminating flask.')
         self._exiting = True
+        return "Done"
 
     def exit_if_requested(self):
         """Exits the application if a shutdown request has been made."""