lanscape 1.3.1a8__py3-none-any.whl → 1.3.2a6__py3-none-any.whl

lanscape/libraries/subnet_scan.py

@@ -1,373 +0,0 @@
-import os
-import json
-import uuid
-import logging
-import ipaddress
-import traceback
-import threading
-from time import time
-from time import sleep
-from typing import List, Union
-from tabulate import tabulate
-from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-from .net_tools import Device, is_arp_supported
-from .ip_parser import parse_ip_input
-from .port_manager import PortManager
-from.errors import SubnetScanTerminationFailure
-from .decorators import job_tracker, JobStats, terminator
-
-
-TCNT_PORT_SCANS = 10
-TCNT_PORT_TEST = 128
-TCNT_DEVICE_ISALIVE = 256
-
-@dataclass
-class ScanConfig:
-    subnet: str
-    port_list: str
-    t_multiplier: float = 1.0
-    t_cnt_port_scan: int = 10
-    t_cnt_port_test: int = 128
-    t_cnt_isalive: int = 256
-
-    task_scan_ports: bool = True
-    # below wont run if above false
-    task_scan_port_services: bool = False # disabling until more stable
-
-    def t_cnt(self, id: str) -> int:
-        return int(int(getattr(self, f't_cnt_{id}')) * float(self.t_multiplier))
-    
-    @staticmethod
-    def from_dict(data: dict) -> 'ScanConfig':
-        return ScanConfig(
-            subnet = data['subnet'],
-            port_list = data['port_list'],
-            t_multiplier = data.get('parallelism',1.0),
-            t_cnt_port_scan = data.get('t_cnt_port_scan',10),
-            t_cnt_port_test = data.get('t_cnt_port_test',128),
-            t_cnt_isalive = data.get('t_cnt_isalive',256),
-            task_scan_ports = data.get('task_scan_ports',True),
-            task_scan_port_services = data.get('task_scan_port_services',True)
-        )
-    
-    def get_ports(self) -> List[int]:
-        return PortManager().get_port_list(self.port_list).keys()
-    
-    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})'
-
-
-
-
-class SubnetScanner:
-    def __init__(
-            self, 
-            config: ScanConfig
-        ):
-        self.cfg = config
-        self.subnet = config.parse_subnet()
-        self.ports: List[int] = config.get_ports()
-        self.running = False
-        self.subnet_str = config.subnet
-
-        
-        self.job_stats = JobStats()
-        self.uid = str(uuid.uuid4())
-        self.results = ScannerResults(self)
-        self.log: logging.Logger = logging.getLogger('SubnetScanner')
-        if not is_arp_supported():
-            self.log.warning('ARP is not supported with the active runtime context. Device discovery will be limited to ping responses.')
-        self.log.debug(f'Instantiated with uid: {self.uid}')
-        self.log.debug(f'Port Count: {len(self.ports)} | Device Count: {len(self.subnet)}')
-
-
-    
-    
-    def start(self):
-        """
-        Scan the subnet for devices and open ports.
-        """
-        self._set_stage('scanning devices')
-        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 as_completed(futures):
-                ip = futures[future]
-                try:
-                    future.result()
-                except Exception as e:
-                    self.log.error(f'[{ip}] scan failed. details below:\n{traceback.format_exc()}')
-                    self.results.errors.append({
-                        'basic': f"Error scanning IP {ip}: {e}",
-                        'traceback': traceback.format_exc(),
-                    })
-                
-        
-        self._set_stage('testing ports')
-        if self.cfg.task_scan_ports:
-            self._scan_network_ports()
-        self.running = False
-        self._set_stage('complete')
-        
-        return self.results
-    
-    def terminate(self):
-        self.running = False
-        self._set_stage('terminating')
-        for i in range(20):
-            if not len(self.job_stats.running.keys()):
-                self._set_stage('terminated')
-                return True
-            sleep(.5)
-        raise SubnetScanTerminationFailure(self.job_stats.running)
-            
-    def calc_percent_complete(self) -> int: # 0 - 100
-        if not self.running: return 100
-
-        # --- Host discovery (isalive) calculations ---
-        avg_host_detail_sec = self.job_stats.timing.get('_get_host_details', 4.5)
-        # assume 10% alive percentage if the scan just started
-        if len(self.results.devices) and (self.results.devices_scanned):
-            est_subnet_alive_percent = (len(self.results.devices)) / (self.results.devices_scanned)  # avoid div 0
-        else:
-            est_subnet_alive_percent = .1
-        est_subnet_devices = est_subnet_alive_percent * self.results.devices_total
-
-        remaining_isalive_sec = (self.results.devices_total - self.results.devices_scanned) * avg_host_detail_sec
-        total_isalive_sec = self.results.devices_total * avg_host_detail_sec
-
-        isalive_multiplier = self.cfg.t_cnt('isalive')
-
-        # --- Port scanning calculations ---
-        device_ports_scanned = self.job_stats.finished.get('_test_port', 0)
-        # remediate initial inaccurate results because open ports reurn quickly
-        avg_port_test_sec = self.job_stats.timing.get('_test_port', 1) if device_ports_scanned > 20 else 1
-            
-        device_ports_unscanned = max(0, (est_subnet_devices*len(self.ports)) - device_ports_scanned)
-
-        remaining_port_test_sec = device_ports_unscanned * avg_port_test_sec
-        total_port_test_sec = est_subnet_devices * len(self.ports) * avg_port_test_sec
-
-        port_test_multiplier = self.cfg.t_cnt('port_scan') * self.cfg.t_cnt('port_test')
-
-        # --- Overall progress ---
-        est_total_time = (total_isalive_sec / isalive_multiplier) + (total_port_test_sec / port_test_multiplier)
-        est_remaining_time = (remaining_isalive_sec / isalive_multiplier) + (remaining_port_test_sec / port_test_multiplier)
-
-        return int(abs((1 - (est_remaining_time / est_total_time)) * 100))
-
-        
-
-    def debug_active_scan(self,sleep_sec=1):
-        """
-            Run this after running scan_subnet_threaded 
-            to see the progress of the scan
-        """
-        while self.running:
-            percent = self.calc_percent_complete()
-            t_elapsed = time() - self.results.start_time
-            t_remain = int((100-percent) * (t_elapsed / percent)) if percent else '∞'
-            buffer = f'{self.uid} - {self.subnet_str}\n'
-            buffer += f'Elapsed: {int(t_elapsed)} sec - Remain: {t_remain} sec\n'
-            buffer += f'Scanned: {self.results.devices_scanned}/{self.results.devices_total}'
-            buffer += f' - {percent}%\n'
-            buffer += str(self.job_stats)
-            os.system('cls' if os.name == 'nt' else 'clear')
-            print(buffer)
-            sleep(sleep_sec)
-
-    @terminator
-    @job_tracker
-    def _get_host_details(self, host: str):
-        """
-        Get the MAC address and open ports of the given host.
-        """
-        device = Device(host)
-        device.alive = self._ping(device)
-        self.results.scanned()
-        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
-        
-    @terminator
-    def _scan_network_ports(self):
-        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_scan')) as executor:
-            futures = {executor.submit(self._scan_ports, device): device for device in self.results.devices}
-            for future in futures:
-                future.result()
-
-    @terminator
-    @job_tracker
-    def _scan_ports(self, device: Device):
-        self.log.debug(f'[{device.ip}] Initiating port scan')
-        device.stage = 'scanning'
-        with ThreadPoolExecutor(max_workers=self.cfg.t_cnt('port_test')) as executor:
-            futures = {executor.submit(self._test_port, device, int(port)): port for port in self.ports}
-            for future in futures:
-                future.result()
-        self.log.debug(f'[{device.ip}] Completed port scan')
-        device.stage = 'complete'
-    
-    @terminator
-    @job_tracker
-    def _test_port(self,host: Device, port: int):
-        """
-        Test if a port is open on a given host.
-        If port open, determine service.
-        Device class handles tracking open ports.
-        """
-        is_alive = host.test_port(port)
-        if is_alive and self.cfg.task_scan_port_services:
-            host.scan_service(port)
-        return is_alive
-    
-        
-    @terminator
-    @job_tracker
-    def _ping(self, host: Device):
-        """
-        Ping the given host and return True if it's reachable, False otherwise.
-        """
-        return host.is_alive(host.ip)
-    
-    def _set_stage(self,stage):
-        self.log.debug(f'[{self.uid}] Moving to Stage: {stage}')
-        self.results.stage = stage
-        if not self.running:
-            self.results.end_time = time()
-    
-class ScannerResults:
-    def __init__(self,scan: SubnetScanner):
-        self.scan = scan
-        self.port_list: str = scan.cfg.port_list
-        self.subnet: str = scan.subnet_str
-        self.uid = scan.uid
-
-        self.devices_total: int = len(list(scan.subnet))
-        self.devices_scanned: int = 0
-        self.devices: List[Device] = []
-
-        self.errors: List[str] = []        
-        self.running: bool = False
-        self.start_time: float = time()
-        self.end_time: int = None
-        self.stage = 'instantiated'
-
-        self.log = logging.getLogger('ScannerResults')
-        self.log.debug(f'Instantiated Logger For Scan: {self.scan.uid}')
-
-
-    def scanned(self):
-        self.devices_scanned += 1
-
-    def get_runtime(self):
-        if self.scan.running:
-            return int(time()-self.start_time)
-        return int(self.end_time-self.start_time)
-        
-
-    
-    def export(self,out_type=dict) -> Union[str, dict]:
-        """
-            Returns json representation of the scan
-        """
-
-        self.running = self.scan.running
-        self.run_time = int(round(time() - self.start_time,0))
-        self.devices_alive = len(self.devices)
-
-        out = vars(self).copy()
-        out.pop('scan')
-        out.pop('log')
-        out['cfg'] = vars(self.scan.cfg)
-        
-        devices: List[Device] = out.pop('devices')
-        sortedDevices = sorted(devices, key=lambda obj: ipaddress.IPv4Address(obj.ip))
-        out['devices'] = [device.dict() for device in sortedDevices]
-
-        if out_type == str:
-            return json.dumps(out,default=str, indent=2)
-        # otherwise return dict
-        return out
-    
-    def __str__(self):
-        # Prepare data for tabulate
-        data = [
-            [device.ip, device.hostname, device.get_mac(), ", ".join(map(str, device.ports))]
-            for device in self.devices
-        ]
-
-        # Create headers for the table
-        headers = ["IP", "Host", "MAC", "Ports"]
-
-        # Generate the table using tabulate
-        table = tabulate(data, headers=headers, tablefmt="grid")
-
-        # Format and return the complete buffer with table output
-        buffer = f"Scan Results - {self.scan.subnet_str} - {self.uid}\n"
-        buffer += "---------------------------------------------\n\n"
-        buffer += table
-        return buffer
-
-
-class ScanManager:
-    """
-    Maintain active and completed scans in memory for 
-    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):
-        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:
-        """
-        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
-        """
-        for scan in self.scans:
-            if scan.running:
-                scan.terminate()
-
-    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):
-        t = threading.Thread(target=scan.start)
-        t.start()
-        return t
-
-
-    

lanscape/libraries/version_manager.py

@@ -1,54 +0,0 @@
-import logging 
-import requests
-import traceback
-from importlib.metadata import version, PackageNotFoundError
-from random import randint
-
-from .app_scope import is_local_run
-
-log = logging.getLogger('VersionManager')
-
-PACKAGE='lanscape'
-LOCAL_VERSION = '0.0.0'
-
-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)
-
-    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):
-    # Fetch the latest version from PyPI
-    global latest
-    if not latest:
-        no_cache = f'?cachebust={randint(0,6969)}'
-        url = f"https://pypi.org/pypi/{package}/json{no_cache}"
-        try:
-            response = requests.get(url,timeout=5)
-            response.raise_for_status()  # Raise an exception for HTTP errors
-            latest = response.json()['info']['version']
-            log.debug(f'Latest pypi version: {latest}')
-        except:
-            log.debug(traceback.format_exc())
-            log.warning('Unable to fetch package version from PyPi')
-    return latest
-
-def get_installed_version(package=PACKAGE):
-    if not is_local_run():
-        try:
-            return version(package)
-        except PackageNotFoundError:
-            log.debug(traceback.format_exc())
-            log.warning(f'Cannot find {package} installation')
-    return LOCAL_VERSION
-    
-

lanscape/libraries/web_browser.py

@@ -1,141 +0,0 @@
-#!/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
-from typing import Optional
-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')
-        log.debug(f'Opening {url} with {exe}')
-
-        cmd = f'"{exe}" --app="{url}"'
-        subprocess.run(cmd, check=True, shell=True)
-
-        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(f'As app error: {e}')
-        try:
-            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:
-            log.warning(f'Exhausted all options to open browser, you need to open manually')
-            log.debug(f'As tab error: {e}')
-            log.info(f'LANScape UI is running on {url}')
-    return False
-    
-
-def get_default_browser_executable() -> Optional[str]:
-    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
-
-    elif sys.platform.startswith("darwin"):
-        # macOS: try to find Chrome first for app mode support, fallback to default
-        try:
-            p = subprocess.run(
-                ["mdfind", "kMDItemCFBundleIdentifier == 'com.google.Chrome'"],
-                capture_output=True, text=True, check=True
-            )
-            chrome_paths = p.stdout.strip().split('\n')
-            if chrome_paths and chrome_paths[0]:
-                return f"{chrome_paths[0]}/Contents/MacOS/Google Chrome"
-        except subprocess.CalledProcessError:
-            pass
-        
-        # Fallback to system default
-        return "/usr/bin/open"
-
-    else:
-        raise NotImplementedError(f"Unsupported platform: {sys.platform!r}")

lanscape/resources/mac_addresses/convert_csv.py

@@ -1,27 +0,0 @@
-# Only used to import csv data - not during runtime
-
-import csv, json
-
-def main():
-    ans = {}
-    with open('mac-vendors-export.csv', 'r', encoding='utf-8') as f:
-        data = csv.reader(f)
-        services = csv_to_dict(data)
-    for service in services:
-        if service['Vendor Name'] and service['Mac Prefix']:
-            try:
-                ans[service['Mac Prefix']] = service['Vendor Name']
-            except:
-                pass
-    with open('mac_db.json', 'w') as f:
-        json.dump(ans, f, indent=2)
-        
-
-def csv_to_dict(data):
-    """
-    Convert a CSV file to a dictionary.
-    """
-    header = next(data)
-    return [dict(zip(header, row)) for row in data]
-
-main()

lanscape/resources/ports/convert_csv.py

@@ -1,27 +0,0 @@
-# Only used to import csv data - not during runtime
-
-import csv, json
-
-def main():
-    ans = {}
-    with open('service-names-port-numbers.csv', 'r') as f:
-        data = csv.reader(f)
-        services = csv_to_dict(data)
-    for service in services:
-        if service['Service Name'] and service['Port Number']:
-            try:
-                ans[service['Port Number']] = service['Service Name']
-            except:
-                pass
-    with open('valid_ports.json', 'w') as f:
-        json.dump(ans, f, indent=2)
-        
-
-def csv_to_dict(data):
-    """
-    Convert a CSV file to a dictionary.
-    """
-    header = next(data)
-    return [dict(zip(header, row)) for row in data]
-
-main()

lanscape/tests/__init__.py

@@ -1,3 +0,0 @@
-from .test_api import ApiTestCase
-from .test_env import EnvTestCase
-from .test_library import LibraryTestCase

lanscape/tests/_helpers.py

@@ -1,15 +0,0 @@
-
-from ..libraries.ip_parser import get_address_count
-
-
-def right_size_subnet(subnet: str):
-    """
-    Used to improve speed of test time
-    """
-    if get_address_count(subnet) > 500:
-        parts = subnet.split('/')
-        ip = parts[0]
-        mask = int(parts[1])
-        mask += 1
-        return right_size_subnet(f"{ip}/{mask}")
-    return subnet