lanscape 1.4.2a3__tar.gz → 2.1.2__tar.gz

{lanscape-1.4.2a3/lanscape.egg-info → lanscape-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.4.2a3
+Version: 2.1.2
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -8,8 +8,13 @@ Project-URL: Homepage, https://github.com/mdennis281/py-lanscape
 Project-URL: Issues, https://github.com/mdennis281/py-lanscape/issues
 Keywords: network,scanner,lan,local,python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Flask<5.0,>=3.0
@@ -20,6 +25,11 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape
@@ -80,7 +90,7 @@ I use a combination of ARP, ICMP & port testing to determine if a device is onli
 Recommendations:
 
   - Adjust scan configuration
-  - Configure ARP lookup [ARP lookup setup](./support/arp-issues.md)
+  - Configure ARP lookup [ARP lookup setup](./docs/arp-issues.md)
   - Create a bug
 
 

{lanscape-1.4.2a3 → lanscape-2.1.2}/README.md

@@ -56,7 +56,7 @@ I use a combination of ARP, ICMP & port testing to determine if a device is onli
 Recommendations:
 
   - Adjust scan configuration
-  - Configure ARP lookup [ARP lookup setup](./support/arp-issues.md)
+  - Configure ARP lookup [ARP lookup setup](./docs/arp-issues.md)
   - Create a bug
 
 

lanscape-2.1.2/lanscape/__init__.py

@@ -0,0 +1,24 @@
+"""
+Local network scanner
+"""
+from lanscape.core.subnet_scan import (
+    SubnetScanner,
+    ScannerResults,
+    ScanManager
+)
+
+from lanscape.core.scan_config import (
+    ScanConfig,
+    ArpConfig,
+    PingConfig,
+    PokeConfig,
+    ArpCacheConfig,
+    PortScanConfig,
+    ServiceScanConfig,
+    ServiceScanStrategy,
+    ScanType
+)
+
+from lanscape.core.port_manager import PortManager
+
+from lanscape.core import net_tools

{lanscape-1.4.2a3/lanscape/libraries → lanscape-2.1.2/lanscape/core}/app_scope.py

@@ -5,7 +5,6 @@ Resource and environment management utilities for Lanscape.
 
 from pathlib import Path
 import json
-import re
 
 
 class ResourceManager:
@@ -32,9 +31,28 @@ class ResourceManager:
         return json.loads(self.get(asset_name))
 
     def get_jsonc(self, asset_name: str):
-        """Get JSON content with comments removed."""
+        """AI Slop to get JSONC (JSON with comments) content of an asset as a JSON object."""
         content = self.get(asset_name)
-        cleaned_content = re.sub(r'//.*', '', content)
+
+        def strip_jsonc_lines(text):
+            result = []
+            in_string = False
+            escape = False
+            for line in text.splitlines():
+                new_line = []
+                i = 0
+                while i < len(line):
+                    char = line[i]
+                    if char == '"' and not escape:
+                        in_string = not in_string
+                    if not in_string and line[i:i + 2] == "//":
+                        break  # Ignore rest of line (comment)
+                    new_line.append(char)
+                    escape = (char == '\\' and not escape)
+                    i += 1
+                result.append(''.join(new_line))
+            return '\n'.join(result)
+        cleaned_content = strip_jsonc_lines(content)
         return json.loads(cleaned_content)
 
     def update(self, asset_name: str, content: str):

{lanscape-1.4.2a3/lanscape/libraries → lanscape-2.1.2/lanscape/core}/decorators.py

@@ -2,13 +2,11 @@
 """Decorators and job tracking utilities for Lanscape."""
 
 from time import time
-from dataclasses import dataclass, field
-from typing import DefaultDict
 from collections import defaultdict
-import inspect
 import functools
 import concurrent.futures
 import logging
+import threading
 from tabulate import tabulate
 
 
@@ -39,31 +37,74 @@ def run_once(func):
     return wrapper
 
 
-@dataclass
 class JobStats:
     """
+    Thread-safe singleton for tracking job statistics across all classes.
     Tracks statistics for job execution, including running, finished, and timing data.
     """
-    running: DefaultDict[str, int] = field(
-        default_factory=lambda: defaultdict(int))
-    finished: DefaultDict[str, int] = field(
-        default_factory=lambda: defaultdict(int))
-    timing: DefaultDict[str, float] = field(
-        default_factory=lambda: defaultdict(float))
 
     _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:  # Double-checked locking
+                    cls._instance = super().__new__(cls)
+        return cls._instance
 
     def __init__(self):
-        # Only initialize once
-        if not hasattr(self, "running"):
+        if not hasattr(self, '_initialized'):
+            self._stats_lock = threading.RLock()
             self.running = defaultdict(int)
             self.finished = defaultdict(int)
             self.timing = defaultdict(float)
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(JobStats, cls).__new__(cls)
-        return cls._instance
+            self._initialized = True
+
+    def start_job(self, func_name: str):
+        """Thread-safe increment of running counter."""
+        with self._stats_lock:
+            self.running[func_name] += 1
+
+    def finish_job(self, func_name: str, elapsed_time: float):
+        """Thread-safe update of job completion and timing."""
+        with self._stats_lock:
+            self.running[func_name] -= 1
+            self.finished[func_name] += 1
+
+            # Calculate running average
+            count = self.finished[func_name]
+            old_avg = self.timing[func_name]
+            new_avg = (old_avg * (count - 1) + elapsed_time) / count
+            self.timing[func_name] = round(new_avg, 4)
+
+            # Cleanup running if zero
+            if self.running[func_name] <= 0:
+                self.running.pop(func_name, None)
+
+    def clear_stats(self):
+        """Clear all statistics (useful between scans)."""
+        with self._stats_lock:
+            self.running.clear()
+            self.finished.clear()
+            self.timing.clear()
+
+    def get_stats_copy(self) -> dict:
+        """Get a thread-safe copy of current statistics."""
+        with self._stats_lock:
+            return {
+                'running': dict(self.running),
+                'finished': dict(self.finished),
+                'timing': dict(self.timing)
+            }
+
+    @classmethod
+    def reset_for_testing(cls):
+        """Reset singleton instance for testing purposes only."""
+        with cls._lock:
+            if cls._instance:
+                cls._instance.clear_stats()
+            cls._instance = None
 
     def __str__(self):
         """Return a formatted string representation of the job statistics."""
@@ -106,48 +147,40 @@ def job_tracker(func):
         Return the function name with the class name prepended if available.
         """
         qual_parts = func.__qualname__.split(".")
-        cls_name = qual_parts[-2] if len(qual_parts) > 1 else None
-        cls_obj = None  # resolved lazily
-        if cls_obj is None and cls_name:
-            mod = inspect.getmodule(func)
-            cls_obj = getattr(mod, cls_name, None)
-        if cls_obj and first_arg is not None:
-            if (first_arg is cls_obj or isinstance(first_arg, cls_obj)):
-                return f"{cls_name}.{func.__name__}"
+
+        # If function has class context (e.g., "ClassName.method_name")
+        if len(qual_parts) > 1:
+            cls_name = qual_parts[-2]
+
+            # Check if first_arg is an instance and has the expected class name
+            if first_arg is not None and hasattr(first_arg, '__class__'):
+                if first_arg.__class__.__name__ == cls_name:
+                    return f"{cls_name}.{func.__name__}"
+
         return func.__name__
 
+    @functools.wraps(func)
     def wrapper(*args, **kwargs):
         """Wrap the function to update job statistics before and after execution."""
-        class_instance = args[0]
         job_stats = JobStats()
-        fxn = get_fxn_src_name(
-            func,
-            class_instance
-        )
 
-        # Increment running counter and track execution time
-        job_stats.running[fxn] += 1
-        start = time()
+        # Determine function name for tracking
+        if args:
+            fxn = get_fxn_src_name(func, args[0])
+        else:
+            fxn = func.__name__
 
-        result = func(*args, **kwargs)  # Execute the wrapped function
-
-        # Update statistics after function execution
-        elapsed = time() - start
-        job_stats.running[fxn] -= 1
-        job_stats.finished[fxn] += 1
-
-        # Calculate the new average timing for the function
-        job_stats.timing[fxn] = round(
-            ((job_stats.finished[fxn] - 1) * job_stats.timing[fxn] + elapsed)
-            / job_stats.finished[fxn],
-            4
-        )
-
-        # Clean up if no more running instances of this function
-        if job_stats.running[fxn] == 0:
-            job_stats.running.pop(fxn)
+        # Start job tracking
+        job_stats.start_job(fxn)
+        start = time()
 
-        return result
+        try:
+            result = func(*args, **kwargs)  # Execute the wrapped function
+            return result
+        finally:
+            # Always update statistics, even if function raises exception
+            elapsed = time() - start
+            job_stats.finish_job(fxn, elapsed)
 
     return wrapper
 
@@ -179,7 +212,9 @@ def timeout_enforcer(timeout: int, raise_on_timeout: bool = True):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             """Wrap the function to enforce a timeout on its execution."""
-            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+            with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=1,
+                    thread_name_prefix="TimeoutEnforcer") as executor:
                 future = executor.submit(func, *args, **kwargs)
                 try:
                     return future.result(

{lanscape-1.4.2a3/lanscape/libraries → lanscape-2.1.2/lanscape/core}/device_alive.py

@@ -12,13 +12,14 @@ import psutil
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
 from icmplib import ping
+from icmplib.exceptions import SocketPermissionError
 
-from lanscape.libraries.net_tools import Device
-from lanscape.libraries.scan_config import (
+from lanscape.core.net_tools import Device, DeviceError
+from lanscape.core.scan_config import (
     ScanConfig, ScanType, PingConfig,
     ArpConfig, PokeConfig, ArpCacheConfig
 )
-from lanscape.libraries.decorators import timeout_enforcer, job_tracker
+from lanscape.core.decorators import timeout_enforcer, job_tracker
 
 
 def is_device_alive(device: Device, scan_config: ScanConfig) -> bool:
@@ -72,18 +73,84 @@ class IcmpLookup():
         Returns:
             bool: True if the device is reachable via ICMP, False otherwise.
         """
-        # Perform up to cfg.attempts rounds of ping(count=cfg.ping_count)
-        for _ in range(cfg.attempts):
-            result = ping(
-                device.ip,
-                count=cfg.ping_count,
-                interval=cfg.retry_delay,
-                timeout=cfg.timeout,
-                privileged=psutil.WINDOWS  # Use privileged mode on Windows
-            )
-            if result.is_alive:
-                device.alive = True
-                break
+        try:
+            # Try using icmplib first
+            for _ in range(cfg.attempts):
+                result = ping(
+                    device.ip,
+                    count=cfg.ping_count,
+                    interval=cfg.retry_delay,
+                    timeout=cfg.timeout,
+                    privileged=psutil.WINDOWS  # Use privileged mode on Windows
+                )
+                if result.is_alive:
+                    device.alive = True
+                    break
+            return device.alive is True
+        except SocketPermissionError:
+            # Fallback to system ping command when raw sockets aren't available
+            return cls._ping_fallback(device, cfg)
+
+    @classmethod
+    def _ping_fallback(cls, device: Device, cfg: PingConfig) -> bool:
+        """Fallback ping using system ping command via subprocess.
+
+        Args:
+            device (Device): The device to ping.
+            cfg (PingConfig): The ping configuration.
+
+        Returns:
+            bool: True if the device responds to ping, False otherwise.
+        """
+        cmd = []
+
+        if psutil.WINDOWS:
+            # -n count, -w timeout in ms
+            cmd = ['ping', '-n', str(cfg.ping_count), '-w', str(int(cfg.timeout * 1000)), device.ip]
+        else:  # Linux, macOS, and other Unix-like systems
+            # -c count, -W timeout in s
+            cmd = ['ping', '-c', str(cfg.ping_count), '-W', str(int(cfg.timeout)), device.ip]
+
+        for r in range(cfg.attempts):
+            try:
+                # Remove check=True to handle return codes manually
+                # Add timeout to prevent hanging
+                timeout_val = cfg.timeout * cfg.ping_count + 5
+                proc = subprocess.run(
+                    cmd,
+                    text=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    timeout=timeout_val,
+                    check=False  # Handle return codes manually
+                )
+
+                # Check if ping was successful
+                if proc.returncode == 0:
+                    output = proc.stdout.lower()
+
+                    # Windows/Linux both include "TTL" on a successful reply
+                    if psutil.WINDOWS or psutil.LINUX:
+                        if 'ttl' in output:
+                            device.alive = True
+                            return True  # Early return on success
+
+                    # some distributions of Linux and macOS
+                    if psutil.MACOS or psutil.LINUX:
+                        bad = '100.0% packet loss'
+                        good = 'ping statistics'
+                        # mac doesnt include TTL, so we check good is there, and bad is not
+                        if good in output and bad not in output:
+                            device.alive = True
+                            return True  # Early return on success
+
+            except (subprocess.CalledProcessError, subprocess.TimeoutExpired,
+                    FileNotFoundError) as e:
+                device.caught_errors.append(DeviceError(e))
+
+            if r < cfg.attempts - 1:
+                time.sleep(cfg.retry_delay)
+
         return device.alive is True
 
 
@@ -156,7 +223,7 @@ class ArpLookup():
     NOTE: This lookup method requires elevated privileges to access the ARP cache.
 
 
-    [Arp Lookup Requirements](/support/arp-issues.md)
+    [Arp Lookup Requirements](/docs/arp-issues.md)
     """
 
     @classmethod

{lanscape-1.4.2a3/lanscape/libraries → lanscape-2.1.2/lanscape/core}/ip_parser.py

@@ -10,9 +10,8 @@ This module provides utilities for parsing various IP address formats including:
 It also includes validation to prevent processing excessively large IP ranges.
 """
 import ipaddress
-import re
 
-from lanscape.libraries.errors import SubnetTooLargeError
+from lanscape.core.errors import SubnetTooLargeError
 
 MAX_IPS_ALLOWED = 100000
 
@@ -50,14 +49,10 @@ def parse_ip_input(ip_input):
             for ip in net.hosts():
                 ip_ranges.append(ip)
 
-        # Handle IP range (e.g., 10.0.0.15-10.0.0.25)
+        # Handle IP range (e.g., 10.0.0.15-10.0.0.25) and (e.g., 10.0.9.1-253)
         elif '-' in entry:
             ip_ranges += parse_ip_range(entry)
 
-        # Handle shorthand IP range (e.g., 10.0.9.1-253)
-        elif re.search(r'\d+\-\d+', entry):
-            ip_ranges += parse_shorthand_ip_range(entry)
-
         # If no CIDR or range, assume a single IP
         else:
             ip_ranges.append(ipaddress.IPv4Address(entry))
@@ -106,25 +101,6 @@ def parse_ip_range(entry):
     return list(ip_range_to_list(start_ip, end_ip))
 
 
-def parse_shorthand_ip_range(entry):
-    """
-    Parse a shorthand IP range (e.g., 192.168.1.1-10).
-
-    In this format, only the last octet of the end IP is specified.
-
-    Args:
-        entry (str): String containing a shorthand IP range
-
-    Returns:
-        list: List of IPv4Address objects in the range (inclusive)
-    """
-    start_ip, end_part = entry.split('-')
-    start_ip = ipaddress.IPv4Address(start_ip.strip())
-    end_ip = start_ip.exploded.rsplit('.', 1)[0] + '.' + end_part.strip()
-
-    return list(ip_range_to_list(start_ip, ipaddress.IPv4Address(end_ip)))
-
-
 def ip_range_to_list(start_ip, end_ip):
     """
     Convert an IP range defined by start and end addresses to a list of addresses.