pytest-isolate 0.0.2__tar.gz → 0.0.3__tar.gz

{pytest_isolate-0.0.2 → pytest_isolate-0.0.3}/PKG-INFO

@@ -1,12 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pytest-isolate
-Version: 0.0.2
+Version: 0.0.3
+Summary: Run pytest tests in isolated subprocesses
 Project-URL: Documentation, https://github.com/gilfree/pytest-isolate#readme
 Project-URL: Issues, https://github.com/gilfree/pytest-isolate/issues
 Project-URL: Source, https://github.com/gilfree/pytest-isolate
 Author-email: gilfree <gilfree@users.noreply.github.com>
-License-Expression: MIT
-License-File: LICENSE.txt
+License: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.7
@@ -60,9 +60,9 @@ To run every test in its own **forked** subprocess.
 
 Or:
 
-    pytest --isolate-timeout 10 --isolate-mem-limit 1000000
+    pytest --isolate-timeout 10 --isolate-mem-limit 1000000 --isolate-cpu-limit 10
 
-To set a timeout to every test in addition to forking.
+To set a timeout to every test in addition to forking, and limit to 10 cpu seconds.
 
 > Note:
 >
@@ -75,10 +75,10 @@ they will take precedence. Uninstall them to use `pytest-isolate`.
 
 Unlike `pytest-timeout`, timeout in `pytest-isolate` is implemented by forking the test to a separate subprocess, and setting timeout for that subprocess.
 
-You can also use a mark to isolate or time limit the memory test:
+You can also use a mark to isolate or time limit the memory and/or cpu usage test:
 
 ```python
-@pytest.mark.isolate(timeout=10,mem_limit=10**6)
+@pytest.mark.isolate(timeout=10, mem_limit=10**6, cpu_limit=10)
 def test_something():
     pass
 ```
@@ -89,6 +89,7 @@ The options can also be set in an pytest configuration file, e.g:
 [tool.pytest.ini_options]
 isolate_timeout=10
 isolate_mem_limit=1000000
+isolate_cpu_limit=10
 ```
 
 ## Contributing

{pytest_isolate-0.0.2 → pytest_isolate-0.0.3}/README.md

@@ -36,9 +36,9 @@ To run every test in its own **forked** subprocess.
 
 Or:
 
-    pytest --isolate-timeout 10 --isolate-mem-limit 1000000
+    pytest --isolate-timeout 10 --isolate-mem-limit 1000000 --isolate-cpu-limit 10
 
-To set a timeout to every test in addition to forking.
+To set a timeout to every test in addition to forking, and limit to 10 cpu seconds.
 
 > Note:
 >
@@ -51,10 +51,10 @@ they will take precedence. Uninstall them to use `pytest-isolate`.
 
 Unlike `pytest-timeout`, timeout in `pytest-isolate` is implemented by forking the test to a separate subprocess, and setting timeout for that subprocess.
 
-You can also use a mark to isolate or time limit the memory test:
+You can also use a mark to isolate or time limit the memory and/or cpu usage test:
 
 ```python
-@pytest.mark.isolate(timeout=10,mem_limit=10**6)
+@pytest.mark.isolate(timeout=10, mem_limit=10**6, cpu_limit=10)
 def test_something():
     pass
 ```
@@ -65,6 +65,7 @@ The options can also be set in an pytest configuration file, e.g:
 [tool.pytest.ini_options]
 isolate_timeout=10
 isolate_mem_limit=1000000
+isolate_cpu_limit=10
 ```
 
 ## Contributing

{pytest_isolate-0.0.2 → pytest_isolate-0.0.3}/pyproject.toml

@@ -4,14 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-isolate"
-description = ''
+description = 'Run pytest tests in isolated subprocesses'
 readme = "README.md"
 requires-python = ">=3.7"
 license = "MIT"
 keywords = []
-authors = [
-  { name = "gilfree", email = "gilfree@users.noreply.github.com" },
-]
+authors = [{ name = "gilfree", email = "gilfree@users.noreply.github.com" }]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
@@ -23,7 +21,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["dill","tblib","pytest"]
+dependencies = ["dill", "tblib", "pytest"]
 dynamic = ["version"]
 
 [project.urls]
@@ -38,22 +36,26 @@ pytest_isolate = "pytest_isolate.plugin"
 path = "src/pytest_isolate/__about__.py"
 
 [tool.hatch.envs.default]
-dependencies = [
-  "pytest",
-  "pytest-cov",
-]
+dependencies = ["pytest", "pytest-cov", "numpy", "pytest-xdist"]
+
+
+[tool.pytest.ini_options]
+isolate_timeout = 2
 
 [tool.ruff]
+fix = true
+
+# Assume Python 3.11.
+target-version = "py311"
+
+[tool.ruff.lint]
 # Enable Pyflakes `E` and `F` codes by default.
-select = ["E", "F","I"]
+select = ["E", "F", "I"]
 ignore = []
-fix=true
 # Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
-# Assume Python 3.11.
-target-version = "py311"
 
-[tool.ruff.mccabe]
+[tool.ruff.lint.mccabe]
 # Unlike Flake8, default to a complexity level of 10.
-max-complexity = 10
+max-complexity = 10

pytest_isolate-0.0.3/src/pytest_isolate/__about__.py

@@ -0,0 +1 @@
+__version__ = '0.0.3'

{pytest_isolate-0.0.2 → pytest_isolate-0.0.3}/src/pytest_isolate/plugin.py

@@ -1,7 +1,7 @@
 # This file is was originally based on pytest forked:
 # see: https://github.com/pytest-dev/pytest-forked/blob/master/src/pytest_forked/__init__.py
-# Since pytest forked is un unmaintained, 
-# I decided to make my changes in a different project.
+# Since pytest forked is un unmaintained I decided to make my 
+# changes in a different project
 # Please see README.md
 
 
@@ -13,7 +13,6 @@ import resource
 import sys
 import warnings
 from contextlib import contextmanager
-from datetime import datetime
 from queue import Empty
 from typing import Any, List, Optional, Tuple
 
@@ -28,6 +27,11 @@ try:
 except ImportError:
     pass
 
+try:
+    import setproctitle # noqa F401
+except ImportError:
+    pass
+
 try:
     from tblib import pickling_support
 
@@ -37,26 +41,33 @@ except ImportError:
 
 
 def forked_subprocess(
-    target, args=(), timeout=None, memlimt=None
+    target, args=(), timeout=None, memlimt=None, cpulimit=None
 ) -> Tuple[Any, int, bool]:
     sub = ForkedSubprocess()
-    exitcode, timed_out, result = sub.run_in_subprocess(timeout, memlimt, target, args)
+    exitcode, timed_out, result = sub.run_in_subprocess(
+        timeout, memlimt, cpulimit, target, args
+    )
     return result, exitcode, timed_out
 
 
 @contextmanager
-def limits(max_mem):
-    if not max_mem:
+def limits(max_mem, max_cpu):
+    if not max_mem and not max_cpu:
         yield
         return
-    (soft, hard) = resource.getrlimit(resource.RLIMIT_DATA)
-    resource.setrlimit(resource.RLIMIT_DATA, (max_mem, hard))
-    (soft, hard) = resource.getrlimit(resource.RLIMIT_DATA)
+    (soft_mem, hard_mem) = resource.getrlimit(resource.RLIMIT_DATA)
+    (soft_cpu, hard_cpu) = resource.getrlimit(resource.RLIMIT_CPU)
+    if max_mem:
+        resource.setrlimit(resource.RLIMIT_DATA, (max_mem, hard_mem))
+    if max_cpu:
+        resource.setrlimit(resource.RLIMIT_CPU, (max_cpu, hard_cpu))
     try:
         yield
     finally:
-        pass
-        resource.setrlimit(resource.RLIMIT_DATA, (soft, hard))
+        if max_mem:
+            resource.setrlimit(resource.RLIMIT_DATA, (soft_mem, hard_mem))
+        if max_cpu:
+            resource.setrlimit(resource.RLIMIT_CPU, (soft_cpu, hard_cpu))
     return
 
 
@@ -91,7 +102,7 @@ class ForkedSubprocess:
         os.close(self.w_out)
         os.close(self.w_err)
 
-    def run_in_subprocess(self, timeout, memlimit, target, args=()):
+    def run_in_subprocess(self, timeout, memlimit, cpulimit, target, args=()):
         ctx = mp.get_context("fork")
         q = ctx.Queue()
         timed_out = None
@@ -99,9 +110,8 @@ class ForkedSubprocess:
         def run_subprocess():
             # Close the read fd, redirect output to write fd
             self.child_redirect_streams()
-
             try:
-                with limits(memlimit):
+                with limits(memlimit, cpulimit):
                     q.put(dill.dumps(target(*args)))
             except BaseException as e:
                 q.put(dill.dumps(e))
@@ -183,12 +193,21 @@ def pytest_addoption(parser):
         default=None,
         help="Limit the memory usage of the test ",
     )
+    group.addoption(
+        "--isolate-cpu-limit",
+        dest="isolate_cpu_limit",
+        default=None,
+        help="Limit the CPU usage of the test ",
+    )
     parser.addini(
         "isolate_timeout", "Default timeout for isolated tests", type="string"
     )
     parser.addini(
         "isolate_mem_limit", "Default memory limit for isolated tests", type="string"
     )
+    parser.addini(
+        "isolate_cpu_limit", "Default cpu limit for isolated tests", type="string"
+    )
 
 
 @pytest.hookimpl(trylast=True)
@@ -208,8 +227,8 @@ def pytest_configure(config):
         warnings.warn(
             "Isolate is a replacement for pytest-timeout. "
             "Pytest-timeout will take precedence while installed, "
-            "tests with timeout will not be isolated. please uninstall one of "
-            "the plugins"
+            "tests with timeout will not be isolated. "
+            "Please uninstall one of the plugins"
         )
     else:
         config.addinivalue_line(
@@ -221,7 +240,6 @@ def pytest_configure(config):
 # Taken from pytest 7.2:
 @contextmanager
 def catch_warnings(item: pytest.Item):
-
     """Context manager that catches warnings generated in the contained execution block.
 
     ``item`` can be None if we are not in the context of an item execution.
@@ -254,14 +272,25 @@ def catch_warnings(item: pytest.Item):
 
 
 def run_subprocess(item: pytest.Item):
-
     item.config.pluginmanager.unregister(name="capturemanager")
+    try:
+        if not os.getenv("PYTEST_ISOLATE_NO_SETPROCTITLE"):
+            import setproctitle  # noqa F811
 
+            setproctitle.setproctitle(f"pytest {item.nodeid}")
+    except ImportError:
+        pass
     try:
         with catch_warnings(item) as warnings:
             reports = runtestprotocol(item, log=False)
         s_reports = []
         for report in reports:
+            usage = resource.getrusage(resource.RUSAGE_SELF)
+            cpu_usage = usage.ru_utime + usage.ru_stime
+            usage = resource.getrusage(resource.RUSAGE_CHILDREN)
+            cpu_usage += usage.ru_utime + usage.ru_stime
+            report.user_properties.append(("cpu_usage", cpu_usage))
+            report.cpu_usage = cpu_usage
             s_reports.append(
                 item.config.hook.pytest_report_to_serializable(
                     config=item.config, report=report
@@ -273,28 +302,29 @@ def run_subprocess(item: pytest.Item):
 
 
 def run_in_subprocess(
-    item: pytest.Item, timeout: Optional[float], mem_limit: Optional[int]
+    item: pytest.Item,
+    timeout: Optional[float],
+    mem_limit: Optional[int],
+    cpu_limit: Optional[int],
 ) -> List[pytest.TestReport]:
-
-    cap: _pytest.capture.CaptureManager = item.config.pluginmanager.getplugin(
-        "capturemanager"
-    )
+    cap = item.config.pluginmanager.getplugin("capturemanager")
+    assert isinstance(cap, _pytest.capture.CaptureManager)
     cap.resume_global_capture()
     cap.activate_fixture()
-    current_time = datetime.now().strftime("%Y%m%d-%H%M%S")
-    print(f"{current_time}: Test lunched {item.nodeid} in subprocess ", file=sys.stderr)
     result, exitcode, timed_out = forked_subprocess(
-        run_subprocess, (item,), timeout, mem_limit
+        run_subprocess, (item,), timeout, mem_limit, cpu_limit
     )
     cap.deactivate_fixture()
     cap.suspend_global_capture(in_=False)
     out, err = cap.read_global_capture()
 
+    warnings_captured = None
+
     # The result might be an exception, that comes
     # form current process
     if result and not isinstance(result, BaseException):
         # The result came from child process
-        result, warnings_caputred = result
+        result, warnings_captured = result
 
     if result and not isinstance(result, BaseException):
         results: List[pytest.TestReport] = []
@@ -308,9 +338,9 @@ def run_in_subprocess(
         results[-1].sections.append(("Captured stderr", err))
         results[-1].sections.append(("Captured stdout", out))
 
-        if warnings_caputred:
+        if warnings_captured:
             try:
-                for warning_message in warnings_caputred:
+                for warning_message in warnings_captured:
                     item.ihook.pytest_warning_recorded.call_historic(
                         kwargs=dict(
                             warning_message=warning_message,
@@ -343,10 +373,12 @@ def report_process_crash(
 
     if timed_out is not None:
         info += f"Timeout > {timed_out}"
+    elif exitcode == -24:
+        info += "SIGXCPU: CPU time limit exceeded"
     elif exitcode != 0:
-        info += f"Running the test CRASHED with exit code {exitcode}"
+        info += f"Crashed with exit code {exitcode}"
     else:
-        info += "Exited with no result, probably hit memory limit"
+        info += "Exited with no result, memory limit exceeded (probably)"
 
     call = runner.CallInfo.from_call(lambda: 0 / 0, "???")
     call.excinfo = info
@@ -421,13 +453,17 @@ def pytest_runtest_protocol(item):
         return
     if item.config.pluginmanager.get_plugin("timeout"):
         return
-
-    isolate, timeout, mem_limit = get_isolation_options(item)
-
-    if isolate is not None or mem_limit is not None or timeout is not None:
+    isolate, timeout, mem_limit, cpu_limit = get_isolation_options(item)
+
+    if (
+        isolate is not None
+        or mem_limit is not None
+        or timeout is not None
+        or cpu_limit is not None
+    ):
         ihook = item.ihook
         ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
-        reports = run_in_subprocess(item, timeout, mem_limit)
+        reports = run_in_subprocess(item, timeout, mem_limit, cpu_limit)
 
         for rep in reports:
             ihook.pytest_runtest_logreport(report=rep)
@@ -436,22 +472,8 @@ def pytest_runtest_protocol(item):
         return True
 
 
-def get_isolation_options(item):
-    # Should we fork?
-    forked = get_global_value(item, "forked")
-    forked_marker = get_marker(item, "forked")
-    isolate = get_global_value(item, "isolate")
-    isolate_marker = get_marker(item, "isolate")
-    if isolate_marker is not None:
-        isolate = isolate_marker
-    elif forked_marker is not None:
-        isolate = forked_marker
-    elif isolate is not None:
-        pass
-    else:
-        isolate = forked
-
-    # Should we timeout
+def get_timeout(item):
+    # Should we timeout?
     timeout = get_global_value(item, "timeout")
     timeout_marker = get_marker(item, "timeout", "timeout", 0)
 
@@ -465,10 +487,15 @@ def get_isolation_options(item):
     elif isolate_timeout is not None:
         timeout = isolate_timeout
 
-    if timeout and isinstance(timeout, str) and str.isnumeric(timeout):
+    try:
         timeout = float(timeout)
+    except (ValueError, TypeError):
+        timeout = None
+    return timeout
+
 
-    # Should we memlimit?
+def get_memory_limit(item):
+    # Should we limit memory?
     mem_limit = None
     isolate_mem_limit_marker = get_marker(item, "isolate", "mem_limit", 1)
     isolate_mem_limit = get_global_value(item, "isolate_mem_limit")
@@ -477,4 +504,88 @@ def get_isolation_options(item):
         mem_limit = isolate_mem_limit_marker
     else:
         mem_limit = isolate_mem_limit
-    return isolate, timeout, mem_limit
+
+    try:
+        mem_limit = int(mem_limit)
+        if mem_limit < 1 or round(mem_limit) != mem_limit:
+            raise ValueError("Memory limit must be in whole bytes")
+        mem_limit = int(mem_limit)
+    except (ValueError, TypeError):
+        mem_limit = None
+    return mem_limit
+
+
+def get_cpu_limit(item):
+    # Should we limit cpu?
+    cpu_limit = None
+    isolate_cpu_limit_marker = get_marker(item, "isolate", "cpu_limit", 2)
+    isolate_cpu_limit = get_global_value(item, "isolate_cpu_limit")
+
+    if isolate_cpu_limit_marker is not None:
+        cpu_limit = isolate_cpu_limit_marker
+    else:
+        cpu_limit = isolate_cpu_limit
+
+    try:
+        cpu_limit = float(cpu_limit)
+        if cpu_limit < 1 or round(cpu_limit) != cpu_limit:
+            raise ValueError("Cpu limit must be in whole seconds")
+        cpu_limit = int(cpu_limit)
+    except (ValueError, TypeError):
+        cpu_limit = None
+    return cpu_limit
+
+
+def get_isolation_options(item):
+    # Should we fork?
+    forked = get_global_value(item, "forked")
+    forked_marker = get_marker(item, "forked")
+    isolate = get_global_value(item, "isolate")
+    isolate_marker = get_marker(item, "isolate")
+    if isolate_marker is not None:
+        isolate = isolate_marker
+    elif forked_marker is not None:
+        isolate = forked_marker
+    elif isolate is not None:
+        pass
+    else:
+        isolate = forked
+    timeout = get_timeout(item)
+    mem_limit = get_memory_limit(item)
+    cpu_limit = get_cpu_limit(item)
+
+    return isolate, timeout, mem_limit, cpu_limit
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_terminal_summary(terminalreporter) -> None:
+    durations = terminalreporter.config.option.durations
+    durations_min = terminalreporter.config.option.durations_min
+    verbose = terminalreporter.config.getvalue("verbose")
+    if durations is None:
+        return
+    tr = terminalreporter
+    dlist = []
+    for replist in tr.stats.values():
+        for rep in replist:
+            if hasattr(rep, "cpu_usage"):
+                dlist.append(rep)
+    if not dlist:
+        return
+    dlist.sort(key=lambda x: x.cpu_usage, reverse=True)  # type: ignore[no-any-return]
+    if not durations:
+        tr.write_sep("=", "highest cpu_usage")
+    else:
+        tr.write_sep("=", "highest %s cpu_usage" % durations)
+        dlist = dlist[:durations]
+
+    for i, rep in enumerate(dlist):
+        if verbose < 2 and rep.cpu_usage < durations_min:
+            tr.write_line("")
+            tr.write_line(
+                "(%s cpu_usage < %gs hidden.  Use -vv to show these durations.)"
+                % (len(dlist) - i, durations_min)
+            )
+            break
+        if rep.when == "teardown":
+            tr.write_line(f"{rep.cpu_usage:02.2f}s {rep.nodeid}")

{pytest_isolate-0.0.2 → pytest_isolate-0.0.3}/tests/test_isolate.py

@@ -43,7 +43,7 @@ def test_bare_ok():
     print(f"isolated in {os.getpid()}")
 
 
-@pytest.mark.xfail
+@pytest.mark.xfail(strict=True)
 def test_bare_fail():
     print("Hello")
     print("Hello")
@@ -54,17 +54,27 @@ def test_bare_fail():
 
 @pytest.mark.isolate(mem_limit=10**9)
 def test_rss_limit_ok():
-    a = bytearray(10**7)
+    a = bytearray(10**5)
     print(a[random.randint(0, len(a))])
 
 
 @pytest.mark.xfail
-@pytest.mark.isolate(mem_limit=10**6)
+@pytest.mark.isolate(mem_limit=10**5)
 def test_rss_limit_fail():
-    a = bytearray(10**7)
+    a = bytearray(10**6)
     print(a[random.randint(0, len(a))])
 
 
 @pytest.mark.isolate()
 def test_warn():
     warnings.warn("Boo")
+
+
+@pytest.mark.xfail
+@pytest.mark.isolate(cpu_limit=1)
+def test_isolate_cpu():
+    import numpy as np
+    # hog CPU:
+    x=0
+    for i in range(100):
+        x+=(np.random.rand(1000,1000)@np.random.rand(1000,1000)).sum()

pytest_isolate-0.0.3/tox.ini

@@ -0,0 +1,25 @@
+# For more information about tox, see https://tox.readthedocs.io/en/latest/
+[tox]
+requires =
+    tox >=4
+envlist = py{37,311}
+isolated_build = True
+
+[testenv]
+deps =
+    pytest>6.0
+    numpy
+    pytest-xdist
+    pytest-sugar
+
+commands = pytest --isolate  --import-mode importlib {posargs:tests}
+
+[testenv:lint]
+skip_install = true
+deps = ruff
+commands = ruff check {postargs:.}
+
+[gh]
+python =
+    3.7 = py37
+    3.11 = py311

pytest_isolate-0.0.2/src/pytest_isolate/__about__.py

@@ -1 +0,0 @@
-__version__ = '0.0.2'

pytest_isolate-0.0.2/tox.ini

@@ -1,25 +0,0 @@
-# For more information about tox, see https://tox.readthedocs.io/en/latest/
-[tox]
-envlist = py{37,311}
-isolated_build = True
-
-[tox:.package]
-# note tox will use the same python version as under what tox is installed to package
-# so unless this is python 3 you can require a given python version for the packaging
-# environment via the basepython key
-basepython = python3
-
-
-[testenv]
-deps = pytest>6.0
-commands = pytest --isolate  --import-mode importlib {posargs:tests}
-
-[testenv:ruff]
-skip_install = true
-deps = ruff
-commands = ruff .
-
-[gh]
-python =
-    3.7 = py37
-    3.11 = py311, ruff