lanscape 1.4.4__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

lanscape/__init__.py

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

lanscape/__main__.py

@@ -7,3 +7,4 @@ from lanscape.ui.main import main
 
 if __name__ == "__main__":
     main()
+

lanscape/{libraries → 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):
@@ -72,3 +90,4 @@ def is_local_run() -> bool:
     if any(parts):
         return False
     return True  # Installed package
+

lanscape/{libraries → 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()
 
-        result = func(*args, **kwargs)  # Execute the wrapped function
+        # Determine function name for tracking
+        if args:
+            fxn = get_fxn_src_name(func, args[0])
+        else:
+            fxn = func.__name__
 
-        # 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(
@@ -194,3 +229,4 @@ def timeout_enforcer(timeout: int, raise_on_timeout: bool = True):
                     return None  # Return None if not raising an exception
         return wrapper
     return decorator
+

lanscape/{libraries → core}/device_alive.py

@@ -13,12 +13,12 @@ from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
 from icmplib import ping
 
-from lanscape.libraries.net_tools import Device
-from lanscape.libraries.scan_config import (
+from lanscape.core.net_tools import Device
+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:
@@ -227,3 +227,4 @@ class Poker():
                 sock.close()
 
         do_poke()
+

lanscape/{libraries → core}/errors.py

@@ -40,3 +40,4 @@ class DeviceError(Exception):
 
     def __str__(self):
         return f'Error(source={self.method}, msg={self.base})'
+

lanscape/{libraries → core}/ip_parser.py

@@ -12,7 +12,7 @@ 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
 
@@ -139,3 +139,4 @@ def ip_range_to_list(start_ip, end_ip):
     # Yield the range of IPs
     for ip_int in range(int(start_ip), int(end_ip) + 1):
         yield ipaddress.IPv4Address(ip_int)
+

lanscape/{libraries → core}/logger.py

@@ -72,3 +72,4 @@ def disable_flask_logging() -> None:
     werkzeug_log.setLevel(logging.ERROR)
 
     override_click_logging()
+

lanscape/{libraries → core}/mac_lookup.py

@@ -105,3 +105,4 @@ def lookup_mac(mac: str) -> Optional[str]:
 def get_macs(ip: str) -> List[str]:
     """Backward compatibility function for MAC resolution."""
     return MacResolver().get_macs(ip)
+

lanscape/{libraries → core}/net_tools.py

@@ -1,44 +1,97 @@
 """Network tools for scanning and managing devices on a network."""
 
-import logging
 import ipaddress
-import traceback
-import subprocess
-from typing import List, Dict
+import logging
+import re
 import socket
 import struct
-import re
-import psutil
+import subprocess
+import traceback
+from time import sleep
+from typing import List, Dict, Optional
 
+import psutil
 from scapy.sendrecv import srp
 from scapy.layers.l2 import ARP, Ether
 from scapy.error import Scapy_Exception
 
-from lanscape.libraries.service_scan import scan_service
-from lanscape.libraries.mac_lookup import MacLookup, get_macs
-from lanscape.libraries.ip_parser import get_address_count, MAX_IPS_ALLOWED
-from lanscape.libraries.errors import DeviceError
-from lanscape.libraries.decorators import job_tracker, run_once
+from pydantic import BaseModel, PrivateAttr
+try:
+    from pydantic import ConfigDict, computed_field, model_serializer  # pydantic v2
+    _PYD_V2 = True
+except Exception:  # pragma: no cover
+    CONFIG_DICT = None  # type: ignore  # pylint: disable=invalid-name
+    COMPUTED_FIELD = None  # type: ignore  # pylint: disable=invalid-name
+    MODEL_SERIALIZER = None  # type: ignore  # pylint: disable=invalid-name
+    _PYD_V2 = False
+else:
+    CONFIG_DICT = ConfigDict  # pylint: disable=invalid-name
+    COMPUTED_FIELD = computed_field  # pylint: disable=invalid-name
+    MODEL_SERIALIZER = model_serializer  # pylint: disable=invalid-name
+
+from lanscape.core.service_scan import scan_service
+from lanscape.core.mac_lookup import MacLookup, get_macs
+from lanscape.core.ip_parser import get_address_count, MAX_IPS_ALLOWED
+from lanscape.core.errors import DeviceError
+from lanscape.core.decorators import job_tracker, run_once, timeout_enforcer
+from lanscape.core.scan_config import ServiceScanConfig, PortScanConfig
 
 log = logging.getLogger('NetTools')
 mac_lookup = MacLookup()
 
 
-class Device:
+class Device(BaseModel):
     """Represents a network device with metadata and scanning capabilities."""
 
-    def __init__(self, ip: str):
-        super().__init__()
-        self.ip: str = ip
-        self.alive: bool = None
-        self.hostname: str = None
-        self.macs: List[str] = []
-        self.manufacturer: str = None
-        self.ports: List[int] = []
-        self.stage: str = 'found'
-        self.services: Dict[str, List[int]] = {}
-        self.caught_errors: List[DeviceError] = []
-        self.log = logging.getLogger('Device')
+    ip: str
+    alive: Optional[bool] = None
+    hostname: Optional[str] = None
+    macs: List[str] = []
+    manufacturer: Optional[str] = None
+    ports: List[int] = []
+    stage: str = 'found'
+    ports_scanned: int = 0
+    services: Dict[str, List[int]] = {}
+    caught_errors: List[DeviceError] = []
+    job_stats: Optional[Dict] = None
+
+    _log: logging.Logger = PrivateAttr(default_factory=lambda: logging.getLogger('Device'))
+    # Support pydantic v1 and v2 configs
+    if _PYD_V2 and CONFIG_DICT:
+        model_config = CONFIG_DICT(arbitrary_types_allowed=True)  # type: ignore[assignment]
+    else:  # pragma: no cover
+        class Config:  # pylint: disable=too-few-public-methods
+            """Pydantic v1 configuration."""
+            arbitrary_types_allowed = True
+            extra = 'allow'
+
+    @property
+    def log(self) -> logging.Logger:
+        """Get the logger instance for this device."""
+        return self._log
+
+    # Computed fields for pydantic v2 (included in model_dump)
+    if _PYD_V2 and COMPUTED_FIELD:
+        @COMPUTED_FIELD(return_type=str)  # type: ignore[misc]
+        @property
+        def mac_addr(self) -> str:
+            """Get the primary MAC address for this device."""
+            return self.get_mac() or ""
+
+        @MODEL_SERIALIZER(mode='wrap')  # type: ignore[misc]
+        def _serialize(self, serializer):
+            """Serialize device data for output."""
+            data = serializer(self)
+            # Remove internals
+            data.pop('job_stats', None)
+            # Ensure mac_addr present (computed_field already adds it)
+            data['mac_addr'] = data.get('mac_addr') or (self.get_mac() or '')
+            # Ensure manufacturer present; prefer explicit model value
+            manuf = data.get('manufacturer')
+            if not manuf:
+                data['manufacturer'] = self._get_manufacturer(
+                    data['mac_addr']) if data['mac_addr'] else None
+            return data
 
     def get_metadata(self):
         """Retrieve metadata such as hostname and MAC addresses."""
@@ -46,32 +99,72 @@ class Device:
             self.hostname = self._get_hostname()
             self._get_mac_addresses()
 
-    def dict(self) -> dict:
-        """Convert the device object to a dictionary."""
-        obj = vars(self).copy()
-        obj.pop('log')
-        obj.pop('job_stats', None)  # Remove job_stats if it exists
-        primary_mac = self.get_mac()
-        obj['mac_addr'] = primary_mac
-        obj['manufacturer'] = self._get_manufacturer(primary_mac)
-
-        return obj
-
-    def test_port(self, port: int) -> bool:
+    # Fallback for pydantic v1: use dict() and enrich output
+    if not _PYD_V2:
+        def dict(self, *args, **kwargs) -> dict:  # type: ignore[override]
+            """Generate dictionary representation for pydantic v1."""
+            data = super().dict(*args, **kwargs)
+            data.pop('job_stats', None)
+            mac_addr = self.get_mac() or ''
+            data['mac_addr'] = mac_addr
+            if not data.get('manufacturer'):
+                data['manufacturer'] = self._get_manufacturer(mac_addr) if mac_addr else None
+            return data
+    else:
+        # In v2, route dict() to model_dump() so callers get the serialized enrichment
+        def dict(self, *args, **kwargs) -> dict:  # type: ignore[override]
+            """Generate dictionary representation for pydantic v2."""
+            try:
+                return self.model_dump(*args, **kwargs)  # type: ignore[attr-defined]
+            except Exception:
+                # Safety fallback (shouldn't normally hit)
+                data = self.__dict__.copy()
+                data.pop('_log', None)
+                data.pop('job_stats', None)
+                mac_addr = self.get_mac() or ''
+                data['mac_addr'] = mac_addr
+                if not data.get('manufacturer'):
+                    data['manufacturer'] = self._get_manufacturer(mac_addr) if mac_addr else None
+                return data
+
+    def test_port(self, port: int, port_config: Optional[PortScanConfig] = None) -> bool:
         """Test if a specific port is open on the device."""
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(1)
-        result = sock.connect_ex((self.ip, port))
-        sock.close()
-        if result == 0:
-            self.ports.append(port)
-            return True
-        return False
+        if port_config is None:
+            port_config = PortScanConfig()  # Use defaults
+
+        # Calculate timeout enforcer: (timeout * (retries+1) * 1.5)
+        enforcer_timeout = port_config.timeout * (port_config.retries + 1) * 1.5
+
+        @timeout_enforcer(enforcer_timeout, False)
+        def do_test():
+            for attempt in range(port_config.retries + 1):
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(port_config.timeout)
+                try:
+                    result = sock.connect_ex((self.ip, port))
+                    if result == 0:
+                        if port not in self.ports:
+                            self.ports.append(port)
+                        return True
+                except Exception:
+                    pass  # Connection failed, try again if retries remain
+                finally:
+                    sock.close()
+
+                # Wait before retry (except on last attempt)
+                if attempt < port_config.retries:
+                    sleep(port_config.retry_delay)
+
+            return False
+
+        ans = do_test() or False
+        self.ports_scanned += 1
+        return ans
 
     @job_tracker
-    def scan_service(self, port: int):
+    def scan_service(self, port: int, cfg: ServiceScanConfig):
         """Scan a specific port for services."""
-        service = scan_service(self.ip, port)
+        service = scan_service(self.ip, port, cfg)
         service_ports = self.services.get(service, [])
         service_ports.append(port)
         self.services[service] = service_ports
@@ -473,3 +566,4 @@ def is_arp_supported():
         return True
     except (Scapy_Exception, PermissionError, RuntimeError):
         return False
+

lanscape/{libraries → core}/port_manager.py

@@ -148,3 +148,4 @@ class PortManager:
             return True
         except BaseException:
             return False
+

lanscape/{libraries → core}/runtime_args.py

@@ -63,3 +63,4 @@ def parse_args() -> RuntimeArgs:
 
     # Return the dataclass instance with the dynamically assigned values
     return RuntimeArgs(**filtered_args)
+