nano-dev-utils 0.2.1__py3-none-any.whl

nano_dev_utils/__init__.py

@@ -0,0 +1,14 @@
+"""Nano-Utils-Yaronday - A collection of small Python utilities for developers.
+Copyright (c) 2025 Yaron Dayan
+"""
+from .dynamic_importer import Importer
+from .timers import Timer
+from .release_ports import PortsRelease, PROXY_SERVER, INSPECTOR_CLIENT
+
+__all__ = [
+    "Importer",
+    "Timer",
+    "PortsRelease",
+    "PROXY_SERVER",
+    "INSPECTOR_CLIENT",
+]

nano_dev_utils/dynamic_importer.py

@@ -0,0 +1,28 @@
+from types import ModuleType
+from typing import Any
+
+import importlib
+
+
+class Importer:
+    def __init__(self):
+        self.imported_modules = {}
+
+    def import_mod_from_lib(self, library: str, module_name: str) -> ModuleType | Any:
+        """Lazily imports and caches a specific submodule from a given library.
+        :param library: The name of the library.
+        :param module_name: The name of the module to import.
+        :return: The imported module.
+        """
+        if module_name in self.imported_modules:
+            return self.imported_modules[module_name]
+
+        try:
+            module = importlib.import_module(f"{library}.{module_name}")
+            self.imported_modules[module_name] = module
+            return module
+        except ModuleNotFoundError as e:
+            raise ImportError(f"Could not import {library}.{module_name}") from e
+
+
+

nano_dev_utils/release_ports.py

@@ -0,0 +1,156 @@
+import platform
+import subprocess
+import logging
+from typing import Optional
+
+
+logging.basicConfig(filename='port release.log',
+                    level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s: %(message)s',
+                    datefmt='%d-%m-%Y %H:%M:%S')
+lgr = logging.getLogger(__name__)
+
+PROXY_SERVER = 6277
+INSPECTOR_CLIENT = 6274
+
+
+class PortsRelease:
+    def __init__(self, default_ports: Optional[list[int]] = None):
+        self.default_ports: list[int] = default_ports \
+            if default_ports is not None else [PROXY_SERVER, INSPECTOR_CLIENT]
+
+    @staticmethod
+    def _log_process_found(port: int, pid: int) -> str:
+        return f'Process ID (PID) found for port {port}: {pid}.'
+
+    @staticmethod
+    def _log_process_terminated(pid: int, port: int) -> str:
+        return f'Process {pid} (on port {port}) terminated successfully.'
+
+    @staticmethod
+    def _log_no_process(port: int) -> str:
+        return f'No process found listening on port {port}.'
+
+    @staticmethod
+    def _log_invalid_port(port: int) -> str:
+        return f'Invalid port number: {port}. Skipping.'
+
+    @staticmethod
+    def _log_terminate_failed(pid: int, port: Optional[int] = None,
+                              error: Optional[str] = None) -> str:
+        base_msg = f'Failed to terminate process {pid}'
+        if port:
+            base_msg += f' (on port {port})'
+        if error:
+            base_msg += f'. Error: {error}'
+        return base_msg
+
+    @staticmethod
+    def _log_line_parse_failed(line: str) -> str:
+        return f'Could not parse PID from line: {line}'
+
+    @staticmethod
+    def _log_unexpected_error(e: Exception) -> str:
+        return f'An unexpected error occurred: {e}'
+
+    @staticmethod
+    def _log_cmd_error(error: bytes) -> str:
+        return f'Error running command: {error.decode()}'
+
+    @staticmethod
+    def _log_unsupported_os() -> str:
+        return f'Unsupported OS: {platform.system()}'
+
+    def get_pid_by_port(self, port: int) -> Optional[int]:
+        """Gets the process ID (PID) listening on the specified port."""
+        try:
+            cmd: Optional[str] = {
+                "Windows": f"netstat -ano | findstr :{port}",
+                "Linux": f"ss -lntp | grep :{port}",
+                "Darwin": f"lsof -i :{port}",
+            }.get(platform.system())
+            if not cmd:
+                lgr.error(self._log_unsupported_os())
+                return None
+
+            process = subprocess.Popen(cmd, shell=True,
+                                       stdout=subprocess.PIPE,
+                                       stderr=subprocess.PIPE)
+            output, error = process.communicate()
+            if error:
+                lgr.error(self._log_cmd_error(error))
+                return None
+
+            lines: list[str] = output.decode().splitlines()
+            for line in lines:
+                if str(port) in line:
+                    parts: list[str] = line.split()
+                    if platform.system() == "Windows" and len(parts) > 4:
+                        try:
+                            return int(parts[4])
+                        except ValueError:
+                            lgr.error(self._log_line_parse_failed(line))
+                            return None
+                    elif platform.system() == "Linux":
+                        for part in parts:
+                            if "pid=" in part:
+                                try:
+                                    return int(part.split("=")[1])
+                                except ValueError:
+                                    lgr.error(self._log_line_parse_failed(line))
+                                    return None
+                    elif platform.system() == "Darwin" and len(parts) > 1:
+                        try:
+                            return int(parts[1])
+                        except ValueError:
+                            lgr.error(self._log_line_parse_failed(line))
+                            return None
+            return None
+        except Exception as e:
+            lgr.error(self._log_unexpected_error(e))
+            return None
+
+    def kill_process(self, pid: int) -> bool:
+        """Kills the process with the specified PID."""
+        try:
+            cmd: Optional[str] = {
+                'Windows': f'taskkill /F /PID {pid}',
+                'Linux': f'kill -9 {pid}',
+                'Darwin': f'kill -9 {pid}',
+            }.get(platform.system())
+            if not cmd:
+                lgr.error(self._log_unsupported_os())
+                return False
+            process = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE)
+            _, error = process.communicate()
+            if process.returncode:
+                error_msg = error.decode()
+                lgr.error(self._log_terminate_failed(pid=pid, error=error_msg))
+                return False
+            return True
+        except Exception as e:
+            lgr.error(self._log_unexpected_error(e))
+            return False
+
+    def release_all(self, ports: Optional[list[int]] = None) -> None:
+        try:
+            ports_to_release: list[int] = self.default_ports if ports is None else ports
+
+            for port in ports_to_release:
+                if not isinstance(port, int):
+                    lgr.error(self._log_invalid_port(port))
+                    continue
+
+                pid: Optional[int] = self.get_pid_by_port(port)
+                if pid is None:
+                    lgr.info(self._log_no_process(port))
+                    continue
+
+                lgr.info(self._log_process_found(port, pid))
+                if self.kill_process(pid):
+                    lgr.info(self._log_process_terminated(pid, port))
+                else:
+                    lgr.error(self._log_terminate_failed(pid=pid, port=port))
+        except Exception as e:
+            lgr.error(self._log_unexpected_error(e))
+

nano_dev_utils/timers.py

@@ -0,0 +1,24 @@
+from functools import wraps
+import time
+
+
+class Timer:
+    def __init__(self, precision=4, verbose=False):
+        self.precision = precision
+        self.verbose = verbose
+
+    def timeit(self, func):
+        @wraps(func)
+        def timeit_wrapper(*args, **kwargs):
+            start_time = time.perf_counter()
+            result = func(*args, **kwargs)
+            end_time = time.perf_counter()
+            total_time = end_time - start_time
+            extra_info = f'{args} {kwargs} ' if self.verbose else ''
+            print(f'{func.__name__} {extra_info}took {total_time:.{self.precision}f} [s]')
+            return result
+        return timeit_wrapper
+
+
+
+

nano_dev_utils-0.2.1.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: nano_dev_utils
+Version: 0.2.1
+Summary: A collection of small Python utilities for developers.
+Project-URL: Homepage, https://github.com/yaronday/nano_utils
+Project-URL: Issues, https://github.com/yaronday/nano_utils/issues
+Author-email: Yaron Dayan <yaronday77@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# nano_dev_utils
+
+A collection of small Python utilities for developers.
+
+## Modules
+
+### `timers.py`
+
+This module provides a `Timer` class for measuring the execution time of code blocks and functions.
+
+#### `Timer` Class
+
+* **`__init__(self, precision=4, verbose=False)`**: Initializes a `Timer` instance.
+    * `precision` (int, optional): The number of decimal places to record and 
+    * display time durations. Defaults to 4.
+    * `verbose` (bool, optional): If `True`, the function's arguments and keyword
+    * arguments will be included in the printed timing output. Defaults to `False`.
+    * `timing_records` (list): A list to store the recorded timing durations as formatted strings.
+
+* **`timeit(self, func)`**: A decorator that measures the execution time of the decorated function.
+    * When the decorated function is called, this decorator records the start and end times,
+    * calculates the total execution time, prints the function name and execution time 
+    * (optionally including arguments if `verbose` is `True`), and returns the result of the original function.
+
+#### Example Usage:
+
+```python
+import time
+from src.nano_dev_utils.timers import Timer
+
+timer = Timer(precision=6, verbose=True)
+
+
+@timer.timeit
+def my_function(a, b=10):
+  """A sample function."""
+  time.sleep(0.1)
+  return a + b
+
+
+result = my_function(5, b=20)
+print(f"Result: {result}")
+```
+
+### `dynamic_importer.py`
+
+This module provides an `Importer` class for lazy loading and caching module imports.
+
+#### `Importer` Class
+
+* **`__init__(self)`**: Initializes an `Importer` instance with an empty dictionary `imported_modules` to cache imported modules.
+
+* **`import_mod_from_lib(self, library: str, module_name: str) -> ModuleType | Any`**: Lazily imports a module from a specified library and caches it.
+    * `library` (str): The name of the library (e.g., "os", "requests").
+    * `module_name` (str): The name of the module to import within the library (e.g., "path", "get").
+    * Returns the imported module. If the module has already been imported, it returns the cached instance.
+    * Raises `ImportError` if the module cannot be found.
+
+#### Example Usage:
+
+```python
+from src.nano_dev_utils.dynamic_importer import Importer
+
+importer = Importer()
+
+os_path = importer.import_mod_from_lib("os", "path")
+print(f"Imported os.path: {os_path}")
+
+requests_get = importer.import_mod_from_lib("requests", "get")
+print(f"Imported requests.get: {requests_get}")
+
+# Subsequent calls will return the cached module
+os_path_again = importer.import_mod_from_lib("os", "path")
+print(f"Imported os.path again (cached): {os_path_again}")
+```
+
+### `release_ports.py`
+
+This module provides a `PortsRelease` class to identify and release processes 
+listening on specified TCP ports. It supports Windows, Linux, and macOS.
+
+#### `PortsRelease` Class
+
+* **`__init__(self, default_ports: Optional[list[int]] = None)`**: 
+* Initializes a `PortsRelease` instance.
+    * `default_ports` (`list[int]`, *optional*): A list of default ports to manage. 
+    * If not provided, it defaults to `[6277, 6274]`.
+
+* **`get_pid_by_port(port: int) -> Optional[int]`**: A static method that attempts to 
+* find the process ID (PID) listening on the given `port`. It uses platform-specific 
+* commands (`netstat`, `ss`, `lsof`). Returns the PID if found, otherwise `None`. 
+
+* **`kill_process(pid: int) -> bool`**: A static method that attempts to kill the process 
+* with the given `pid`. It uses platform-specific commands (`taskkill`, `kill -9`). 
+* Returns `True` if the process was successfully killed, `False` otherwise. 
+
+* **`release_all(self, ports: Optional[list[int]] = None) -> None`**: Releases all processes
+* listening on the specified `ports`.
+    * `ports` (`list[int]`, *optional*): A list of ports to release. If `None`, it uses the
+    * `default_ports` defined during initialization.
+    * For each port, it first tries to get the PID and then attempts to kill the process. 
+    * It logs the actions and any errors encountered. Invalid port numbers in the provided list are skipped.
+
+#### Example Usage:
+
+```python
+from src.nano_dev_utils.release_ports import PortsRelease
+
+# Create an instance with default ports
+port_releaser = PortsRelease()
+port_releaser.release_all()
+
+# Create an instance with custom ports
+custom_ports_releaser = PortsRelease(default_ports=[8080, 9000, 6274])
+custom_ports_releaser.release_all(ports=[8080, 9000])
+
+# Release only the default ports
+port_releaser.release_all()
+```
+
+## License
+This project is licensed under the MIT License. 
+See [LICENSE](https://github.com/yaronday/nano_dev_utils/blob/master/README.md) for details.

nano_dev_utils-0.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+nano_dev_utils/__init__.py,sha256=qcbhac5zx27mAgmNvwwHzNxyYsMRK-WElB8n4e8c81A,374
+nano_dev_utils/dynamic_importer.py,sha256=sW09aj3_6tzm6mOQbBuqZjp6O2PnpG0_2Ol4Zs_nXe4,902
+nano_dev_utils/release_ports.py,sha256=HpKL7kawNrLE5RPLByoX_nflaLkQfTnlZKyEIZqSG8g,6081
+nano_dev_utils/timers.py,sha256=_WBY0EQLTn3m-41hw0bzpZ2jR9jn2pmbhfAOWmQkKho,690
+nano_dev_utils-0.2.1.dist-info/METADATA,sha256=561_a1OX9cNMOcu_0cabbp86RfgjjWUHpSAMNGkdqtU,5159
+nano_dev_utils-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nano_dev_utils-0.2.1.dist-info/licenses/LICENSE.md,sha256=Muenl7Bw_LdtHZtlOMAP7Kt97gDCq8WWp2605eDWhHU,1089
+nano_dev_utils-0.2.1.dist-info/RECORD,,

nano_dev_utils-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nano_dev_utils-0.2.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yaron Dayan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.