lanscape 1.3.8a1__py3-none-any.whl → 2.4.0a2__py3-none-any.whl

lanscape/ui/ws/server.py

@@ -0,0 +1,375 @@
+"""
+WebSocket server for LANscape.
+
+Provides an async WebSocket server that can run independently of the Flask UI.
+Handles client connections, message routing, and real-time scan updates.
+"""
+
+import asyncio
+import json
+import logging
+import uuid
+from typing import Optional
+
+import websockets
+from websockets.server import WebSocketServerProtocol
+
+from lanscape.ui.ws.protocol import (
+    WSRequest,
+    WSResponse,
+    WSError,
+    WSEvent
+)
+from lanscape.ui.ws.handlers import (
+    ScanHandler,
+    PortHandler,
+    ToolsHandler
+)
+
+class WebSocketServer:
+    """
+    Async WebSocket server for LANscape.
+
+    Provides a standalone WebSocket interface to all LANscape functionality.
+    Supports real-time scan updates via subscriptions.
+    """
+
+    DEFAULT_HOST = 'localhost'
+    DEFAULT_PORT = 8766
+
+    def __init__(self, host: str = DEFAULT_HOST, port: int = DEFAULT_PORT):
+        """
+        Initialize the WebSocket server.
+
+        Args:
+            host: Host to bind to (default: 0.0.0.0)
+            port: Port to listen on (default: 8766)
+        """
+        self.host = host
+        self.port = port
+        self.log = logging.getLogger('WebSocketServer')
+
+        # Initialize handlers
+        self._scan_handler = ScanHandler()
+        self._port_handler = PortHandler()
+        self._tools_handler = ToolsHandler()
+
+        self._handlers = [
+            self._scan_handler,
+            self._port_handler,
+            self._tools_handler
+        ]
+
+        # Active connections
+        self._clients: dict[str, WebSocketServerProtocol] = {}
+
+        # Track scans that were running (to detect completion)
+        self._previously_running_scans: set[str] = set()
+
+        # Server instance
+        self._server = None
+        self._running = False
+
+        # Background tasks
+        self._update_task: Optional[asyncio.Task] = None
+
+    def get_actions(self) -> list[str]:
+        """
+        Get all supported actions.
+
+        Returns:
+            List of all action names supported by all handlers
+        """
+        actions = []
+        for handler in self._handlers:
+            actions.extend(handler.get_actions())
+        return actions
+
+    async def start(self) -> None:
+        """Start the WebSocket server."""
+        self.log.info(f"Starting WebSocket server on ws://{self.host}:{self.port}")
+
+        self._running = True
+
+        # Minimal WebSocket server configuration - let the library handle everything
+        self._server = await websockets.serve(
+            self._handle_connection,
+            self.host,
+            self.port
+        )
+
+        # Start the background update task
+        self._update_task = asyncio.create_task(self._broadcast_scan_updates())
+
+        self.log.info("WebSocket server started")
+
+    async def stop(self) -> None:
+        """Stop the WebSocket server."""
+        self.log.info("Stopping WebSocket server...")
+        self._running = False
+
+        if self._update_task:
+            self._update_task.cancel()
+            try:
+                await self._update_task
+            except asyncio.CancelledError:
+                pass
+
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+
+        # Close all client connections
+        for client_id, ws in list(self._clients.items()):
+            try:
+                await ws.close()
+            except Exception as e:
+                self.log.debug(f"Error closing client {client_id}: {e}")
+
+        self._clients.clear()
+        self.log.info("WebSocket server stopped")
+
+    async def serve_forever(self) -> None:
+        """Run the server until stopped."""
+        await self.start()
+        try:
+            await self._server.wait_closed()
+        except asyncio.CancelledError:
+            await self.stop()
+
+    async def _handle_connection(
+        self,
+        websocket: WebSocketServerProtocol
+    ) -> None:
+        """
+        Handle a new WebSocket connection.
+
+        Args:
+            websocket: The WebSocket connection
+        """
+        client_id = str(uuid.uuid4())
+        self._clients[client_id] = websocket
+        self.log.info(f"Client connected: {client_id}")
+
+        # Send welcome message with client_id
+        await self._send_event(
+            websocket,
+            'connection.established',
+            {'client_id': client_id, 'actions': self.get_actions()}
+        )
+
+        try:
+            async for message in websocket:
+                await self._handle_message(client_id, websocket, message)
+        except websockets.ConnectionClosed:
+            self.log.info(f"Client disconnected: {client_id}")
+        except Exception as e:
+            self.log.error(f"Error handling client {client_id}: {e}")
+        finally:
+            self._cleanup_client(client_id)
+
+    async def _handle_message(
+        self,
+        client_id: str,
+        websocket: WebSocketServerProtocol,
+        message: str
+    ) -> None:
+        """
+        Handle an incoming WebSocket message.
+
+        Args:
+            client_id: The client identifier
+            websocket: The WebSocket connection
+            message: The raw message string
+        """
+        try:
+            data = json.loads(message)
+            request = WSRequest.model_validate(data)
+        except json.JSONDecodeError as e:
+            error = WSError(error=f"Invalid JSON: {e}")
+            await self._send(websocket, error)
+            return
+        except Exception as e:
+            error = WSError(error=f"Invalid request format: {e}")
+            await self._send(websocket, error)
+            return
+
+        self.log.debug(f"[{client_id}] Request: {request.action}")
+
+        # Find the appropriate handler
+        response = None
+        for handler in self._handlers:
+            if handler.can_handle(request.action):
+                # Create a send_event callback for this client
+                async def send_event(event: str, data: dict) -> None:
+                    await self._send_event(websocket, event, data)
+
+                response = await handler.handle(request, send_event)
+                break
+
+        if response is None:
+            response = WSError(
+                id=request.id,
+                action=request.action,
+                error=f"Unknown action: {request.action}. "
+                      f"Available actions: {self.get_actions()}"
+            )
+
+        await self._send(websocket, response)
+
+    async def _send(
+        self,
+        websocket: WebSocketServerProtocol,
+        message: WSResponse | WSError | WSEvent
+    ) -> None:
+        """
+        Send a message to a client.
+
+        Args:
+            websocket: The WebSocket connection
+            message: The message to send
+        """
+        try:
+            await websocket.send(message.model_dump_json())
+        except websockets.ConnectionClosed:
+            pass
+        except Exception as e:
+            self.log.error(f"Error sending message: {e}")
+
+    async def _send_event(
+        self,
+        websocket: WebSocketServerProtocol,
+        event: str,
+        data: dict
+    ) -> None:
+        """
+        Send an event to a client.
+
+        Args:
+            websocket: The WebSocket connection
+            event: The event name
+            data: The event data
+        """
+        message = WSEvent(event=event, data=data)
+        await self._send(websocket, message)
+
+    async def _broadcast_scan_updates(self) -> None:
+        """
+        Background task to broadcast scan updates to subscribed clients.
+
+        Sends delta updates every 500ms for active scans.
+        """
+        while self._running:
+            try:
+                await asyncio.sleep(0.5)
+                await self._send_updates_for_active_scans()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.log.error(f"Error in broadcast loop: {e}")
+
+    async def _send_updates_for_active_scans(self) -> None:
+        """Send delta updates for all active scans to subscribed clients."""
+        # pylint: disable=protected-access
+        currently_running = set()
+
+        for scan in self._scan_handler._scan_manager.scans:
+            if scan.running:
+                currently_running.add(scan.uid)
+                await self._send_scan_update_to_subscribers(scan)
+            elif scan.uid in self._previously_running_scans:
+                # Scan just completed - send final update with complete event
+                await self._send_scan_complete_to_subscribers(scan)
+
+        # Update tracking set
+        self._previously_running_scans = currently_running
+
+    async def _send_scan_complete_to_subscribers(self, scan) -> None:
+        """Send scan complete event to all subscribed clients."""
+        subscribed_clients = self._scan_handler.get_subscriptions(scan.uid)
+
+        for client_id in subscribed_clients:
+            websocket = self._clients.get(client_id)
+            if websocket is None:
+                continue
+
+            try:
+                # Send final delta with all remaining changes
+                # pylint: disable=protected-access
+                delta = self._scan_handler._handle_get_delta(
+                    {'scan_id': scan.uid, 'client_id': client_id},
+                    None
+                )
+                # Force the complete stage in metadata
+                if 'metadata' in delta:
+                    delta['metadata']['running'] = False
+                    delta['metadata']['stage'] = 'complete'
+
+                await self._send_event(websocket, 'scan.complete', delta)
+            except Exception as e:
+                self.log.debug(f"Error sending complete to {client_id}: {e}")
+
+    async def _send_scan_update_to_subscribers(self, scan) -> None:
+        """Send scan update to all subscribed clients."""
+        subscribed_clients = self._scan_handler.get_subscriptions(scan.uid)
+
+        for client_id in subscribed_clients:
+            websocket = self._clients.get(client_id)
+            if websocket is None:
+                continue
+
+            await self._try_send_delta_update(websocket, scan.uid, client_id)
+
+    async def _try_send_delta_update(
+        self,
+        websocket: WebSocketServerProtocol,
+        scan_id: str,
+        client_id: str
+    ) -> None:
+        """Try to send a delta update to a client."""
+        try:
+            # pylint: disable=protected-access
+            delta = self._scan_handler._handle_get_delta(
+                {'scan_id': scan_id, 'client_id': client_id},
+                None
+            )
+
+            if delta.get('has_changes'):
+                await self._send_event(websocket, 'scan.update', delta)
+        except Exception as e:
+            self.log.debug(f"Error sending update to {client_id}: {e}")
+
+    def _cleanup_client(self, client_id: str) -> None:
+        """
+        Clean up resources for a disconnected client.
+
+        Args:
+            client_id: The client identifier
+        """
+        self._clients.pop(client_id, None)
+        self._scan_handler.cleanup_client(client_id)
+        self.log.debug(f"Cleaned up client: {client_id}")
+
+
+def run_server(host: str = WebSocketServer.DEFAULT_HOST,
+               port: int = WebSocketServer.DEFAULT_PORT) -> None:
+    """
+    Run the WebSocket server.
+
+    This is a convenience function to start the server synchronously.
+
+    Args:
+        host: Host to bind to
+        port: Port to listen on
+    """
+    server = WebSocketServer(host, port)
+    asyncio.run(server.serve_forever())
+
+
+if __name__ == '__main__':
+    # Configure logging when run directly
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    run_server()

{lanscape-1.3.8a1.dist-info → lanscape-2.4.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lanscape
-Version: 1.3.8a1
+Version: 2.4.0a2
 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,16 @@ Requires-Dist: scapy<3.0,>=2.3.2
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pydantic
 Requires-Dist: icmplib
+Requires-Dist: pwa-launcher>=1.1.0
+Requires-Dist: websockets<14.0,>=12.0
+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: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: pylint>=3.0; extra == "dev"
+Requires-Dist: autopep8>=2.0; extra == "dev"
 Dynamic: license-file
 
 # LANscape
@@ -80,7 +95,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.4.0a2.dist-info/RECORD

@@ -0,0 +1,85 @@
+lanscape/__init__.py,sha256=ibc4hZ6Esm7fsqocLRpc2v30BVWrKpFQ-iMJisoDtL8,423
+lanscape/__main__.py,sha256=PuY42yuCLAwHrOREJ6u2DgVyGX5hZKRQeoE9pajkNfM,170
+lanscape/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lanscape/core/app_scope.py,sha256=qfzX8Ed4bFdxHMGjgnLlWuLZDTCBKObermz91KbGVn0,3298
+lanscape/core/decorators.py,sha256=CZbPEfnLS1OF-uejQweetadzqf0pVo736jKko4Xs-g4,7264
+lanscape/core/device_alive.py,sha256=VY2dsoy6_MWUxcysZEFcsSoCtDkLMYzwqy0U_sbVWE0,9609
+lanscape/core/errors.py,sha256=QTf42UzR9Zxj1t1mdwfLvZIp0c9a5EItELOdCR7kTmE,1322
+lanscape/core/ip_parser.py,sha256=kn5H4ERitLnreRAqifWphwbxdjItGqwu50lsMCPDMcA,3474
+lanscape/core/logger.py,sha256=nzo6J8UdlMdhRkOJEDOIHKztoE3Du8PQZad7ixvNgeM,2534
+lanscape/core/mac_lookup.py,sha256=PxBSMe3wEVDtivCsh5NclSAguZz9rqdAS7QshBiuWvM,3519
+lanscape/core/net_tools.py,sha256=PsyH-I6ylrkJaVas_YUttYPhU2Cs8I5uCLibPzXxuoM,22076
+lanscape/core/port_manager.py,sha256=3_ROOb6JEiB0NByZVtADuGcldFkgZwn1RKtvwgs9AIk,4479
+lanscape/core/runtime_args.py,sha256=vZNDqb75hr3OQccgJip3XtYYljwa1tIzXQ5PdzHeIDg,2865
+lanscape/core/scan_config.py,sha256=A2ZKXqXKW9nrP6yLb7b9b3XqSY_cQB3LZ5K0LVCSebE,11114
+lanscape/core/service_scan.py,sha256=umDVOoCNNVJhWMtxDV-rn7hcS7t_V073srSMPTl5gMo,7943
+lanscape/core/subnet_scan.py,sha256=PtSOk92dK05-reyr8LBkOXaI15qpYnar5nDqALCX1tQ,14850
+lanscape/core/version_manager.py,sha256=eGjyKgsv31QO0W26se9pPQ1TwmEN8qn37dHULtoocqc,2841
+lanscape/resources/mac_addresses/convert_csv.py,sha256=hvlyLs0XmuuhBuvXBNRGP1cKJzYVRSf8VfUJ1VqROms,1189
+lanscape/resources/mac_addresses/mac_db.json,sha256=Lng2yJerwO7vjefzxzgtE203hry1lIsCadHL1A5Rptg,2136137
+lanscape/resources/ports/convert_csv.py,sha256=MMLDa-5pGMsn4A2_k45jHsRYffrRY_0Z2D1ziiikeQA,1143
+lanscape/resources/ports/full.json,sha256=O8XBW52QvEVSGMQDbXe4-c4qq6XAecw6KJW4m2HkTLo,1441444
+lanscape/resources/ports/large.json,sha256=CzlCcIGCBW1QAgjz4NDerCYA8HcYf6lNxehh7F928y0,138410
+lanscape/resources/ports/medium.json,sha256=T5Rc7wa47MtroHxuZrHSftOqRWbQzhZULJdE1vpsTvU,3518
+lanscape/resources/ports/small.json,sha256=F_lo_5xHwHBfOVfVgxP7ejblR3R62SNtC1Mm33brhYc,376
+lanscape/resources/ports/test_port_list_scan.json,sha256=qXuWGQ_sGIRCVrhJxMeWcHKYdjaMv8O6OVWutiqCwVo,36
+lanscape/resources/services/definitions.jsonc,sha256=M9BDeK-mh25sEVj8xDEYbU2ix7EETVWhbiYmMb14Gjg,20905
+lanscape/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lanscape/ui/app.py,sha256=rg4UGHgbVHpU2jdabSwBoSqGna7WGOunPkPc5Tvds9w,4076
+lanscape/ui/main.py,sha256=cL3og5eO-SdyX-ev-DhcuvO7htn5u50TtRTGv2HeK-A,5047
+lanscape/ui/shutdown_handler.py,sha256=HrEnWrdYSzLDVsPgD8tf9FgtAwQrZNECDu6wnEs27EY,1704
+lanscape/ui/blueprints/__init__.py,sha256=EjPtaR5Nh17pGiOVYTJULVNaZntpFZOiYyep8rBWAiE,265
+lanscape/ui/blueprints/api/__init__.py,sha256=5Z4Y7B36O-bNFenpomfuNhPuJ9dW_MC0TPUU3pCFVfA,103
+lanscape/ui/blueprints/api/port.py,sha256=enqJ87hpVHSTBoaV9bJ7IgsvHrWDTga704wV33dtwUg,2384
+lanscape/ui/blueprints/api/scan.py,sha256=2rsW4xkI4X2Q2ocwaE469aU1VxQ3xHuBRjD9xE36WdI,3326
+lanscape/ui/blueprints/api/tools.py,sha256=jr9gt0VhvBFgJ61MLgNIM6hin-MUmJLGdmStPx3e3Yc,2432
+lanscape/ui/blueprints/web/__init__.py,sha256=NvgnjP0X4LwqVhSEyh5RUzoG45N44kHK1MEFlfvBxTg,118
+lanscape/ui/blueprints/web/routes.py,sha256=f5TzfTzelJ_erslyBXTOpFr4BlIfB1Mb1ye6ioH7IL0,4534
+lanscape/ui/static/lanscape.webmanifest,sha256=07CqA-PQsO35KJD8R96sI3Pxix6UuBjijPDCuy9vM3s,446
+lanscape/ui/static/css/style.css,sha256=UWu0fOCVhNKRtKawaCy4hp-dU5Q-ac2WiSdIwRQMvFs,21442
+lanscape/ui/static/img/ico/android-chrome-192x192.png,sha256=JmFT6KBCCuoyxMV-mLNtF9_QJbVBvfWPUizKN700fi8,18255
+lanscape/ui/static/img/ico/android-chrome-512x512.png,sha256=88Jjx_1-4XAnZYz64KP6FdTl_kYkNG2_kQIKteQwSh4,138055
+lanscape/ui/static/img/ico/apple-touch-icon.png,sha256=tEJlLwBZtF4v-NC90YCfRJQ2prTsF4i3VQLK_hnv2Mw,16523
+lanscape/ui/static/img/ico/favicon-16x16.png,sha256=HpQOZk3rziZjT1xQxKuy5WourXsfrdwuzQY1hChzBJQ,573
+lanscape/ui/static/img/ico/favicon-32x32.png,sha256=UpgiDPIHckK19udHtACiaI3ZPbmImUUcN1GcrjpEg9s,1302
+lanscape/ui/static/img/ico/favicon.ico,sha256=rs5vq0MPJ1LzzioOzOz5aQLVfrtS2nLRc920dOeReTw,15406
+lanscape/ui/static/img/ico/site.webmanifest,sha256=ep4Hzh9zhmiZF2At3Fp1dQrYQuYF_3ZPZxc1KcGBvwQ,263
+lanscape/ui/static/js/core.js,sha256=TzyoD1NCnIY-2JLArymw0JoMOq0CMeJrZDmZyMdMK2I,1394
+lanscape/ui/static/js/layout-sizing.js,sha256=U2dsyJi-YKpOpudu3kg2whiU4047ghzDTY3ExYUhpPs,810
+lanscape/ui/static/js/main.js,sha256=Bgb5Ld_UPWzBVzxWkLD0kJGjOoLJyzni2TKE6Uk99VA,7428
+lanscape/ui/static/js/on-tab-close.js,sha256=3icxYWlLpY81iLoW7kQTJeWQ3UnyyboG0dESHF2wLPQ,1376
+lanscape/ui/static/js/quietReload.js,sha256=T7lvxVejMGJr1cKdABedyiaTVukZfRDIKV7Eyv-jeyc,802
+lanscape/ui/static/js/scan-config.js,sha256=nQ2dWkgpf8yer-lCMTZ25DBqOuWt0SIyzzfdP_fS-bE,8086
+lanscape/ui/static/js/shutdown-server.js,sha256=Mx8UGmmktHaCK7DL8TVUxah6VEcN0wwLFfhbCId-K8U,453
+lanscape/ui/static/js/subnet-info.js,sha256=osZM6CGs-TC5QpBJWkNWCtXNOKzjyIiWKHwKi4vlDf8,559
+lanscape/ui/static/js/subnet-selector.js,sha256=2YKCAuKU2Ti1CmJrqi4_vNTD2LQbxx7chIDqND_1eAY,358
+lanscape/ui/templates/base.html,sha256=HIHLFEUMDTGEaeuSpeNg-vkXXb9VNbZnbFWlYetVL18,1377
+lanscape/ui/templates/error.html,sha256=bqGJbf_ix9wtpUlXk5zvz_XyFpeTbEO-4f0ImgLtUGk,1033
+lanscape/ui/templates/info.html,sha256=SQ6RpTs9_v9HF32mr3FBsh6vTJneYqFz_WrC9diXzHg,2958
+lanscape/ui/templates/main.html,sha256=CVBwJCNBjzOTFDCiIicT1wuptjCUfZzMc7YSvu4OXxA,3626
+lanscape/ui/templates/scan.html,sha256=00QX2_1S_1wGzk42r00LjEkJvoioCLs6JgjOibi6r20,376
+lanscape/ui/templates/shutdown.html,sha256=iXVCq2yl5TjZfNFl4esbDJra3gJA2VQpae0jj4ipy9w,701
+lanscape/ui/templates/core/head.html,sha256=zP1RkTYuaKCC6RtnSEHFKPw3wKWfSyV0HZg5XsAxWik,719
+lanscape/ui/templates/core/scripts.html,sha256=rSRi4Ut8iejajMPhOc5bzEz-Z3EHxpj_3PxwwyyhmTQ,640
+lanscape/ui/templates/scan/config.html,sha256=vI5ZuJLZE5FwbTRkQyXwIRP-bwe_cZdSyzDZVZu1s_w,14821
+lanscape/ui/templates/scan/device-detail.html,sha256=3N0WcdnWopbSFwsnKogBaHOYsLMAfKBZdkP7HQG4vLA,4794
+lanscape/ui/templates/scan/export.html,sha256=Nvs_unojzT3qhN_ZnEgYHou2C9wqWGr3dVr2UiLnYjY,749
+lanscape/ui/templates/scan/ip-table-row.html,sha256=viAvjJcye3jYpDsWGR2To8BGqr1NxuF3gPO2ECQnxUU,1302
+lanscape/ui/templates/scan/ip-table.html,sha256=8pkaStlVeGJ3h6spk8eKu3Ft5HffH7KpHD3vjECyHa0,977
+lanscape/ui/templates/scan/overview.html,sha256=xWj9jWDPg2KcPLvS8fnSins23_UXjKCdb2NJwNG2U2Q,1176
+lanscape/ui/templates/scan/scan-error.html,sha256=wmAYQ13IJHUoO8fAGNDjMvNml7tu4rsIU3Vav71ETlA,999
+lanscape/ui/ws/__init__.py,sha256=kwvrI6WAgxRMToI3NAHdDph4FtbvR7cWODh4WrXHoxg,688
+lanscape/ui/ws/delta.py,sha256=sMmjG8darYosdOds1Sdl2MqwqG44P6Ypb27FJnMz0-E,4798
+lanscape/ui/ws/protocol.py,sha256=i6ULVg-hNyXvKRUKEDJHa2_RfMunieEU8VIYTNXxfD0,2135
+lanscape/ui/ws/server.py,sha256=-rAiWOmPS5UOy5TA9eTAd0oBGLM988qW9b5SWqQNuso,11734
+lanscape/ui/ws/handlers/__init__.py,sha256=D3m4CvaVl-TURkBqADmLaEoBvGcHSIRnFzsBcwXkUy8,544
+lanscape/ui/ws/handlers/base.py,sha256=Uu0FUBSG4F_2SsqORushu132EF_6mo-7uYhJTNu9SpI,4051
+lanscape/ui/ws/handlers/port.py,sha256=0bFFP_BtoHbmg0O5iaCKtVW08GNcrlc3DMhVUixaGT0,5397
+lanscape/ui/ws/handlers/scan.py,sha256=OniNOp-RmmkhlcOpnll4BVYOWnxyAJH7VP2owImsAhk,10977
+lanscape/ui/ws/handlers/tools.py,sha256=Un24y8YqRUHzr2KW4S7IG5Tdl3nu8hHoxVDF8E3H6yM,4533
+lanscape-2.4.0a2.dist-info/licenses/LICENSE,sha256=VLoE0IrNTIc09dFm7hMN0qzk4T3q8V0NaPcFQqMemDs,1070
+lanscape-2.4.0a2.dist-info/METADATA,sha256=ruSveDjVkHapd_gA5CNPTxIwFFj5sznyl4HZ2iS31Bw,3793
+lanscape-2.4.0a2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+lanscape-2.4.0a2.dist-info/entry_points.txt,sha256=evxSxUikFa1OEd4e0Boky9sLH87HdgM0YqB_AbB2HYc,51
+lanscape-2.4.0a2.dist-info/top_level.txt,sha256=E9D4sjPz_6H7c85Ycy_pOS2xuv1Wm-ilKhxEprln2ps,9
+lanscape-2.4.0a2.dist-info/RECORD,,

{lanscape-1.3.8a1.dist-info → lanscape-2.4.0a2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lanscape-2.4.0a2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lanscape = lanscape.ui.main:main

lanscape/libraries/decorators.py

@@ -1,170 +0,0 @@
-
-"""
-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
-from tabulate import tabulate
-
-
-@dataclass
-class JobStats:
-    """
-    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
-
-    def __init__(self):
-        # Only initialize once
-        if not hasattr(self, "running"):
-            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
-
-    def __str__(self):
-        """Return a formatted string representation of the job statistics."""
-        data = [
-            [
-                name,
-                self.running.get(name, 0),
-                self.finished.get(name, 0),
-                self.timing.get(name, 0.0)
-            ]
-            for name in set(self.running) | set(self.finished)
-        ]
-        headers = ["Function", "Running", "Finished", "Avg Time (s)"]
-        return tabulate(
-            data,
-            headers=headers,
-            tablefmt="grid"
-        )
-
-
-class JobStatsMixin:  # pylint: disable=too-few-public-methods
-    """
-    Singleton mixin that provides shared job_stats property across all instances.
-    """
-    _job_stats = None
-
-    @property
-    def job_stats(self):
-        """Return the shared JobStats instance."""
-        return JobStats()
-
-
-def job_tracker(func):
-    """
-    Decorator to track job statistics for a method,
-    including running count, finished count, and average timing.
-    """
-    def get_fxn_src_name(func, first_arg) -> str:
-        """
-        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__}"
-        return func.__name__
-
-    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
-
-        # 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)
-
-        return result
-
-    return wrapper
-
-
-def terminator(func):
-    """
-    Decorator designed specifically for the SubnetScanner class,
-    helps facilitate termination of a job.
-    """
-    def wrapper(*args, **kwargs):
-        """Wrap the function to check if the scan is running before execution."""
-        scan = args[0]  # aka self
-        if not scan.running:
-            return None
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
-def timeout_enforcer(timeout: int, raise_on_timeout: bool = True):
-    """
-    Decorator to enforce a timeout on a function.
-
-    Args:
-        timeout (int): Timeout length in seconds.
-        raise_on_timeout (bool): Whether to raise an exception if the timeout is exceeded.
-    """
-    def decorator(func):
-        @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:
-                future = executor.submit(func, *args, **kwargs)
-                try:
-                    return future.result(
-                        timeout=timeout
-                    )
-                except concurrent.futures.TimeoutError as exc:
-                    if raise_on_timeout:
-                        raise TimeoutError(
-                            f"Function '{func.__name__}' exceeded timeout of "
-                            f"{timeout} seconds."
-                        ) from exc
-                    return None  # Return None if not raising an exception
-        return wrapper
-    return decorator