nano-dev-utils 0.2.1__tar.gz

nano_dev_utils-0.2.1/.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+/src/*/debug.py
+/src/*/*.log

nano_dev_utils-0.2.1/.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

nano_dev_utils-0.2.1/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

nano_dev_utils-0.2.1/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10" project-jdk-type="Python SDK" />
+</project>

nano_dev_utils-0.2.1/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/nano_dev_utils.iml" filepath="$PROJECT_DIR$/.idea/nano_dev_utils.iml" />
+    </modules>
+  </component>
+</project>

nano_dev_utils-0.2.1/.idea/nano_dev_utils.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

nano_dev_utils-0.2.1/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

nano_dev_utils-0.2.1/.idea/workspace.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="96bbbefe-efb6-42c4-93da-e069ac3e654f" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 5
+}</component>
+  <component name="ProjectId" id="2wBUoAyjEyavXXmNnhB2xcAn4VQ" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+    <option name="showMembers" value="true" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;master&quot;,
+    &quot;last_opened_file_path&quot;: &quot;C:/GitHubWS/nano_dev_utils&quot;
+  }
+}</component>
+  <component name="RunManager">
+    <configuration name="Python tests in tests" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+      <module name="nano_dev_utils" />
+      <option name="ENV_FILES" value="" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tests" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <option name="_new_additionalArguments" value="&quot;&quot;" />
+      <option name="_new_target" value="&quot;$PROJECT_DIR$/tests&quot;" />
+      <option name="_new_targetType" value="&quot;PATH&quot;" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python tests.Python tests in tests" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-python-sdk-5b207ade9991-746f403e7f0c-com.jetbrains.pycharm.community.sharedIndexes.bundled-PC-241.17890.14" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="96bbbefe-efb6-42c4-93da-e069ac3e654f" name="Changes" comment="" />
+      <created>1745514632336</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1745514632336</updated>
+    </task>
+    <servers />
+  </component>
+</project>

nano_dev_utils-0.2.1/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.

nano_dev_utils-0.2.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,123 @@
+# 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/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "nano_dev_utils"
+version = "0.2.1"
+authors = [
+  { name="Yaron Dayan", email="yaronday77@gmail.com" },
+]
+description = "A collection of small Python utilities for developers."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE.md"]
+
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project.urls]
+Homepage = "https://github.com/yaronday/nano_utils"
+Issues = "https://github.com/yaronday/nano_utils/issues"

nano_dev_utils-0.2.1/src/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-0.2.1/src/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-0.2.1/src/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-0.2.1/src/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/tests/__init__.py

@@ -0,0 +1,12 @@
+from .testing_timer import TestTimer
+from .testing_dynamic_importer import TestImporter
+from .testing_release_ports import (TestPortsRelease,
+                                    PROXY_SERVER, CLIENT_PORT)
+
+__all__ = [
+    TestTimer,
+    TestImporter,
+    TestPortsRelease,
+    PROXY_SERVER,
+    CLIENT_PORT,
+]

nano_dev_utils-0.2.1/tests/testing_dynamic_importer.py

@@ -0,0 +1,55 @@
+import unittest
+from unittest.mock import patch
+from types import ModuleType
+from src.nano_dev_utils.dynamic_importer import Importer
+
+
+class TestImporter(unittest.TestCase):
+
+    def setUp(self):
+        self.importer = Importer()
+        self.mock_module = ModuleType('mock_module')
+        self.mock_module.attribute = "test_value"
+
+    def test_import_mod_from_lib_success_new_import(self):
+        with patch("importlib.import_module",
+                   return_value=self.mock_module) as mock_import:
+            module = self.importer.import_mod_from_lib("test_library",
+                                                       "test_module")
+            self.assertEqual(module, self.mock_module)
+            self.assertIn("test_module", self.importer.imported_modules)
+            self.assertEqual(self.importer.imported_modules["test_module"], self.mock_module)
+            mock_import.assert_called_once_with("test_library.test_module")
+
+    def test_import_mod_from_lib_success_cached_import(self):
+        self.importer.imported_modules["cached_module"] = self.mock_module
+        with patch("importlib.import_module") as mock_import:
+            module = self.importer.import_mod_from_lib("another_library",
+                                                       "cached_module")
+            self.assertEqual(module, self.mock_module)
+            mock_import.assert_not_called()
+
+    def test_import_mod_from_lib_failure(self):
+        with patch("importlib.import_module",
+                   side_effect=ModuleNotFoundError("No module named "
+                                                   "'nonexistent_library.missing_module'")):
+            with self.assertRaisesRegex(ImportError, "Could not import "
+                                                     "nonexistent_library.missing_module"):
+                self.importer.import_mod_from_lib("nonexistent_library",
+                                                  "missing_module")
+            self.assertNotIn("missing_module", self.importer.imported_modules)
+
+    def test_import_mod_from_lib_returns_any(self):
+        # Simulate importing a non-module object (though importlib.import_module typically returns modules)
+        mock_object = "not a module"
+        with patch.dict("sys.modules",
+                        {"yet_another_library.some_object": mock_object}):
+            result = self.importer.import_mod_from_lib("yet_another_library",
+                                                       "some_object")
+            self.assertEqual(result, mock_object)
+            self.assertIn("some_object", self.importer.imported_modules)
+            self.assertEqual(self.importer.imported_modules["some_object"], mock_object)
+
+
+if __name__ == '__main__':
+    unittest.main()

nano_dev_utils-0.2.1/tests/testing_release_ports.py

@@ -0,0 +1,228 @@
+import unittest
+from unittest.mock import patch, call
+import logging
+from src.nano_dev_utils import release_ports as rp
+
+PROXY_SERVER = rp.PROXY_SERVER
+CLIENT_PORT = rp.INSPECTOR_CLIENT
+
+
+class TestPortsRelease(unittest.TestCase):
+
+    def setUp(self):
+        self.ports_release = rp.PortsRelease()
+        self.mock_logger = unittest.mock.MagicMock(spec=logging.Logger)
+
+        self.remove_file_handlers()
+
+        patch.object(rp, 'lgr', self.mock_logger).start()
+        self.addCleanup(patch.stopall)
+
+    @staticmethod
+    def remove_file_handlers():
+        """Temporarily remove any file handlers from the root logger"""
+        root_logger = logging.getLogger()
+        existing_file_handlers = [
+            handler for handler in root_logger.handlers
+            if isinstance(handler, logging.FileHandler)
+        ]
+        for handler in existing_file_handlers:
+            root_logger.removeHandler(handler)
+            handler.close()
+
+    def tearDown(self):
+        patch.stopall()
+
+    def test_get_pid_by_port_linux_success(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"tcp6 0 0 :::8080 "
+                                                         b":::* users:((\"python3\",)"
+                                                         b" pid=1234 fd=4)\n", b"")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(8080)
+                self.assertEqual(pid, 1234)
+                mock_popen.assert_called_once_with('ss -lntp | grep :8080',
+                                                   shell=True, stdout=unittest.mock.ANY,
+                                                   stderr=unittest.mock.ANY)
+
+    def test_get_pid_by_port_windows_success(self):
+        with patch('platform.system', return_value='Windows'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"TCP    0.0.0.0:"
+                                                         b"9000           "
+                                                         b"0.0.0.0:0"
+                                                         b"              "
+                                                         b"LISTENING"
+                                                         b"       5678\n", b"")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(9000)
+                self.assertEqual(pid, 5678)
+                mock_popen.assert_called_once_with('netstat -ano | findstr :9000',
+                                                   shell=True, stdout=unittest.mock.ANY,
+                                                   stderr=unittest.mock.ANY)
+
+    def test_get_pid_by_port_darwin_success(self):
+        with patch('platform.system', return_value='Darwin'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"python3     "
+                                                         b"1111 user   "
+                                                         b"10u  IPv4 "
+                                                         b"0xabcdef0123456789"
+                                                         b"      0t0  TCP *:"
+                                                         b"7000 (LISTEN)\n", b"")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(7000)
+                self.assertEqual(pid, 1111)
+                mock_popen.assert_called_once_with('lsof -i :7000',
+                                                   shell=True, stdout=unittest.mock.ANY,
+                                                   stderr=unittest.mock.ANY)
+
+    def test_get_pid_by_port_unsupported_os(self):
+        with patch('platform.system', return_value='UnsupportedOS'):
+            pid = self.ports_release.get_pid_by_port(1234)
+            self.assertIsNone(pid)
+            self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                           _log_unsupported_os())
+
+    def test_get_pid_by_port_no_process(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"", b"")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(9999)
+                self.assertIsNone(pid)
+
+    def test_get_pid_by_port_command_error(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"", b"Error occurred")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(80)
+                self.assertIsNone(pid)
+                self.mock_logger.error.assert_called_once_with("Error running "
+                                                               "command: Error occurred")
+
+    def test_get_pid_by_port_parse_error(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.communicate.return_value = (b"tcp6   0"
+                                                         b"      0 "
+                                                         b":::8080"
+                                                         b"              "
+                                                         b":::* users:((\"python3\","
+                                                         b"pid=invalid,fd=4))\n", b"")
+                mock_popen.return_value = mock_process
+                pid = self.ports_release.get_pid_by_port(8080)
+                self.assertIsNone(pid)
+                self.mock_logger.error.assert_called_once_with("Could not parse PID "
+                                                               "from line: tcp6   0"
+                                                               "      0 :::8080"
+                                                               "              :::*"
+                                                               " users:((\"python3\","
+                                                               "pid=invalid,fd=4))")
+
+    def test_get_pid_by_port_unexpected_exception(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen', side_effect=Exception("Unexpected")):
+                pid = self.ports_release.get_pid_by_port(1234)
+                self.assertIsNone(pid)
+                self.mock_logger.error.assert_called_once_with("An unexpected "
+                                                               "error occurred: Unexpected")
+
+    def test_kill_process_success(self):
+        with patch('platform.system', return_value='Linux'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.returncode = 0
+                mock_process.communicate.return_value = (b"", b"")
+                mock_popen.return_value = mock_process
+                result = self.ports_release.kill_process(5678)
+                self.assertTrue(result)
+                mock_popen.assert_called_once_with('kill -9 5678',
+                                                   shell=True, stderr=unittest.mock.ANY)
+
+    def test_kill_process_fail(self):
+        pid = 1234
+        err = 'Access denied'
+        with patch('platform.system', return_value='Windows'):
+            with patch('subprocess.Popen') as mock_popen:
+                mock_process = unittest.mock.MagicMock()
+                mock_process.returncode = 1
+                mock_process.communicate.return_value = (b"", err.encode('utf-8'))
+                mock_popen.return_value = mock_process
+                result = self.ports_release.kill_process(pid)
+                self.assertFalse(result)
+                self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                               _log_terminate_failed(pid=pid, error="Access denied"))
+
+    def test_kill_process_unsupported_os(self):
+        with patch('platform.system', return_value='UnsupportedOS'):
+            result = self.ports_release.kill_process(9999)
+            self.assertFalse(result)
+            self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                           _log_unsupported_os())
+
+    def test_kill_process_unexpected_exception(self):
+        err = Exception("Another error")
+        with (patch('platform.system', return_value='Linux')):
+            with patch('subprocess.Popen',
+                       side_effect=err):
+                result = self.ports_release.kill_process(4321)
+                self.assertFalse(result)
+                self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                               _log_unexpected_error(err))
+                
+    @patch('testing_release_ports.rp.PortsRelease.get_pid_by_port')
+    @patch('testing_release_ports.rp.PortsRelease.kill_process')
+    def test_release_all_default_ports_success(self, mock_kill, mock_get_pid):
+        pid1, pid2 = 1111, 2222
+        mock_get_pid.side_effect = [pid1, pid2]
+        mock_kill.side_effect = [True, True]
+        self.ports_release.release_all()
+        mock_get_pid.assert_has_calls([call(PROXY_SERVER), call(CLIENT_PORT)])
+        mock_kill.assert_has_calls([call(pid1), call(pid2)])
+        self.assertEqual(mock_get_pid.call_count, 2)
+        self.assertEqual(mock_kill.call_count, 2)
+        self.mock_logger.info.assert_any_call(self.ports_release.
+                                              _log_process_found(PROXY_SERVER, pid1))
+        self.mock_logger.info.assert_any_call(self.ports_release.
+                                              _log_process_terminated(pid1, PROXY_SERVER))
+        self.mock_logger.info.assert_any_call(self.ports_release.
+                                              _log_process_found(CLIENT_PORT, pid2))
+        self.mock_logger.info.assert_any_call(self.ports_release.
+                                              _log_process_terminated(pid2, CLIENT_PORT))
+
+    def test_release_all_invalid_port(self):
+        with patch('testing_release_ports.rp.PortsRelease.get_pid_by_port') as mock_get_pid:
+            with patch('testing_release_ports.rp.PortsRelease.kill_process') as mock_kill:
+                # Make get_pid_by_port return None for the valid ports in this test
+                port = "invalid"
+                mock_get_pid.side_effect = [None, None]
+                self.ports_release.release_all(ports=[1234, "invalid", 5678])
+                mock_get_pid.assert_any_call(1234)
+                mock_get_pid.assert_any_call(5678)
+                self.assertEqual(mock_get_pid.call_count, 2)
+                mock_kill.assert_not_called()
+                self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                               _log_invalid_port(port))
+
+    def test_release_all_unexpected_exception(self):
+        err = Exception("Release all error")
+        with patch('testing_release_ports.'
+                   'rp.PortsRelease.get_pid_by_port',
+                   side_effect=err):
+            self.ports_release.release_all(ports=[9010])
+            self.mock_logger.error.assert_called_once_with(self.ports_release.
+                                                           _log_unexpected_error(err))
+            self.ports_release.get_pid_by_port.assert_called_once_with(9010)
+
+
+if __name__ == '__main__':
+    unittest.main()

nano_dev_utils-0.2.1/tests/testing_timer.py

@@ -0,0 +1,63 @@
+import unittest
+from unittest.mock import patch
+from src.nano_dev_utils.timers import Timer
+
+
+class TestTimer(unittest.TestCase):
+
+    def test_initialization(self):
+        timer = Timer()
+        self.assertEqual(timer.precision, 4)
+        self.assertFalse(timer.verbose)
+        timer_custom = Timer(precision=6, verbose=True)
+        self.assertEqual(timer_custom.precision, 6)
+        self.assertTrue(timer_custom.verbose)
+
+    @patch('time.perf_counter')
+    @patch('builtins.print')
+    def test_timeit_simple(self, mock_print, mock_perf_counter):
+        mock_perf_counter.side_effect = [0, 0.12345]
+        timer = Timer(precision=5)
+
+        @timer.timeit
+        def sample_function():
+            return "result"
+
+        result = sample_function()
+        self.assertEqual(result, "result")
+        mock_perf_counter.assert_any_call()
+        mock_print.assert_called_once_with('sample_function took 0.12345 [s]')
+
+    @patch('time.perf_counter')
+    @patch('builtins.print')
+    def test_timeit_verbose(self, mock_print, mock_perf_counter):
+        mock_perf_counter.side_effect = [0, 0.56789]
+        timer = Timer(precision=3, verbose=True)
+
+        @timer.timeit
+        def another_function(arg1, kwarg1=None):
+            return "another result"
+
+        result = another_function(10, kwarg1="hello")
+        self.assertEqual(result, "another result")
+        mock_perf_counter.assert_any_call()
+        mock_print.assert_called_once_with("another_function (10,) {'kwarg1': 'hello'} took 0.568 [s]")
+
+    @patch('time.perf_counter')
+    @patch('builtins.print')
+    def test_timeit_no_args_kwargs(self, mock_print, mock_perf_counter):
+        mock_perf_counter.side_effect = [1.0, 1.5]
+        timer = Timer(precision=2, verbose=True)
+
+        @timer.timeit
+        def yet_another_function():
+            return "yet another result"
+
+        result = yet_another_function()
+        self.assertEqual(result, "yet another result")
+        mock_perf_counter.assert_any_call()
+        mock_print.assert_called_once_with("yet_another_function () {} took 0.50 [s]")
+
+
+if __name__ == '__main__':
+    unittest.main(argv=['first-arg-is-ignored'], exit=False)