nano-dev-utils 0.5.5__tar.gz → 0.5.6__tar.gz

{nano_dev_utils-0.5.5 → nano_dev_utils-0.5.6}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: nano_dev_utils
-Version: 0.5.5
+Version: 0.5.6
 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
+Project-URL: license, https://github.com/yaronday/nano_dev_utils/blob/master/LICENSE
 Author-email: Yaron Dayan <yaronday77@gmail.com>
 License: MIT
 License-File: LICENSE

{nano_dev_utils-0.5.5 → nano_dev_utils-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nano_dev_utils"
-version = "0.5.5"
+version = "0.5.6"
 
 authors = [
   { name="Yaron Dayan", email="yaronday77@gmail.com" },
@@ -26,9 +26,11 @@ test = [
 [project.urls]
 Homepage = "https://github.com/yaronday/nano_utils"
 Issues = "https://github.com/yaronday/nano_utils/issues"
+license = "https://github.com/yaronday/nano_dev_utils/blob/master/LICENSE"
 
 [build-system]
 requires = ["hatchling >= 1.26"]
 build-backend = "hatchling.build"
 
-
+[tool.hatch.build]
+include = ["LICENSE"]

nano_dev_utils-0.5.5/.idea/.gitignore

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

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

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

nano_dev_utils-0.5.5/.idea/misc.xml

@@ -1,7 +0,0 @@
-<?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.5.5/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?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.5.5/.idea/nano_dev_utils.iml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-    </content>
-    <orderEntry type="jdk" jdkName="Python 3.10" jdkType="Python SDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

nano_dev_utils-0.5.5/.idea/vcs.xml

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

nano_dev_utils-0.5.5/.idea/workspace.xml

@@ -1,100 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AutoImportSettings">
-    <option name="autoReloadType" value="SELECTIVE" />
-  </component>
-  <component name="ChangeListManager">
-    <list default="true" id="1859e23b-7665-4b92-98cc-65e07a208923" name="Changes" comment="license relative path">
-      <change beforePath="$PROJECT_DIR$/LICENSE.md" beforeDir="false" afterPath="$PROJECT_DIR$/LICENSE" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/README.md" beforeDir="false" afterPath="$PROJECT_DIR$/README.md" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/pyproject.toml" beforeDir="false" afterPath="$PROJECT_DIR$/pyproject.toml" afterDir="false" />
-    </list>
-    <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;customColor&quot;: &quot;&quot;,
-  &quot;associatedIndex&quot;: 5
-}</component>
-  <component name="ProjectId" id="2wVV0HQbcggEgX5PEayC1Mcx9Gd" />
-  <component name="ProjectViewState">
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showLibraryContents" value="true" />
-    <option name="showMembers" value="true" />
-  </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "Python tests.Python tests in tests.executor": "Run",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "git-widget-placeholder": "master",
-    "settings.editor.selected.configurable": "com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable"
-  }
-}]]></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="1859e23b-7665-4b92-98cc-65e07a208923" name="Changes" comment="" />
-      <created>1746126505743</created>
-      <option name="number" value="Default" />
-      <option name="presentableId" value="Default" />
-      <updated>1746126505743</updated>
-    </task>
-    <task id="LOCAL-00001" summary=".">
-      <option name="closed" value="true" />
-      <created>1746126585369</created>
-      <option name="number" value="00001" />
-      <option name="presentableId" value="LOCAL-00001" />
-      <option name="project" value="LOCAL" />
-      <updated>1746126585369</updated>
-    </task>
-    <task id="LOCAL-00002" summary="license relative path">
-      <option name="closed" value="true" />
-      <created>1746126934201</created>
-      <option name="number" value="00002" />
-      <option name="presentableId" value="LOCAL-00002" />
-      <option name="project" value="LOCAL" />
-      <updated>1746126934201</updated>
-    </task>
-    <option name="localTasksCounter" value="3" />
-    <servers />
-  </component>
-  <component name="VcsManagerConfiguration">
-    <MESSAGE value="." />
-    <MESSAGE value="license relative path" />
-    <option name="LAST_COMMIT_MESSAGE" value="license relative path" />
-  </component>
-</project>

nano_dev_utils-0.5.5/src/nano_dev_utils/__init__.py

@@ -1,18 +0,0 @@
-"""nano-dev-utils - 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
-from importlib.metadata import version
-
-__version__ = version('nano-dev-utils')
-
-__all__ = [
-    'Importer',
-    'Timer',
-    'PortsRelease',
-    'PROXY_SERVER',
-    'INSPECTOR_CLIENT',
-]

nano_dev_utils-0.5.5/src/nano_dev_utils/dynamic_importer.py

@@ -1,27 +0,0 @@
-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]
-
-        lib_mod = f'{library}.{module_name}'
-
-        try:
-            module = importlib.import_module(lib_mod)
-            self.imported_modules[module_name] = module
-            return module
-        except ModuleNotFoundError as e:
-            raise ImportError(f'Could not import {lib_mod}') from e

nano_dev_utils-0.5.5/src/nano_dev_utils/release_ports.py

@@ -1,155 +0,0 @@
-import platform
-import subprocess
-import logging
-
-lgr = logging.getLogger(__name__)
-"""Module-level logger. Configure using logging.basicConfig() in your application."""
-
-PROXY_SERVER = 6277
-INSPECTOR_CLIENT = 6274
-
-
-class PortsRelease:
-    def __init__(self, default_ports: list[int] | None = 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: int | None = None, error: str | None = 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) -> int | None:
-        """Gets the process ID (PID) listening on the specified port."""
-        system = platform.system()
-        try:
-            cmd: str = {
-                'Windows': f'netstat -ano | findstr :{port}',
-                'Linux': f'ss -lntp | grep :{port}',
-                'Darwin': f'lsof -i :{port}',
-            }.get(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 system == 'Windows' and len(parts) > 4:
-                        try:
-                            return int(parts[4])
-                        except ValueError:
-                            lgr.error(self._log_line_parse_failed(line))
-                            return None
-                    elif 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 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: str = {
-                'Windows': f'taskkill /F /PID {pid}',
-                'Linux': f'kill -9 {pid}',
-                'Darwin': f'kill -9 {pid}',
-            }.get(platform.system(), '')  # fallback to empty string
-            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: list[int] | None = 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: int | None = 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.5.5/src/nano_dev_utils/timers.py

@@ -1,38 +0,0 @@
-from functools import wraps
-import time
-from typing import Callable, ParamSpec, TypeVar
-
-P = ParamSpec('P')
-R = TypeVar('R')
-
-
-class Timer:
-    def __init__(self, precision=4, verbose=False):
-        self.precision = precision
-        self.verbose = verbose
-        self.units = [(1e9, 's'), (1e6, 'ms'), (1e3, 'μs'), (1.0, 'ns')]
-
-    def timeit(self, func: Callable[P, R]) -> Callable[P, R]:
-        """Decorator that times function execution with automatic unit scaling."""
-
-        @wraps(func)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-            start = time.perf_counter_ns()
-            result = func(*args, **kwargs)
-            elapsed = time.perf_counter_ns() - start
-
-            value = elapsed
-            unit = 'ns'
-
-            for divisor, unit in self.units:
-                if elapsed >= divisor or unit == 'ns':
-                    value = elapsed / divisor
-                    break
-
-            extra_info = f'{args} {kwargs} ' if self.verbose else ''
-            print(
-                f'{func.__name__} {extra_info}took {value:.{self.precision}f} [{unit}]'
-            )
-            return result
-
-        return wrapper

nano_dev_utils-0.5.5/tests/__init__.py

@@ -1,10 +0,0 @@
-"""nano-dev-utils - A collection of small Python utilities for developers.
-Copyright (c) 2025 Yaron Dayan
-"""
-
-from .test_release_ports import PROXY_SERVER, CLIENT_PORT
-
-__all__ = [
-    'PROXY_SERVER',
-    'CLIENT_PORT',
-]

nano_dev_utils-0.5.5/tests/test_dynamic_importer.py

@@ -1,62 +0,0 @@
-import pytest
-from types import ModuleType
-from src.nano_dev_utils.dynamic_importer import Importer
-
-
-@pytest.fixture
-def importer():
-    return Importer()
-
-
-@pytest.fixture
-def mock_module():
-    module = ModuleType('mock_module')
-    setattr(module, 'attribute', 'test_value')
-    return module
-
-
-def test_import_mod_from_lib_success_new_import(importer, mock_module, mocker):
-    mock_import = mocker.patch('importlib.import_module', return_value=mock_module)
-    module = importer.import_mod_from_lib('test_library', 'test_module')
-
-    assert module == mock_module
-    assert 'test_module' in importer.imported_modules
-    assert importer.imported_modules['test_module'] == mock_module
-    mock_import.assert_called_once_with('test_library.test_module')
-
-
-def test_import_mod_from_lib_success_cached_import(importer, mock_module, mocker):
-    importer.imported_modules['cached_module'] = mock_module
-    mock_import = mocker.patch('importlib.import_module')
-
-    module = importer.import_mod_from_lib('another_library', 'cached_module')
-
-    assert module == mock_module
-    mock_import.assert_not_called()
-
-
-def test_import_mod_from_lib_failure(importer, mocker):
-    mocker.patch(
-        'importlib.import_module',
-        side_effect=ModuleNotFoundError(
-            "No module named 'nonexistent_library.missing_module'"
-        ),
-    )
-
-    with pytest.raises(
-        ImportError, match='Could not import nonexistent_library.missing_module'
-    ):
-        importer.import_mod_from_lib('nonexistent_library', 'missing_module')
-
-    assert 'missing_module' not in importer.imported_modules
-
-
-def test_import_mod_from_lib_returns_any(importer, mocker):
-    mock_object = 'not a module'
-    mocker.patch.dict('sys.modules', {'yet_another_library.some_object': mock_object})
-
-    result = importer.import_mod_from_lib('yet_another_library', 'some_object')
-
-    assert result == mock_object
-    assert 'some_object' in importer.imported_modules
-    assert importer.imported_modules['some_object'] == mock_object

nano_dev_utils-0.5.5/tests/test_release_ports.py

@@ -1,307 +0,0 @@
-import logging
-import pytest
-from src.nano_dev_utils import release_ports as rp
-
-PROXY_SERVER = rp.PROXY_SERVER
-CLIENT_PORT = rp.INSPECTOR_CLIENT
-
-
-@pytest.fixture
-def ports_release():
-    return rp.PortsRelease()
-
-
-@pytest.fixture
-def mock_logger(mocker):
-    logger = mocker.MagicMock(spec=logging.Logger)
-    mocker.patch.object(rp, 'lgr', logger)
-    return logger
-
-
-def encode_dict(input_dict: dict) -> bytes:
-    return b' '.join(str(v).encode() for v in input_dict.values())
-
-
-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()
-
-
-@pytest.fixture(autouse=True)
-def cleanup():
-    remove_file_handlers()
-    yield
-
-
-def mock_pid_retrieval(ports_release, mocker, entry, port):
-    mock_process = mocker.MagicMock()
-    encoded_entry = encode_dict(entry)
-    mock_process.communicate.return_value = (encoded_entry, '')
-    mocker.patch('subprocess.Popen', return_value=mock_process)
-    pid = ports_release.get_pid_by_port(port)
-    return pid, encoded_entry
-
-
-def test_get_pid_by_port_linux_success(ports_release, mock_logger, mocker):
-    mock_popen = mocker.patch('subprocess.Popen')
-    mocker.patch('platform.system', return_value='Linux')
-    # ss - lntp command response structure
-    port = 8080  # local port
-    peer_port = '*'
-    local_addr = '::'  # :: - listening to all available interfaces
-    peer_addr = '::'
-    _pid = 1234
-    fd = 4  # file descriptor
-    ss_entry = {
-        'netid': 'tcp6',
-        'rx_q': 0,
-        'tx_q': 0,
-        'local_addr_port': f'{local_addr}:{port}',
-        'peer_addr_port': f'{peer_addr}:{peer_port}',
-        'process_name': 'users:python3',
-        'pid': f'pid={_pid}',
-        'fd': f'fd={fd}',
-    }
-
-    mock_process = mocker.MagicMock()
-    mock_process.communicate.return_value = (encode_dict(ss_entry), '')
-    mock_popen.return_value = mock_process
-
-    pid = ports_release.get_pid_by_port(port)
-    assert pid == 1234
-    mock_popen.assert_called_once_with(
-        f'ss -lntp | grep :{port}',
-        shell=True,
-        stdout=-1,
-        stderr=-1,
-    )
-
-
-def test_get_pid_by_port_windows_success(ports_release, mock_logger, mocker):
-    mock_popen = mocker.patch('subprocess.Popen')
-    mocker.patch('platform.system', return_value='Windows')
-
-    # netstat -ano command response structure (Windows)
-    port = 9000
-    _pid = 5678
-    netstat_entry = {
-        'protocol': 'TCP',
-        'local_addr_and_port ': f'0.0.0.0:{port}',
-        'remote_addr_and_port': '0.0.0.0:0',
-        'state_and_pid': f'LISTENING {_pid}\n',
-    }
-
-    mock_process = mocker.MagicMock()
-    mock_process.communicate.return_value = (encode_dict(netstat_entry), '')
-    mock_popen.return_value = mock_process
-
-    pid = ports_release.get_pid_by_port(port)
-    assert pid == 5678
-    mock_popen.assert_called_once_with(
-        f'netstat -ano | findstr :{port}',
-        shell=True,
-        stdout=-1,
-        stderr=-1,
-    )
-
-
-def test_get_pid_by_port_darwin_success(ports_release, mock_logger, mocker):
-    mock_popen = mocker.patch('subprocess.Popen')
-    mocker.patch('platform.system', return_value='Darwin')
-    # lsof -i command response structure (MacOS)
-    port = 7000
-    _pid = 1111
-    lsof_entry = {
-        'command': 'python3',  # Process name
-        'pid': f'{_pid}',  # Process ID (integer)
-        'user': 'user',  # User running the process
-        'fd': '10u',  # File descriptor (read/write)
-        'type': 'IPv4',  # Network connection type (IPv4/IPv6)
-        'device': '0xabcdef0123456789',  # Kernel device identifier
-        'size_off': '0t0',  # Size/offset (0 for sockets)
-        'protocol': 'TCP',  # Protocol (TCP/UDP)
-        'name': f'*:{port} (LISTEN)',  # Combined address & state (optional)
-    }
-
-    mock_process = mocker.MagicMock()
-    mock_process.communicate.return_value = (encode_dict(lsof_entry), '')
-    mock_popen.return_value = mock_process
-
-    pid = ports_release.get_pid_by_port(port)
-    assert pid == 1111
-    mock_popen.assert_called_once_with(
-        f'lsof -i :{port}',
-        shell=True,
-        stdout=-1,
-        stderr=-1,
-    )
-
-
-def test_get_pid_by_port_unsupported_os(ports_release, mock_logger, mocker):
-    mocker.patch('platform.system', return_value='UnsupportedOS')
-    pid = ports_release.get_pid_by_port(1234)
-    assert pid is None
-    mock_logger.error.assert_called_once_with(ports_release._log_unsupported_os())
-
-
-def test_get_pid_by_port_no_process(ports_release, mock_logger, mocker):
-    port = 9999
-    mocker.patch('platform.system', return_value='Linux')
-    mock_process = mocker.MagicMock()
-    mock_process.communicate.return_value = (b'', b'')
-    mocker.patch('subprocess.Popen', return_value=mock_process)
-
-    pid = ports_release.get_pid_by_port(port)
-    assert pid is None
-    mock_logger.error.assert_not_called()
-
-
-def test_get_pid_by_port_command_error(ports_release, mock_logger, mocker):
-    mock_popen = mocker.patch('subprocess.Popen')
-    mocker.patch('platform.system', return_value='Linux')
-    port = 80
-    err = 'Error occurred'
-    mock_process = mocker.MagicMock()
-    mock_process.communicate.return_value = (b'', err.encode())
-    mock_popen.return_value = mock_process
-    pid = ports_release.get_pid_by_port(port)
-    assert pid is None
-    mock_logger.error.assert_called_once_with(f'Error running command: {err}')
-
-
-def test_get_pid_by_port_parse_error(ports_release, mock_logger, mocker):
-    mocker.patch('platform.system', return_value='Linux')
-    port = 8080
-    peer_port = '*'
-    local_addr = '::'
-    peer_addr = '::'
-    _pid = 'invalid'
-    fd = 4
-    ss_entry = {
-        'netid': 'tcp6',
-        'rx_q': 0,
-        'tx_q': 0,
-        'local_addr_port': f'{local_addr}:{port}',
-        'peer_addr_port': f'{peer_addr}:{peer_port}',
-        'process_name': 'users:python3',
-        'pid': f'pid={_pid}',
-        'fd': f'fd={fd}',
-    }
-
-    pid, enc_entry = mock_pid_retrieval(ports_release, mocker, ss_entry, port)
-    assert pid is None
-    mock_logger.error.assert_called_once_with(
-        f'Could not parse PID from line: {enc_entry.decode()}'
-    )
-
-
-def test_get_pid_by_port_unexpected_exception(ports_release, mock_logger, mocker):
-    mocker.patch('platform.system', return_value='Linux')
-    err = Exception('Unexpected')
-    port = 1234
-    mocker.patch('subprocess.Popen', side_effect=err)
-    pid = ports_release.get_pid_by_port(port)
-    assert pid is None
-    mock_logger.error.assert_called_once_with(f'An unexpected error occurred: {err}')
-
-
-def test_kill_process_success(ports_release, mock_logger, mocker):
-    mocker.patch('platform.system', return_value='Linux')
-    mock_popen = mocker.patch('subprocess.Popen')
-
-    port = 5678
-    mock_process = mocker.MagicMock()
-    mock_process.returncode = 0
-    mock_process.communicate.return_value = (b'', b'')
-    mock_popen.return_value = mock_process
-    result = ports_release.kill_process(port)
-    assert result is True
-    mock_popen.assert_called_once_with(f'kill -9 {port}', shell=True, stderr=-1)
-
-
-def test_kill_process_fail(ports_release, mock_logger, mocker):
-    pid = 1234
-    err = 'Access denied'
-    mocker.patch('platform.system', return_value='Windows')
-    mock_popen = mocker.patch('subprocess.Popen')
-    mock_process = mocker.MagicMock()
-    mock_process.returncode = 1
-    mock_process.communicate.return_value = (b'', err.encode())
-    mock_popen.return_value = mock_process
-    result = ports_release.kill_process(pid)
-    assert result is False
-    mock_logger.error.assert_called_once_with(
-        ports_release._log_terminate_failed(pid=pid, error=err)
-    )
-
-
-def test_kill_process_unsupported_os(ports_release, mock_logger, mocker):
-    mocker.patch('platform.system', return_value='UnsupportedOS')
-    pid = 9999
-    result = ports_release.kill_process(pid)
-    assert result is False
-    mock_logger.error.assert_called_once_with(ports_release._log_unsupported_os())
-
-
-def test_kill_process_unexpected_exception(ports_release, mock_logger, mocker):
-    err = Exception('Another error')
-    mocker.patch('platform.system', return_value='Linux')
-    mocker.patch('subprocess.Popen', side_effect=err)
-
-    pid = 4321
-    result = ports_release.kill_process(pid)
-    assert result is False
-    mock_logger.error.assert_called_once_with(ports_release._log_unexpected_error(err))
-
-
-def test_release_all_default_ports_success(ports_release, mock_logger, mocker):
-    mock_get_pid = mocker.patch.object(ports_release, 'get_pid_by_port')
-    mock_kill = mocker.patch.object(ports_release, 'kill_process')
-
-    pid1, pid2 = 1111, 2222
-    mock_get_pid.side_effect = [pid1, pid2]
-    mock_kill.side_effect = [True, True]
-    ports_release.release_all()
-
-    assert mock_get_pid.call_args_list == [
-        mocker.call(PROXY_SERVER),
-        mocker.call(CLIENT_PORT),
-    ]
-    assert mock_kill.call_args_list == [mocker.call(pid1), mocker.call(pid2)]
-    mock_logger.info.assert_has_calls(
-        [
-            mocker.call(ports_release._log_process_found(PROXY_SERVER, pid1)),
-            mocker.call(ports_release._log_process_terminated(pid1, PROXY_SERVER)),
-            mocker.call(ports_release._log_process_found(CLIENT_PORT, pid2)),
-            mocker.call(ports_release._log_process_terminated(pid2, CLIENT_PORT)),
-        ]
-    )
-
-
-def test_release_all_invalid_port(ports_release, mock_logger, mocker):
-    mock_get_pid = mocker.patch.object(ports_release, 'get_pid_by_port')
-    mock_kill = mocker.patch.object(ports_release, 'kill_process')
-    ports = ['invalid', 1234, 5678]
-    mock_get_pid.side_effect = [None, None]
-    ports_release.release_all(ports=ports)
-    assert mock_get_pid.call_args_list == [mocker.call(ports[1]), mocker.call(ports[2])]
-
-    mock_kill.assert_not_called()
-    mock_logger.error.assert_called_once_with(ports_release._log_invalid_port(ports[0]))
-
-
-def test_release_all_unexpected_exception(ports_release, mock_logger, mocker):
-    err = Exception('Release all error')
-    mocker.patch.object(ports_release, 'get_pid_by_port', side_effect=err)
-    port = 9010
-    ports_release.release_all(ports=[port])
-    mock_logger.error.assert_called_once_with(ports_release._log_unexpected_error(err))
-    ports_release.get_pid_by_port.assert_called_once_with(port)

nano_dev_utils-0.5.5/tests/test_timer.py

@@ -1,159 +0,0 @@
-import threading
-import time
-from src.nano_dev_utils.timers import Timer
-
-
-def test_initialization():
-    timer = Timer()
-    assert timer.precision == 4
-    assert not timer.verbose
-
-    timer_custom = Timer(precision=6, verbose=True)
-    assert timer_custom.precision == 6
-    assert timer_custom.verbose
-
-
-def test_timeit_simple(mocker):
-    mock_print = mocker.patch('builtins.print')
-    mock_time = mocker.patch('time.perf_counter_ns', side_effect=[0, 9.23467e5])
-    timer = Timer(precision=2)
-
-    @timer.timeit
-    def sample_function():
-        return 'result'
-
-    result = sample_function()
-    assert result == 'result'
-    mock_time.assert_any_call()
-    mock_print.assert_called_once_with('sample_function took 923.47 [μs]')
-
-
-def test_timeit_no_args_kwargs(mocker):
-    mock_print = mocker.patch('builtins.print')
-    mock_time = mocker.patch('time.perf_counter_ns', 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()
-    assert result == 'yet another result'
-    mock_time.assert_any_call()
-    mock_print.assert_called_once_with('yet_another_function () {} took 0.50 [ns]')
-
-
-def test_multithreaded_timing(mocker):
-    """Test timer works correctly across threads"""
-    mock_print = mocker.patch('builtins.print')
-    timer = Timer()
-    results = []
-
-    @timer.timeit
-    def threaded_operation():
-        time.sleep(0.1)
-        return threading.get_ident()
-
-    def run_in_thread():
-        results.append(threaded_operation())
-
-    threads = [threading.Thread(target=run_in_thread) for _ in range(3)]
-
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join()
-
-    # Should have 3 print calls (one per thread)
-    assert mock_print.call_count == 3
-    # All thread IDs should be different
-    assert len(set(results)) == 3
-
-
-def test_verbose_mode(mocker):
-    """Test that verbose mode includes positional and
-    keyword arguments in output and preserves the wrapped func result"""
-    mock_print = mocker.patch('builtins.print')
-    mocker.patch('time.perf_counter_ns', side_effect=[1e4, 5.23456e4])
-    verbose_timer = Timer(verbose=True)
-
-    @verbose_timer.timeit
-    def func_with_args(a, b, c=3):
-        return a + b + c
-
-    res = func_with_args(1, 2, c=4)
-    output = mock_print.call_args[0][0]
-    assert '(1, 2)' in output  # checking positional args
-    assert "'c': 4" in output  # checking kwargs
-    mock_print.assert_called_once_with(
-        "func_with_args (1, 2) {'c': 4} took 42.3456 [μs]"
-    )
-    assert res == 7  # checking returned value preservation
-
-
-def test_nested_timers(mocker):
-    """Test that nested timers work correctly"""
-    mock_print = mocker.patch('builtins.print')
-    timer = Timer()
-
-    @timer.timeit
-    def outer():
-        @timer.timeit
-        def inner():
-            time.sleep(0.1)
-
-        return inner()
-
-    outer()
-
-    # Should have two print calls (inner and outer)
-    assert mock_print.call_count == 2
-    inner_output = mock_print.call_args_list[0][0][0]
-    outer_output = mock_print.call_args_list[1][0][0]
-
-    inner_time = float(inner_output.split('took ')[1].split(' [')[0])
-    outer_time = float(outer_output.split('took ')[1].split(' [')[0])
-
-    assert outer_time > inner_time
-
-
-def test_unit_scaling(mocker):
-    """Test the time unit selection logic directly"""
-    mock_print = mocker.patch('builtins.print')
-
-    boundary_cases = [
-        (1e3 - 1, 'ns'),
-        (1e3, 'μs'),
-        (1e6 - 1, 'μs'),
-        (1e6, 'ms'),
-        (1e9 - 1, 'ms'),
-        (1e9, 's'),
-    ]
-
-    for ns, expected_unit in boundary_cases:
-        mocker.patch('time.perf_counter_ns', side_effect=[0, ns])
-        timer = Timer(precision=2)
-
-        @timer.timeit
-        def dummy():
-            pass
-
-        dummy()
-        printed_output = mock_print.call_args[0][0]
-        assert expected_unit in printed_output, (
-            f"Failed for {ns:,}ns → Expected '{expected_unit}' in output. "
-            f'Got: {printed_output}'
-        )
-
-
-def test_function_metadata_preserved():
-    """Test that function metadata (name, docstring) is preserved"""
-    timer = Timer(precision=3)
-
-    @timer.timeit
-    def dummy_func():
-        """Test docstring"""
-        pass
-
-    assert dummy_func.__name__ == 'dummy_func'
-    assert dummy_func.__doc__ == 'Test docstring'