lanscape 2.0.0a2__tar.gz → 2.0.0b1__tar.gz

{lanscape-2.0.0a2/lanscape.egg-info → lanscape-2.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.0.0a2
+Version: 2.0.0b1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -88,7 +88,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.0.0a2 → lanscape-2.0.0b1}/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.0.0a2 → lanscape-2.0.0b1}/lanscape/core/device_alive.py

@@ -156,7 +156,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-2.0.0a2 → lanscape-2.0.0b1}/lanscape/core/ip_parser.py

@@ -10,7 +10,6 @@ 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.core.errors import SubnetTooLargeError
 
@@ -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.

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/lanscape/core/service_scan.py

@@ -2,7 +2,6 @@
 """
 
 from typing import Optional, Union
-import sys
 import asyncio
 import logging
 import traceback
@@ -10,6 +9,9 @@ import traceback
 from lanscape.core.app_scope import ResourceManager
 from lanscape.core.scan_config import ServiceScanConfig, ServiceScanStrategy
 
+# asyncio complains more than it needs to
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+
 log = logging.getLogger('ServiceScan')
 SERVICES = ResourceManager('services').get_jsonc('definitions.jsonc')
 
@@ -183,22 +185,3 @@ def scan_service(ip: str, port: int, cfg: ServiceScanConfig) -> str:
 
     # Use asyncio.run to execute the asynchronous logic synchronously
     return asyncio.run(_async_scan_service(ip, port, cfg=cfg))
-
-
-def asyncio_logger_suppression():
-    """Suppress the noisy asyncio transport errors since they are expected in service scanning."""
-
-    # Reduce noisy asyncio transport errors on Windows by switching to Selector policy
-    if sys.platform.startswith("win"):
-        try:
-            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-        except Exception:
-            pass
-    # Also tone down asyncio logger noise from transport callbacks
-    try:
-        logging.getLogger("asyncio").setLevel(logging.WARNING)
-    except Exception:
-        pass
-
-
-asyncio_logger_suppression()

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/lanscape/ui/templates/scan/config.html

@@ -56,7 +56,7 @@
                                         data-bs-toggle="tooltip"
                                         data-bs-placement="top"
                                         title="ARP lookup is not supported on this system, click for more info"
-                                        onclick="window.open('https://github.com/mdennis281/LANscape/blob/main/support/arp-issues.md', '_blank')"
+                                        onclick="window.open('https://github.com/mdennis281/LANscape/blob/main/docs/arp-issues.md', '_blank')"
                                     >
                                         help
                                     </span>

{lanscape-2.0.0a2 → lanscape-2.0.0b1/lanscape.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 2.0.0a2
+Version: 2.0.0b1
 Summary: A python based local network scanner
 Author-email: Michael Dennis <michael@dipduo.com>
 License-Expression: MIT
@@ -88,7 +88,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.0.0a2 → lanscape-2.0.0b1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lanscape"
-version = "2.0.0a2"
+version = "2.0.0b1"
 authors = [
   { name="Michael Dennis", email="michael@dipduo.com" },
 ]

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_api.py

@@ -4,9 +4,10 @@ Tests REST API endpoints for port management, subnet validation, and scan operat
 """
 import json
 import time
-import pytest
 from unittest.mock import patch
 
+import pytest
+
 from lanscape.ui.app import app
 from lanscape.core.net_tools import get_network_subnet
 
@@ -43,13 +44,14 @@ def test_scan_config():
 # API Port Management Tests
 ###########################
 
+
 def test_port_lifecycle(api_client, sample_port_list, updated_port_list):
     """
     Test the complete lifecycle of port list management through the API.
     Creates, retrieves, updates, and deletes a port list through API endpoints.
     """
     test_list_name = 'test_port_list_lifecycle'
-    
+
     # Delete the new port list if it exists
     api_client.delete(f'/api/port/list/{test_list_name}')
 
@@ -94,6 +96,7 @@ def test_port_lifecycle(api_client, sample_port_list, updated_port_list):
 # API Scan Tests
 ################
 
+
 @pytest.mark.integration
 def test_scan(api_client, sample_port_list, test_scan_config):
     """
@@ -101,7 +104,7 @@ def test_scan(api_client, sample_port_list, test_scan_config):
     Verifies scan creation, status retrieval, and UI rendering for scan results.
     """
     test_list_name = 'test_port_list_scan'
-    
+
     # Delete the new port list if it exists
     api_client.delete(f'/api/port/list/{test_list_name}')
 
@@ -136,12 +139,13 @@ def _render_scan_ui_if_available(api_client, scanid):
     """Helper function to render scan UI if the method is available."""
     try:
         # This would be the equivalent of the original _render_scan_ui method
-        response = api_client.get(f"/scan/{scanid}")
+        _ = api_client.get(f"/scan/{scanid}")
         # We don't assert here since this is an optional UI test
     except Exception:
         # Silently pass if UI rendering is not available
         pass
 
+
 def test_subnet_detection(api_client):
     """
     Test to ensure multi-subnet detection is working
@@ -155,9 +159,10 @@ def test_subnet_detection(api_client):
     subnet: dict = subnets[0]
     assert subnet.get('address_cnt') is not None
 
-# Subnet Validation Tests  
+# Subnet Validation Tests
 ##########################
 
+
 @pytest.mark.parametrize("subnet,expected_count", [
     # Valid subnets
     ('10.0.0.0/24', 254),
@@ -185,10 +190,11 @@ def test_subnet_validation(api_client, subnet, expected_count):
     data: dict = json.loads(response.data)
     assert data.get('count') == expected_count
     assert data.get('msg') is not None
-    
+
     if expected_count == -1:
         assert not data.get('valid')
 
+
 @pytest.mark.parametrize("arp_supported,expected_in,expected_not_in", [
     (False, 'POKE_THEN_ARP', 'ARP_LOOKUP'),
     (True, 'ARP_LOOKUP', None)
@@ -201,12 +207,14 @@ def test_default_scan_configs_arp_handling(api_client, arp_supported, expected_i
     assert response.status_code == 200
     configs = json.loads(response.data)
     accurate_lookup = configs['accurate']['lookup_type']
-    
+
     assert expected_in in accurate_lookup
     if expected_not_in:
         assert expected_not_in not in accurate_lookup
 
 # UI Rendering Helper
+
+
 def _render_scan_ui_comprehensive(api_client, scanid):
     """Test comprehensive UI rendering for a scan."""
     uris = [
@@ -221,8 +229,9 @@ def _render_scan_ui_comprehensive(api_client, scanid):
         response = api_client.get(uri)
         assert response.status_code == 200
 
+
 @pytest.mark.integration
-@pytest.mark.slow  
+@pytest.mark.slow
 def test_scan_api_async(api_client, test_scan_config):
     """
     Test the full scan API lifecycle with progress monitoring
@@ -230,8 +239,8 @@ def test_scan_api_async(api_client, test_scan_config):
     # Create the port list first (since test_scan_config references it)
     sample_port_list = {'80': 'http', '443': 'https'}
     api_client.post('/api/port/list/test_port_list_scan', json=sample_port_list)
-    
-    # Create a new scan 
+
+    # Create a new scan
     response = api_client.post('/api/scan', json=test_scan_config)
     assert response.status_code == 200
     scan_info = json.loads(response.data)
@@ -243,20 +252,20 @@ def test_scan_api_async(api_client, test_scan_config):
     percent_complete = 0
     max_iterations = 30  # Safety limit
     iteration = 0
-    
+
     while percent_complete < 100 and iteration < max_iterations:
         # Get scan summary
         response = api_client.get(f'/api/scan/{scan_id}/summary')
         assert response.status_code == 200
         summary = json.loads(response.data)
         assert summary['running'] or summary['stage'] == 'complete'
-        
+
         percent_complete = summary['percent_complete']
         assert 0 <= percent_complete <= 100
-        
+
         # Test UI rendering during scan
         _render_scan_ui_if_available(api_client, scan_id)
-        
+
         if percent_complete < 100:
             time.sleep(2)
         iteration += 1
@@ -270,5 +279,3 @@ def test_scan_api_async(api_client, test_scan_config):
     devices = summary['devices']
     assert devices['scanned'] == devices['total']
     assert devices['alive'] > 0
-
-

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_decorators.py

@@ -3,9 +3,10 @@
 import logging
 import threading
 import time
-import pytest
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+import pytest
+
 from lanscape.core.decorators import run_once, job_tracker, JobStats
 
 
@@ -311,15 +312,15 @@ def test_job_tracker_multiple_different_functions():
 ])
 def test_job_tracker_parametrized_function_calls(function_name, expected_calls):
     """Test parametrized validation of function call counts."""
-    
+
     @job_tracker
     def function_a():
         return "a"
-        
-    @job_tracker 
+
+    @job_tracker
     def function_b():
         return "b"
-        
+
     # Execute functions based on expected calls
     if function_name == "function_a":
         for _ in range(expected_calls):
@@ -327,6 +328,6 @@ def test_job_tracker_parametrized_function_calls(function_name, expected_calls):
     elif function_name == "function_b":
         for _ in range(expected_calls):
             function_b()
-    
+
     stats = JobStats()
     assert stats.finished[function_name] == expected_calls

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_env.py

@@ -4,9 +4,10 @@ Verifies functionality related to version checking, resource management,
 execution environment detection, and network support features.
 """
 
-import pytest
 from unittest.mock import patch, MagicMock
 
+import pytest
+
 from lanscape.core.version_manager import lookup_latest_version
 from lanscape.core.app_scope import ResourceManager, is_local_run
 from lanscape.core.net_tools import is_arp_supported
@@ -27,15 +28,14 @@ def mock_resource_manager():
 def test_version_lookup_returns_valid_version():
     """Test that the version lookup functionality returns a valid version string."""
     version = lookup_latest_version()
-    
+
     assert version is not None
     assert isinstance(version, str)
     # Basic version pattern check (should contain digits and dots)
     assert any(char.isdigit() for char in version)
 
 
-@pytest.mark.parametrize("expected_type", [str, type(None)])
-def test_version_lookup_return_type(expected_type):
+def test_version_lookup_return_type():
     """Test version lookup returns expected type."""
     version = lookup_latest_version()
     if version is not None:
@@ -52,7 +52,7 @@ def test_resource_manager_lists_ports():
     """Test the ResourceManager can list port resources."""
     ports = ResourceManager('ports')
     port_list = ports.list()
-    
+
     assert len(port_list) > 0
     assert isinstance(port_list, list)
 
@@ -61,7 +61,7 @@ def test_resource_manager_retrieves_mac_database():
     """Test ResourceManager can retrieve MAC address database."""
     mac = ResourceManager('mac_addresses')
     mac_list = mac.get('mac_db.json')
-    
+
     assert mac_list is not None
 
 
@@ -72,7 +72,7 @@ def test_resource_manager_retrieves_mac_database():
 def test_resource_manager_methods(resource_type, expected_method):
     """Test ResourceManager has required methods for different resource types."""
     manager = ResourceManager(resource_type)
-    
+
     assert hasattr(manager, expected_method)
     assert callable(getattr(manager, expected_method))
 
@@ -81,7 +81,7 @@ def test_resource_manager_with_mock(mock_resource_manager):
     """Test ResourceManager behavior with mocked dependencies."""
     mock_resource_manager.list.return_value = ['port1', 'port2']
     mock_resource_manager.get.return_value = {'test': 'data'}
-    
+
     # Test the mock behavior
     assert mock_resource_manager.list() == ['port1', 'port2']
     assert mock_resource_manager.get('test') == {'test': 'data'}
@@ -93,7 +93,7 @@ def test_resource_manager_with_mock(mock_resource_manager):
 def test_local_run_detection():
     """Test that the app correctly identifies it's running in a local environment."""
     result = is_local_run()
-    
+
     assert isinstance(result, bool)
     assert result is True  # Should be True in test environment
 
@@ -101,17 +101,17 @@ def test_local_run_detection():
 def test_arp_support_detection():
     """Test that ARP support detection returns a valid boolean value."""
     arp_supported = is_arp_supported()
-    
+
     assert isinstance(arp_supported, bool)
     assert arp_supported in [True, False]
 
 
 @pytest.mark.parametrize("platform,expected", [
     ("win32", True),    # Windows typically supports ARP
-    ("linux", True),    # Linux typically supports ARP  
+    ("linux", True),    # Linux typically supports ARP
     ("darwin", True),   # macOS typically supports ARP
 ])
-def test_arp_support_by_platform(platform, expected):
+def test_arp_support_by_platform(platform, expected):  # pylint: disable=unused-argument
     """Test ARP support expectations by platform (informational test)."""
     with patch('sys.platform', platform):
         # This is more of an informational test about expectations
@@ -128,20 +128,20 @@ def test_environment_integration():
     """Integration test verifying all environment components work together."""
     # Test version lookup
     version = lookup_latest_version()
-    
-    # Test resource access  
+
+    # Test resource access
     ports_rm = ResourceManager('ports')
-    mac_rm = ResourceManager('mac_addresses')
-    
+    _ = ResourceManager('mac_addresses')  # MAC database is optional
+
     # Test environment detection
     is_local = is_local_run()
     arp_support = is_arp_supported()
-    
+
     # Basic assertions that everything returns reasonable values
     if version is not None:
         assert isinstance(version, str)
-    
+
     assert len(ports_rm.list()) >= 0
-    assert mac_rm.get('mac_db.json') is not None or True  # Allow flexibility
-    assert isinstance(is_local, bool) 
+    # MAC DB is optional, don't assert presence
+    assert isinstance(is_local, bool)
     assert isinstance(arp_support, bool)

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_library.py

@@ -56,6 +56,7 @@ def test_scan_config():
     assert cfg2.arp_config.timeout == arp_timeout
     assert cfg2.lookup_type == [ScanType.POKE_THEN_ARP]
 
+
 @pytest.mark.integration
 @pytest.mark.slow
 def test_scan(scan_manager):
@@ -65,7 +66,7 @@ def test_scan(scan_manager):
     """
     subnet = smart_select_primary_subnet()
     assert subnet is not None
-    
+
     cfg = ScanConfig(
         subnet=right_size_subnet(subnet),
         t_multiplier=1.0,

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_logging.py

@@ -5,12 +5,12 @@ Tests include log file creation, CLI logging settings, and runtime arguments for
 
 import logging
 import os
+import shutil
 import tempfile
-import pytest
 from logging.handlers import RotatingFileHandler
 from unittest.mock import patch
 
-# Third-party imports - ensure 'click' is installed with 'pip install click'
+import pytest
 import click
 
 from lanscape.core.logger import configure_logging
@@ -21,7 +21,7 @@ from lanscape.core.runtime_args import parse_args
 def logging_cleanup():
     """Clean up logging after test (manual use)."""
     yield
-    
+
     # Cleanup after test
     root = logging.getLogger()
     for handler in root.handlers[:]:
@@ -39,52 +39,53 @@ def test_configure_logging_writes_file():
     root_logger = logging.getLogger()
     original_handlers = root_logger.handlers[:]
     root_logger.handlers.clear()
-    
+
     tmpdir = tempfile.mkdtemp()
     try:
         logfile = os.path.join(tmpdir, 'test.log')
         configure_logging('INFO', logfile, flask_logging=True)
         logging.getLogger('test').info('hello file')
-        
+
         # Flush all handlers to ensure content is written
         for handler in logging.getLogger().handlers:
             handler.flush()
-        
+
         # Read the file contents
         with open(logfile, 'r', encoding='utf-8') as fh:
             contents = fh.read()
-        
+
         # Clean up handlers to release file locks
         for handler in logging.getLogger().handlers[:]:
             if hasattr(handler, 'close'):
                 handler.close()
         logging.getLogger().handlers.clear()
-        
+
         assert 'hello file' in contents
-        
+
     finally:
         # Restore original handlers
         root_logger.handlers = original_handlers
-        
+
         # Clean up the temp directory
-        import shutil
         try:
             shutil.rmtree(tmpdir)
         except PermissionError:
             # On Windows, sometimes files are still locked, ignore cleanup errors
             pass
-def test_configure_logging_without_file(logging_cleanup):
+
+
+def test_configure_logging_without_file(logging_cleanup):  # pylint: disable=unused-argument
     """Test that no file handlers are created when no log file is specified."""
     configure_logging('INFO', None, flask_logging=True)
     root_handlers = logging.getLogger().handlers
     assert all(not isinstance(h, RotatingFileHandler) for h in root_handlers)
 
 
-def test_disable_flask_logging_overrides_click(logging_cleanup):
+def test_disable_flask_logging_overrides_click(logging_cleanup):  # pylint: disable=unused-argument
     """Test that disabling Flask logging properly overrides click echo functions."""
     original_click_echo = click.echo
     original_click_secho = click.secho
-    
+
     configure_logging('INFO', None, flask_logging=False)
     assert click.echo != original_click_echo
     assert click.secho != original_click_secho

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_port_scan.py

@@ -3,9 +3,10 @@ Tests for port scanning functionality including the new PortScanConfig
 retry logic and timeout enforcement.
 """
 
-import pytest
-from unittest.mock import patch, MagicMock
 from time import time
+from unittest.mock import patch, MagicMock
+
+import pytest
 
 from lanscape.core.net_tools import Device
 from lanscape.core.scan_config import PortScanConfig
@@ -35,6 +36,7 @@ def retry_port_config():
 # PortScanConfig Tests
 ######################
 
+
 def test_port_scan_config_defaults():
     """Test PortScanConfig default values."""
     config = PortScanConfig()
@@ -80,6 +82,7 @@ def test_port_scan_config_serialization():
 # Device Port Testing
 ####################
 
+
 def test_device_test_port_with_default_config(test_device, default_port_config):
     """Test Device.test_port with default PortScanConfig."""
     # Test with a port that should be closed
@@ -98,6 +101,7 @@ def test_device_test_port_without_config(test_device):
     assert isinstance(result, bool)
     assert test_device.ports_scanned == initial_count + 1
 
+
 @patch('socket.socket')
 def test_device_test_port_with_retries(mock_socket_class, test_device):
     """Test Device.test_port retry mechanism."""
@@ -167,6 +171,7 @@ def test_device_test_port_exception_handling(mock_socket_class, test_device):
 # Timeout and Configuration Tests
 ##################################
 
+
 @pytest.mark.parametrize("timeout,retries,expected_enforcer_timeout", [
     (1.0, 0, 1.5),      # 1.0 * (0 + 1) * 1.5 = 1.5
     (2.0, 2, 9.0),      # 2.0 * (2 + 1) * 1.5 = 9.0
@@ -176,11 +181,12 @@ def test_device_test_port_exception_handling(mock_socket_class, test_device):
 def test_timeout_enforcer_calculation(timeout, retries, expected_enforcer_timeout):
     """Test that timeout enforcer uses correct formula."""
     config = PortScanConfig(timeout=timeout, retries=retries, retry_delay=0.1)
-    
+
     # Formula: timeout * (retries + 1) * 1.5
     calculated_timeout = config.timeout * (config.retries + 1) * 1.5
     assert calculated_timeout == expected_enforcer_timeout
 
+
 def test_device_ports_scanned_counter(test_device, default_port_config):
     """Test that ports_scanned counter is properly incremented."""
     initial_count = test_device.ports_scanned

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_service_scan.py

@@ -3,18 +3,17 @@ Dedicated tests for service scanning functionality.
 Tests the service_scan module including async probing, service identification,
 and configuration handling.
 """
-import logging
 import asyncio
-import pytest
 from unittest.mock import patch, AsyncMock, MagicMock
 
+import pytest
+
 from lanscape.core.service_scan import (
     scan_service,
     get_port_probes,
     _try_probe,
     _multi_probe_generic,
-    PRINTER_PORTS,
-    asyncio_logger_suppression
+    PRINTER_PORTS
 )
 from lanscape.core.scan_config import ServiceScanConfig, ServiceScanStrategy
 
@@ -50,6 +49,7 @@ def aggressive_config():
 # Strategy and Probe Generation Tests
 ####################################
 
+
 def test_service_scan_strategy_enum():
     """Test ServiceScanStrategy enum values."""
     assert ServiceScanStrategy.LAZY.value == 'LAZY'
@@ -73,6 +73,7 @@ def test_get_port_probes_lazy_strategy():
     http_probes = [p for p in probes if p and b"HTTP" in p]
     assert len(http_probes) > 0
 
+
 @pytest.mark.parametrize("port", [22, 80, 443])
 def test_get_port_probes_basic_strategy(port):
     """Test probe generation for BASIC strategy."""
@@ -152,7 +153,7 @@ def test_concurrent_probe_limits():
     assert isinstance(result2, str)
 
 
-# Async Probe Tests 
+# Async Probe Tests
 ##################
 
 def test_try_probe_success():
@@ -211,19 +212,6 @@ def test_multi_probe_generic_no_response():
     asyncio.run(run_test())
 
 
-# Logger and Integration Tests
-#############################
-
-def test_asyncio_logger_suppression():
-    """Test that asyncio logger suppression works."""
-    # This should not raise any exceptions
-    asyncio_logger_suppression()
-
-    # Verify that asyncio logger level was changed
-    asyncio_logger = logging.getLogger("asyncio")
-    assert asyncio_logger.level >= logging.WARNING
-
-
 @pytest.mark.integration
 def test_service_scan_integration():
     """Integration test for full service scanning workflow."""
@@ -280,4 +268,3 @@ def test_probe_payload_types():
 
     assert has_none, "Should include None for banner grab"
     assert has_bytes, "Should include bytes payloads"
-

{lanscape-2.0.0a2 → lanscape-2.0.0b1}/tests/test_utils.py

@@ -3,9 +3,10 @@ Unit tests for various utility modules in the LANscape project.
 Tests include IP parsing, port management, and decorator functionality.
 """
 
+import ipaddress
 import time
+
 import pytest
-import ipaddress
 
 from lanscape.core.ip_parser import parse_ip_input
 from lanscape.core.errors import SubnetTooLargeError
@@ -37,7 +38,7 @@ def test_parse_cidr_specific():
 def test_parse_range_length_and_bounds():
     """Test explicit IP range parsing validates length and boundaries."""
     ips = parse_ip_input('10.0.0.1-10.0.0.3')
-    
+
     assert len(ips) == 3
     assert str(ips[0]) == '10.0.0.1'
     assert str(ips[-1]) == '10.0.0.3'
@@ -53,7 +54,7 @@ def test_parse_mixed_format_comprehensive():
     """Test parsing a comprehensive mix of CIDR, range, and individual IP formats."""
     ip_input = "10.0.0.1/30, 10.0.0.10-10.0.0.12, 10.0.0.20-22, 10.0.0.50"
     result = ip_parser.parse_ip_input(ip_input)
-    
+
     expected = [
         ipaddress.IPv4Address("10.0.0.1"),
         ipaddress.IPv4Address("10.0.0.2"),
@@ -65,7 +66,7 @@ def test_parse_mixed_format_comprehensive():
         ipaddress.IPv4Address("10.0.0.22"),
         ipaddress.IPv4Address("10.0.0.50"),
     ]
-    
+
     assert result == expected
 
 
@@ -106,35 +107,35 @@ def test_port_manager_allows_empty_service_name(port_manager):
 
 def test_timeout_enforcer_no_raise():
     """Test timeout_enforcer with raise_on_timeout=False returns None on timeout."""
-    
+
     @timeout_enforcer(0.1, raise_on_timeout=False)
     def slow_function():
         time.sleep(0.5)
         return "should_not_return"
-    
+
     result = slow_function()
     assert result is None
 
 
 def test_timeout_enforcer_with_raise():
     """Test timeout_enforcer with raise_on_timeout=True raises TimeoutError."""
-    
+
     @timeout_enforcer(0.1, raise_on_timeout=True)
     def slow_function():
         time.sleep(0.5)
         return "should_not_return"
-    
+
     with pytest.raises(TimeoutError):
         slow_function()
 
 
 def test_timeout_enforcer_fast_function():
     """Test timeout_enforcer allows fast functions to complete normally."""
-    
+
     @timeout_enforcer(1.0, raise_on_timeout=True)
     def fast_function():
         return "completed"
-    
+
     result = fast_function()
     assert result == "completed"
 
@@ -145,12 +146,12 @@ def test_timeout_enforcer_fast_function():
 ])
 def test_timeout_enforcer_parametrized(timeout, raise_flag, expected_exception):
     """Test timeout_enforcer with different timeout values and raise settings."""
-    
+
     @timeout_enforcer(timeout, raise_on_timeout=raise_flag)
     def slow_function():
         time.sleep(0.2)
         return "done"
-    
+
     if raise_flag:
         with pytest.raises(expected_exception):
             slow_function()