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

{pytest_isolate-0.0.3 → pytest_isolate-0.0.8}/.github/workflows/python-package.yml

@@ -16,8 +16,8 @@ jobs:
         os:
           - Ubuntu
         py:
-          - "3.11"
-          - "3.7"
+          - "3.12"
+          - "3.9"
     steps:
       - name: Setup python for test ${{ matrix.py }}
         uses: actions/setup-python@v2

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

@@ -1,25 +1,28 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pytest-isolate
-Version: 0.0.3
-Summary: Run pytest tests in isolated subprocesses
+Version: 0.0.8
+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: MIT
+License-Expression: MIT
+License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.7
 Requires-Dist: dill
+Requires-Dist: filelock
 Requires-Dist: pytest
 Requires-Dist: tblib
+Provides-Extra: gpu
+Requires-Dist: pynvml; extra == 'gpu'
 Description-Content-Type: text/markdown
 
 # pytest-isolate
@@ -39,19 +42,32 @@ This pytest plugin was generated with Cookiecutter along with `@hackebrot`'s `co
 * Captures stdout & stderr of crashing processes
 * Add Timeout to a forked test
 * Limit memory used by test
+* Limit CPU time used by test
+* Manage GPU resources with CUDA_VISIBLE_DEVICES
 * Plays nice with pytest-xdist
 * Shows warnings, even with xdist!
+* *Create visual timeline of test execution (isolated or not)*
 
 ## Requirements
 
 * pytest
 
+### Optional Dependencies
+
+For GPU resource management:
+
+* pynvml (optional, for automatic GPU detection)
+
 ## Installation
 
 You can install "pytest-isolate" via `pip` from `PyPI`
 
     pip install pytest-isolate
 
+For GPU resource management support:
+
+    pip install pytest-isolate[gpu]
+
 ## Usage
 
     pytest --isolate
@@ -64,6 +80,13 @@ Or:
 
 To set a timeout to every test in addition to forking, and limit to 10 cpu seconds.
 
+Or:
+
+    pytest --timeline
+
+With possible combination of the above, to generate a timeline of test execution. The
+timeline can be viewed in chrome://tracing.
+
 > Note:
 >
 > Since this plugin uses `fork`, it will not work on  operating systems without `fork` support (e.g. Windows).
@@ -75,7 +98,9 @@ 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 and/or cpu usage test:
+### Using the isolate marker
+
+You can 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, cpu_limit=10)
@@ -83,7 +108,19 @@ def test_something():
     pass
 ```
 
-The options can also be set in an pytest configuration file, e.g:
+The `isolate` marker can also be used to request gpus for a test on a gpu machine:
+
+```python
+# Request 2 GPUs for this test
+@pytest.mark.isolate(resources={'gpu': 2})
+def test_with_gpus():
+    # The test will have CUDA_VISIBLE_DEVICES set to the allocated GPU IDs
+    assert len(os.environ.get("CUDA_VISIBLE_DEVICES").split(",")) == 2
+```
+
+### Configuration Options
+
+The options can be set in an pytest configuration file, e.g:
 
 ```toml
 [tool.pytest.ini_options]
@@ -92,6 +129,15 @@ isolate_mem_limit=1000000
 isolate_cpu_limit=10
 ```
 
+## CUDA_VISIBLE_DEVICES Handling
+
+If `CUDA_VISIBLE_DEVICES` is already set when pytest starts, the plugin will respect this setting and only allocate from the GPUs specified there. This works even without pynvml installed.
+
+For example:
+
+* If `CUDA_VISIBLE_DEVICES=0,1,2` is set, tests will only use GPUs 0, 1, and 2.
+* If `CUDA_VISIBLE_DEVICES=` is set (empty), no GPUs will be used.
+
 ## Contributing
 
 Contributions are very welcome. Tests can be run with `tox`, please ensure

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

@@ -15,19 +15,32 @@ This pytest plugin was generated with Cookiecutter along with `@hackebrot`'s `co
 * Captures stdout & stderr of crashing processes
 * Add Timeout to a forked test
 * Limit memory used by test
+* Limit CPU time used by test
+* Manage GPU resources with CUDA_VISIBLE_DEVICES
 * Plays nice with pytest-xdist
 * Shows warnings, even with xdist!
+* *Create visual timeline of test execution (isolated or not)*
 
 ## Requirements
 
 * pytest
 
+### Optional Dependencies
+
+For GPU resource management:
+
+* pynvml (optional, for automatic GPU detection)
+
 ## Installation
 
 You can install "pytest-isolate" via `pip` from `PyPI`
 
     pip install pytest-isolate
 
+For GPU resource management support:
+
+    pip install pytest-isolate[gpu]
+
 ## Usage
 
     pytest --isolate
@@ -40,6 +53,13 @@ Or:
 
 To set a timeout to every test in addition to forking, and limit to 10 cpu seconds.
 
+Or:
+
+    pytest --timeline
+
+With possible combination of the above, to generate a timeline of test execution. The
+timeline can be viewed in chrome://tracing.
+
 > Note:
 >
 > Since this plugin uses `fork`, it will not work on  operating systems without `fork` support (e.g. Windows).
@@ -51,7 +71,9 @@ 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 and/or cpu usage test:
+### Using the isolate marker
+
+You can 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, cpu_limit=10)
@@ -59,7 +81,19 @@ def test_something():
     pass
 ```
 
-The options can also be set in an pytest configuration file, e.g:
+The `isolate` marker can also be used to request gpus for a test on a gpu machine:
+
+```python
+# Request 2 GPUs for this test
+@pytest.mark.isolate(resources={'gpu': 2})
+def test_with_gpus():
+    # The test will have CUDA_VISIBLE_DEVICES set to the allocated GPU IDs
+    assert len(os.environ.get("CUDA_VISIBLE_DEVICES").split(",")) == 2
+```
+
+### Configuration Options
+
+The options can be set in an pytest configuration file, e.g:
 
 ```toml
 [tool.pytest.ini_options]
@@ -68,6 +102,15 @@ isolate_mem_limit=1000000
 isolate_cpu_limit=10
 ```
 
+## CUDA_VISIBLE_DEVICES Handling
+
+If `CUDA_VISIBLE_DEVICES` is already set when pytest starts, the plugin will respect this setting and only allocate from the GPUs specified there. This works even without pynvml installed.
+
+For example:
+
+* If `CUDA_VISIBLE_DEVICES=0,1,2` is set, tests will only use GPUs 0, 1, and 2.
+* If `CUDA_VISIBLE_DEVICES=` is set (empty), no GPUs will be used.
+
 ## Contributing
 
 Contributions are very welcome. Tests can be run with `tox`, please ensure

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pytest-isolate"
-description = 'Run pytest tests in isolated subprocesses'
+description = 'Run pytest tests in isolated subprocesses '
 readme = "README.md"
 requires-python = ">=3.7"
 license = "MIT"
@@ -13,17 +13,19 @@ authors = [{ name = "gilfree", email = "gilfree@users.noreply.github.com" }]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.7",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["dill", "tblib", "pytest"]
+dependencies = ["dill", "tblib", "pytest","filelock"]
 dynamic = ["version"]
 
+[project.optional-dependencies]
+gpu = ["pynvml"]
+
 [project.urls]
 Documentation = "https://github.com/gilfree/pytest-isolate#readme"
 Issues = "https://github.com/gilfree/pytest-isolate/issues"

pytest_isolate-0.0.8/src/pytest_isolate/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.0.8"

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

@@ -1,12 +1,13 @@
 # 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 
+# Since pytest forked is un unmaintained I decided to make my
 # changes in a different project
 # Please see README.md
 
 
 import fcntl
 import io
+import json
 import multiprocessing as mp
 import os
 import resource
@@ -28,7 +29,7 @@ except ImportError:
     pass
 
 try:
-    import setproctitle # noqa F401
+    import setproctitle  # noqa F401
 except ImportError:
     pass
 
@@ -39,13 +40,50 @@ try:
 except ImportError:
     pass
 
+from pytest_isolate.resource_management import (
+    clean_resources,
+    cleanup_resource_environment,
+    parse_resource_list,
+    register_resource_provider,
+    setup_resource_environment,
+)
+
+
+def get_available_gpus() -> List[int]:
+    # Check if CUDA_VISIBLE_DEVICES is already set
+    cuda_visible_devices = os.environ.get("CUDA_VISIBLE_DEVICES")
+    if cuda_visible_devices is not None:
+        return parse_resource_list(cuda_visible_devices)
+
+    # If not set and pynvml is available, get all GPUs
+    try:
+        import pynvml
+
+        pynvml.nvmlInit()
+        count = pynvml.nvmlDeviceGetCount()
+        resources = list(range(count))
+        pynvml.nvmlShutdown()
+        return resources
+    except Exception:
+        warnings.warn("Failed to get GPU count using pynvml", RuntimeWarning)
+
+    return []
+
 
 def forked_subprocess(
-    target, args=(), timeout=None, memlimt=None, cpulimit=None
+    target,
+    args=(),
+    timeout=None,
+    memlimt=None,
+    cpulimit=None,
+    wait_delta=0.05,
+    resource_dict=None,
+    test_id=None,
+    resource_timeout=None,
 ) -> Tuple[Any, int, bool]:
-    sub = ForkedSubprocess()
+    sub = ForkedSubprocess(wait_delta=wait_delta)
     exitcode, timed_out, result = sub.run_in_subprocess(
-        timeout, memlimt, cpulimit, target, args
+        timeout, memlimt, cpulimit, resource_dict, test_id, resource_timeout, target, args
     )
     return result, exitcode, timed_out
 
@@ -72,7 +110,8 @@ def limits(max_mem, max_cpu):
 
 
 class ForkedSubprocess:
-    def __init__(self) -> None:
+    def __init__(self, wait_delta=0.05) -> None:
+        self.wait_delta = wait_delta
         self.r_out, self.w_out = os.pipe()
         self.r_err, self.w_err = os.pipe()
         fcntl.fcntl(self.r_err, fcntl.F_SETFL, os.O_NONBLOCK)
@@ -102,7 +141,17 @@ class ForkedSubprocess:
         os.close(self.w_out)
         os.close(self.w_err)
 
-    def run_in_subprocess(self, timeout, memlimit, cpulimit, target, args=()):
+    def run_in_subprocess(
+        self,
+        timeout,
+        memlimit,
+        cpulimit,
+        resource_dict,
+        test_id,
+        resource_timeout,
+        target,
+        args=(),
+    ):
         ctx = mp.get_context("fork")
         q = ctx.Queue()
         timed_out = None
@@ -112,7 +161,8 @@ class ForkedSubprocess:
             self.child_redirect_streams()
             try:
                 with limits(memlimit, cpulimit):
-                    q.put(dill.dumps(target(*args)))
+                    with allocate_resources(resource_dict, test_id, resource_timeout):
+                        q.put(dill.dumps(target(*args)))
             except BaseException as e:
                 q.put(dill.dumps(e))
             sys.stdout.flush()
@@ -122,16 +172,17 @@ class ForkedSubprocess:
         p = ctx.Process(target=run_subprocess)
         p.start()
         self.parent_open_streams()
-        time_left = timeout or 1
+        delta = self.wait_delta
+        time_left = timeout or delta
         result = None
         while time_left > 0:
             try:
-                result = dill.loads(q.get(block=True, timeout=min(1, time_left)))
+                result = dill.loads(q.get(block=True, timeout=min(delta, time_left)))
             except Empty:
                 if not p.is_alive():
                     break
                 if timeout is not None:
-                    time_left = time_left - 1
+                    time_left = time_left - delta
             except Exception as e:
                 result = e
                 break
@@ -162,7 +213,7 @@ def pytest_load_initial_conftests(early_config, parser, args):
     )
     early_config.addinivalue_line(
         "markers",
-        "isolate: Always isolate this test.",
+        "isolate: Always isolate this test, possibly with resources.",
     )
     early_config.addinivalue_line(
         "markers",
@@ -208,6 +259,35 @@ def pytest_addoption(parser):
     parser.addini(
         "isolate_cpu_limit", "Default cpu limit for isolated tests", type="string"
     )
+    parser.addini(
+        "wait_delta",
+        "Delta between subprocess queue pollings",
+        type="string",
+        default="0.05",
+    )
+    parser.addini(
+        "resource_timeout",
+        "Timeout for resource allocation",
+        type="string",
+        default="300",
+    )
+    parser.addoption(
+        "--timeline",
+        dest="timeline",
+        action="store_true",
+        default=False,
+        help="Report test timelines",
+    )
+
+    parser.addoption(
+        "--timeline-file",
+        dest="timeline_file",
+        default="./timeline.json",
+        help="Path to the timeline file",
+    )
+
+    parser.addini("timeline_file", "timeline file", type="string")
+
 
 
 @pytest.hookimpl(trylast=True)
@@ -235,6 +315,8 @@ def pytest_configure(config):
             "markers",
             "timeout: Run this tests in a separate, forked, process with timeout",
         )
+    clean_resources()
+    register_resource_provider("gpu", "CUDA_VISIBLE_DEVICES", get_available_gpus)
 
 
 # Taken from pytest 7.2:
@@ -296,23 +378,56 @@ def run_subprocess(item: pytest.Item):
                     config=item.config, report=report
                 )
             )
+
         return s_reports, warnings
     except BaseException as e:
         return e, None
 
 
+@contextmanager
+def allocate_resources(resource_dict, test_id, timeout):
+    resource_dict = resource_dict or {}
+    allocated_resources = {}
+    for resource_type, count in resource_dict.items():
+        # Allocate resources
+        resource_ids = setup_resource_environment(
+            test_id=f"{test_id}_{resource_type}",
+            count=count,
+            resource_type=resource_type,
+            wait_timeout=timeout,
+        )
+        allocated_resources[resource_type] = resource_ids
+    try:
+        yield allocated_resources
+    finally:
+        for res_type, _ in allocated_resources.items():
+            cleanup_resource_environment(f"{test_id}_{res_type}", res_type)
+
+
 def run_in_subprocess(
     item: pytest.Item,
     timeout: Optional[float],
     mem_limit: Optional[int],
     cpu_limit: Optional[int],
+    wait_delta: float,
 ) -> List[pytest.TestReport]:
     cap = item.config.pluginmanager.getplugin("capturemanager")
     assert isinstance(cap, _pytest.capture.CaptureManager)
     cap.resume_global_capture()
     cap.activate_fixture()
+    resource_dict = get_resource_dict(item)
+    test_id = f"{item.nodeid}"
+    resource_timeout = float(item.config.getini("resource_timeout"))  # type: ignore
     result, exitcode, timed_out = forked_subprocess(
-        run_subprocess, (item,), timeout, mem_limit, cpu_limit
+        run_subprocess,
+        (item,),
+        timeout,
+        mem_limit,
+        cpu_limit,
+        wait_delta,
+        resource_dict,
+        test_id,
+        resource_timeout,
     )
     cap.deactivate_fixture()
     cap.suspend_global_capture(in_=False)
@@ -396,7 +511,7 @@ def report_process_crash(
     reason = xfail_marker.kwargs.get("reason", "")
     rep.wasxfail = ""
     if reason:
-        rep.wasxfail = f"reason: {xfail_marker.kwargs.get('reason','')}; "
+        rep.wasxfail = f"reason: {xfail_marker.kwargs.get('reason', '')}; "
     rep.wasxfail += f"pytest-isolate reason: {call.excinfo}"
 
     warnings.warn(
@@ -447,23 +562,66 @@ def get_marker(item, marker_name, argname=None, pos=None):
     return marker
 
 
+def get_resource_dict(item):
+    """
+    Get resource requirements from the resources parameter of the isolate marker.
+
+    Example: @pytest.mark.isolate(resources={'gpu': 2})
+    """
+    resources = {}
+    isolate_marker = item.get_closest_marker("isolate")
+
+    if isolate_marker is not None and "resources" in isolate_marker.kwargs:
+        resources_param = isolate_marker.kwargs.get("resources", {})
+
+        # Ensure the resources parameter is a dictionary
+        if not isinstance(resources_param, dict):
+            warnings.warn(
+                f"Invalid resources parameter {resources_param}. Must be a dictionary.",
+                RuntimeWarning,
+            )
+            return resources
+
+        # Process each resource requirement
+        for resource_type, count in resources_param.items():
+            try:
+                count = int(count)
+                if count < 0:
+                    warnings.warn(
+                        f"Invalid {resource_type} count: {count}. Must be >= 0.",
+                        RuntimeWarning,
+                    )
+                    continue
+                resources[resource_type] = count
+            except (ValueError, TypeError):
+                warnings.warn(
+                    f"Invalid {resource_type} count: {count}. Must be an integer.",
+                    RuntimeWarning,
+                )
+
+    return resources
+
+
 @pytest.hookimpl(tryfirst=True)
-def pytest_runtest_protocol(item):
+def pytest_runtest_protocol(item: pytest.Item):
     if item.config.pluginmanager.get_plugin("forked"):
         return
     if item.config.pluginmanager.get_plugin("timeout"):
         return
-    isolate, timeout, mem_limit, cpu_limit = get_isolation_options(item)
+    isolate, timeout, mem_limit, cpu_limit, resource_reqs = get_isolation_options(item)
+
+    wait_delta = float(item.config.getini("wait_delta"))  # type: ignore
 
     if (
         isolate is not None
         or mem_limit is not None
         or timeout is not None
         or cpu_limit is not None
+        or resource_reqs
     ):
         ihook = item.ihook
         ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
-        reports = run_in_subprocess(item, timeout, mem_limit, cpu_limit)
+        reports = run_in_subprocess(item, timeout, mem_limit, cpu_limit, wait_delta)
 
         for rep in reports:
             ihook.pytest_runtest_logreport(report=rep)
@@ -550,42 +708,100 @@ def get_isolation_options(item):
         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
+    # Get resources from isolate(resources={'gpu': 2}) syntax
+    resource_dict = get_resource_dict(item)
+
+    # If resources are requested, ensure isolation
+    if resource_dict and not isolate:
+        isolate = True
+
+    return isolate, timeout, mem_limit, cpu_limit, resource_dict
 
 
 @pytest.hookimpl(tryfirst=True)
-def pytest_terminal_summary(terminalreporter) -> None:
+def pytest_terminal_summary(terminalreporter, exitstatus, config) -> 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}")
+    if durations is not None:
+        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}")
+
+    if config.getoption("timeline"):
+        events = []
+        for replist in tr.stats.values():
+            rep: pytest.TestReport
+
+            for rep in replist:
+                if not isinstance(rep, pytest.TestReport) or rep.when != "call":
+                    continue
+                props = dict(getattr(rep, "user_properties", ()))
+                events.extend(
+                    create_event(
+                        props.get("worker_id", "master"),
+                        rep.nodeid,
+                        rep.outcome,
+                        rep.start,
+                        rep.stop,
+                    )
+                )
+        filename = config.getoption("timeline_file")
+        os.makedirs(os.path.dirname(os.path.abspath(filename)), exist_ok=True)
+        json.dump(events, open(filename, "w"))
+
+
+@pytest.hookimpl(tryfirst=False, hookwrapper=True)
+def pytest_runtest_call(item: pytest.Item):
+    yield
+    item.user_properties.append(
+        ("worker_id", os.getenv("PYTEST_XDIST_WORKER", "master"))
+    )
+
+
+def create_event(worker_name, test_name, category, start_time, end_time, **kwargs):
+    start_event = {
+        "name": test_name.rsplit("/")[-1],
+        "cat": category,
+        "ph": "B",
+        "pid": worker_name,
+        "tid": 0,
+        "ts": start_time * (1000**2),
+        "args": kwargs,
+    }
+    end_event = {
+        "name": test_name.rsplit("/")[-1],
+        "cat": "pipeline",
+        "ph": "E",
+        "pid": worker_name,
+        "tid": 0,
+        "ts": end_time * (1000**2),
+    }
+    return start_event, end_event

pytest_isolate-0.0.8/src/pytest_isolate/resource_management.py

@@ -0,0 +1,148 @@
+import json
+import os
+import tempfile
+import time
+import warnings
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Callable, List, Optional
+
+import filelock
+
+# Constants
+
+DEFAULT_STATE_FILE = Path(tempfile.gettempdir()) / "pytest_isolate_resources.json"
+DEFAULT_WAIT_TIMEOUT = 300  # 5 minutes
+POLL_INTERVAL = 0.1  # 1 second
+
+
+@contextmanager
+def lock_resource_file():
+    with filelock.FileLock(str(DEFAULT_STATE_FILE)+'.lock', timeout=4) as lock:
+        yield lock
+
+
+@dataclass
+class Resource:
+    env_variable: str
+    available: List[int]
+    allocated: dict[str, List[int]]
+
+    def allocate(self, test_id: str, count: int) -> List[int]:
+        """Allocate resources for a test."""
+        if len(self.available) < count:
+            return []
+
+        allocated = self.available[:count]
+        self.allocated[test_id] = allocated
+        self.available = self.available[count:]
+        return allocated
+
+    def release(self, test_id: str) -> None:
+        """Release resources for a test."""
+        if test_id in self.allocated:
+            released = self.allocated.pop(test_id)
+            self.available.extend(released)
+        else:
+            raise ValueError(f"Test ID {test_id} not found in allocated resources.")
+
+
+@dataclass
+class StateData:
+    resources: dict[str, Resource]
+
+    @classmethod
+    def get_instance(cls) -> "StateData":
+        if not DEFAULT_STATE_FILE.exists():
+            data = {}
+        try:
+            with open(DEFAULT_STATE_FILE, "r") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            data = {}
+        return StateData(
+            resources={name: Resource(**res) for name, res in data.items()}
+        )
+
+    def save(self) -> None:
+        with open(DEFAULT_STATE_FILE, "w") as f:
+            json.dump({name: asdict(res) for name, res in self.resources.items()}, f)
+
+
+def clean_resources() -> None:
+    """Clean up resources by removing lock and state files."""
+    if DEFAULT_STATE_FILE.exists():
+        os.remove(DEFAULT_STATE_FILE)
+
+
+def register_resource_provider(
+    resource_type: str, env_variable: str, provider_func: Callable[[], List[int]]
+) -> None:
+    with lock_resource_file():
+        existing = provider_func()
+        state = StateData.get_instance()
+        if resource_type in state.resources:
+            warnings.warn(
+                f"Resource type {resource_type} already registered. Overwriting."
+            )
+        state.resources[resource_type] = Resource(
+            env_variable=env_variable,
+            available=existing,
+            allocated={},
+        )
+        state.save()
+
+
+def parse_resource_list(env_value: Optional[str]) -> List[int]:
+    """Parse a comma-separated list of resource IDs from an environment variable."""
+    if not env_value:
+        return []
+    try:
+        vals= [int(x.strip()) for x in env_value.split(",") if x.strip()]
+        vals = [x for x in vals if x >= 0]
+        return vals
+    except ValueError:
+        return []
+
+
+def setup_resource_environment(
+    test_id: str,
+    count: int,
+    resource_type: str,
+    wait_timeout: Optional[float] = None,
+) -> Optional[List[int]]:
+    def try_allocate() -> Optional[List[int]]:
+        with lock_resource_file():
+            state = StateData.get_instance()
+            if resource_type not in state.resources:
+                raise ValueError(f"Resource type {resource_type} not registered.")
+
+            resource = state.resources[resource_type]
+            allocated = resource.allocate(test_id, count)
+            if allocated:
+                os.environ[resource.env_variable] = ",".join(map(str, allocated))
+                state.save()
+                return allocated
+        return []
+
+    timeout = wait_timeout or DEFAULT_WAIT_TIMEOUT
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        allocated = try_allocate()
+        if allocated:
+            return allocated
+        time.sleep(POLL_INTERVAL)
+    raise TimeoutError(f"Timeout while waiting for resources of type {resource_type}.")
+
+
+def cleanup_resource_environment(test_id: str, resource_type: str) -> None:
+    with lock_resource_file():
+        state = StateData.get_instance()
+        if resource_type not in state.resources:
+            raise ValueError(f"Resource type {resource_type} not registered.")
+
+        resource = state.resources[resource_type]
+        resource.release(test_id)
+        os.environ.pop(resource.env_variable, None)
+        state.save()

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

@@ -74,7 +74,13 @@ def test_warn():
 @pytest.mark.isolate(cpu_limit=1)
 def test_isolate_cpu():
     import numpy as np
+
     # hog CPU:
-    x=0
+    x = 0
     for i in range(100):
-        x+=(np.random.rand(1000,1000)@np.random.rand(1000,1000)).sum()
+        x += (np.random.rand(1000, 1000) @ np.random.rand(1000, 1000)).sum()
+
+
+def test_slow():
+    sleep(0.1)
+    pass

pytest_isolate-0.0.8/tests/test_resource_management.py

@@ -0,0 +1,81 @@
+import os
+import random
+import tempfile
+from importlib import resources
+from pathlib import Path
+from time import sleep
+from unittest import mock
+
+import filelock
+import pytest
+
+from pytest_isolate.plugin import allocate_resources
+from pytest_isolate.resource_management import (
+    parse_resource_list,
+    register_resource_provider,
+)
+
+
+@pytest.fixture
+def temp_resource_files():
+    """Create temporary files for resource manager testing"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        lock_file = Path(tmpdir) / "resources.lock"
+        state_file = Path(tmpdir) / "resources.json"
+        yield lock_file, state_file
+
+
+@pytest.fixture
+def mock_pynvml():
+    """Mock pynvml module for testing"""
+    pynvml_mock = mock.MagicMock()
+    pynvml_mock.nvmlDeviceGetCount.return_value = 4
+
+    # Mock the import so it returns our mock when imported in plugin.py
+    with mock.patch.dict("sys.modules", {"pynvml": pynvml_mock}):
+        yield pynvml_mock
+
+
+def test_parse_resource_list():
+    """Test parsing resources from environment variables."""
+    # Test empty input
+    assert parse_resource_list(None) == []
+    assert parse_resource_list("") == []
+
+    # Test simple cases
+    assert parse_resource_list("0") == [0]
+    assert parse_resource_list("0,1,2") == [0, 1, 2]
+
+    # Test with spaces
+    assert parse_resource_list(" 0, 1, 2 ") == [0, 1, 2]
+
+    # Test with invalid values - no warning in new implementation
+    assert parse_resource_list("0,a,2") == []
+
+
+def test_allocate_resources():
+    with allocate_resources({"gpu": 1}, "foo", 100) as allocated:
+        assert allocated["gpu"] == [0]
+        assert os.environ.get("CUDA_VISIBLE_DEVICES") == "0"
+
+
+
+@pytest.mark.isolate(resources={"gpu": 2}, timeout=10)
+@pytest.mark.parametrize("dummy", [1] * 2)
+def test_gpu_marker_2(dummy):
+    sleep(0.3)
+    assert len(os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",")) == 2
+
+
+@pytest.mark.isolate(resources={"gpu": 1}, timeout=10)
+@pytest.mark.parametrize("dummy", [1] * 2)
+def test_gpu_marker_1(dummy):
+    sleep(0.3)
+    assert len(os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",")) == 1
+
+
+@pytest.mark.xfail
+@pytest.mark.isolate(resources={"gpu": 7}, timeout=4)
+def test_gpu_marker_7():
+    sleep(0.3)
+    assert len(os.environ.get("CUDA_VISIBLE_DEVICES", "").split(",")) == 7

{pytest_isolate-0.0.3 → pytest_isolate-0.0.8}/tox.ini

@@ -2,7 +2,7 @@
 [tox]
 requires =
     tox >=4
-envlist = py{37,311}
+envlist = py{39,312}
 isolated_build = True
 
 [testenv]
@@ -11,8 +11,10 @@ deps =
     numpy
     pytest-xdist
     pytest-sugar
-
-commands = pytest --isolate  --import-mode importlib {posargs:tests}
+    pytest-mock
+setenv = 
+    CUDA_VISIBLE_DEVICES = 0,1
+commands = pytest --isolate  --import-mode importlib {posargs:tests} --timeline 
 
 [testenv:lint]
 skip_install = true
@@ -21,5 +23,5 @@ commands = ruff check {postargs:.}
 
 [gh]
 python =
-    3.7 = py37
-    3.11 = py311
+    3.9 = py39
+    3.12 = py312

pytest_isolate-0.0.3/src/pytest_isolate/__about__.py

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