pytest-isolated 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

pytest_isolated/__init__.py

@@ -1,3 +1,3 @@
 """pytest-isolated: Run pytest tests in isolated subprocesses."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

pytest_isolated/plugin.py

@@ -6,42 +6,77 @@ import os
 import subprocess
 import sys
 import tempfile
+import time
 from collections import OrderedDict
 from pathlib import Path
-from typing import Any
+from typing import Any, Final, Literal, TypedDict, cast
 
 import pytest
 
 # Guard to prevent infinite recursion (parent spawns child; child must not spawn again)
-SUBPROC_ENV = "PYTEST_RUNNING_IN_SUBPROCESS"
+SUBPROC_ENV: Final = "PYTEST_RUNNING_IN_SUBPROCESS"
 
 # Parent tells child where to write JSONL records per test call
-SUBPROC_REPORT_PATH = "PYTEST_SUBPROCESS_REPORT_PATH"
+SUBPROC_REPORT_PATH: Final = "PYTEST_SUBPROCESS_REPORT_PATH"
+
+# Arguments to exclude when forwarding options to subprocess
+_EXCLUDED_ARG_PREFIXES: Final = (
+    "--junitxml=",
+    "--html=",
+    "--result-log=",
+    "--collect-only",
+    "--setup-only",
+    "--setup-plan",
+    "-x",
+    "--exitfirst",
+    "--maxfail=",
+)
+
+# Plugin-specific options that take values and should not be forwarded
+_PLUGIN_OPTIONS_WITH_VALUE: Final = ("--isolated-timeout",)
+
+# Plugin-specific flag options that should not be forwarded
+_PLUGIN_FLAGS: Final = ("--no-isolation",)
+
+
+class _TestRecord(TypedDict, total=False):
+    """Structure for test phase results from subprocess."""
+
+    nodeid: str
+    when: Literal["setup", "call", "teardown"]
+    outcome: Literal["passed", "failed", "skipped"]
+    longrepr: str
+    duration: float
+    stdout: str
+    stderr: str
+    keywords: list[str]
+    sections: list[tuple[str, str]]
+    user_properties: list[tuple[str, Any]]
+    wasxfail: bool
 
 
 def pytest_addoption(parser: pytest.Parser) -> None:
-    """Add configuration options for subprocess isolation."""
-    group = parser.getgroup("subprocess")
+    group = parser.getgroup("isolated")
     group.addoption(
-        "--subprocess-timeout",
+        "--isolated-timeout",
         type=int,
         default=None,
-        help="Timeout in seconds for subprocess groups (default: 300)",
+        help="Timeout in seconds for isolated test groups (default: 300)",
     )
     group.addoption(
-        "--no-subprocess",
+        "--no-isolation",
         action="store_true",
         default=False,
         help="Disable subprocess isolation (for debugging)",
     )
     parser.addini(
-        "subprocess_timeout",
+        "isolated_timeout",
         type="string",
         default="300",
-        help="Default timeout in seconds for subprocess groups",
+        help="Default timeout in seconds for isolated test groups",
     )
     parser.addini(
-        "subprocess_capture_passed",
+        "isolated_capture_passed",
         type="bool",
         default=False,
         help="Capture output for passed tests (default: False)",
@@ -51,8 +86,9 @@ def pytest_addoption(parser: pytest.Parser) -> None:
 def pytest_configure(config: pytest.Config) -> None:
     config.addinivalue_line(
         "markers",
-        "subprocess(group=None): run this test in a grouped fresh Python subprocess; "
-        "tests with the same group run together in one subprocess.",
+        "isolated(group=None, timeout=None): run this test in a grouped "
+        "fresh Python subprocess; tests with the same group run together in "
+        "one subprocess. timeout (seconds) overrides global --isolated-timeout.",
     )
 
 
@@ -60,17 +96,13 @@ def pytest_configure(config: pytest.Config) -> None:
 # CHILD MODE: record results + captured output per test phase
 # ----------------------------
 def pytest_runtest_logreport(report: pytest.TestReport) -> None:
-    """
-    In the child process, write one JSON line per test phase (setup/call/teardown)
-    containing outcome, captured stdout/stderr, duration, and other metadata.
-    The parent will aggregate and re-emit this info.
-    """
+    """Write test phase results to a JSONL file when running in subprocess mode."""
     path = os.environ.get(SUBPROC_REPORT_PATH)
     if not path:
         return
 
     # Capture ALL phases (setup, call, teardown), not just call
-    rec = {
+    rec: _TestRecord = {
         "nodeid": report.nodeid,
         "when": report.when,  # setup, call, or teardown
         "outcome": report.outcome,  # passed/failed/skipped
@@ -94,23 +126,21 @@ def pytest_runtest_logreport(report: pytest.TestReport) -> None:
 def pytest_collection_modifyitems(
     config: pytest.Config, items: list[pytest.Item]
 ) -> None:
-    """
-    Partition items into subprocess groups + normal items and stash on config.
-    """
     if os.environ.get(SUBPROC_ENV) == "1":
         return  # child should not do grouping
 
-    # If --no-subprocess is set, treat all tests as normal (no subprocess isolation)
-    if config.getoption("no_subprocess", False):
+    # If --no-isolation is set, treat all tests as normal (no subprocess isolation)
+    if config.getoption("no_isolation", False):
         config._subprocess_groups = OrderedDict()  # type: ignore[attr-defined]
         config._subprocess_normal_items = items  # type: ignore[attr-defined]
         return
 
     groups: OrderedDict[str, list[pytest.Item]] = OrderedDict()
+    group_timeouts: dict[str, int | None] = {}  # Track timeout per group
     normal: list[pytest.Item] = []
 
     for item in items:
-        m = item.get_closest_marker("subprocess")
+        m = item.get_closest_marker("isolated")
         if not m:
             normal.append(item)
             continue
@@ -119,46 +149,51 @@ def pytest_collection_modifyitems(
         # Default grouping to module path (so you don't accidentally group everything)
         if group is None:
             group = item.nodeid.split("::")[0]
-        groups.setdefault(str(group), []).append(item)
+
+        # Store group-specific timeout (first marker wins)
+        group_key = str(group)
+        if group_key not in group_timeouts:
+            group_timeouts[group_key] = m.kwargs.get("timeout")
+
+        groups.setdefault(group_key, []).append(item)
 
     config._subprocess_groups = groups  # type: ignore[attr-defined]
+    config._subprocess_group_timeouts = group_timeouts  # type: ignore[attr-defined]
     config._subprocess_normal_items = normal  # type: ignore[attr-defined]
 
 
 def pytest_runtestloop(session: pytest.Session) -> int | None:
-    """
-    Run each subprocess group in its own subprocess once;
-    then run normal tests in-process.
-
-    Enhanced to:
-    - Capture all test phases (setup, call, teardown)
-    - Support configurable timeouts
-    - Properly handle crashes and missing results
-    - Integrate with pytest's reporting system
+    """Execute isolated test groups in subprocesses and remaining tests in-process.
+
+    Any subprocess timeouts are caught and reported as test failures; the
+    subprocess.TimeoutExpired exception is not propagated to the caller.
     """
     if os.environ.get(SUBPROC_ENV) == "1":
         return None  # child runs the normal loop
 
     config = session.config
-    groups: OrderedDict[str, list[pytest.Item]] = getattr(
-        config, "_subprocess_groups", OrderedDict()
+    groups = getattr(config, "_subprocess_groups", OrderedDict())
+    if not isinstance(groups, OrderedDict):
+        groups = OrderedDict()
+    group_timeouts: dict[str, int | None] = getattr(
+        config, "_subprocess_group_timeouts", {}
     )
     normal_items: list[pytest.Item] = getattr(
         config, "_subprocess_normal_items", session.items
     )
 
-    # Get timeout configuration
-    timeout_opt = config.getoption("subprocess_timeout", None)
-    timeout_ini = config.getini("subprocess_timeout")
-    timeout = timeout_opt or (int(timeout_ini) if timeout_ini else 300)
+    # Get default timeout configuration
+    timeout_opt = config.getoption("isolated_timeout", None)
+    timeout_ini = config.getini("isolated_timeout")
+    default_timeout = timeout_opt or (int(timeout_ini) if timeout_ini else 300)
 
     # Get capture configuration
-    capture_passed = config.getini("subprocess_capture_passed")
+    capture_passed = config.getini("isolated_capture_passed")
 
     def emit_report(
         item: pytest.Item,
-        when: str,
-        outcome: str,
+        when: Literal["setup", "call", "teardown"],
+        outcome: Literal["passed", "failed", "skipped"],
         longrepr: str = "",
         duration: float = 0.0,
         stdout: str = "",
@@ -167,10 +202,6 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
         user_properties: list[tuple[str, Any]] | None = None,
         wasxfail: bool = False,
     ) -> None:
-        """
-        Emit a synthetic report for the given item and phase.
-        Attach captured output based on outcome and configuration.
-        """
         call = pytest.CallInfo.from_call(lambda: None, when=when)
         rep = pytest.TestReport.from_item_and_call(item, call)
         rep.outcome = outcome
@@ -185,7 +216,8 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
         # For skipped tests, longrepr needs to be a tuple (path, lineno, reason)
         if outcome == "skipped" and longrepr:
             # Parse longrepr or create simple tuple
-            rep.longrepr = (str(item.fspath), item.location[1], longrepr)
+            lineno = item.location[1] if item.location[1] is not None else -1
+            rep.longrepr = (str(item.fspath), lineno, longrepr)  # type: ignore[assignment]
         elif outcome == "failed" and longrepr:
             rep.longrepr = longrepr
 
@@ -205,6 +237,9 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
     for group_name, group_items in groups.items():
         nodeids = [it.nodeid for it in group_items]
 
+        # Get timeout for this group (marker timeout > global timeout)
+        group_timeout = group_timeouts.get(group_name) or default_timeout
+
         # file where the child will append JSONL records
         with tempfile.NamedTemporaryFile(
             prefix="pytest-subproc-", suffix=".jsonl", delete=False
@@ -215,12 +250,74 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
         env[SUBPROC_ENV] = "1"
         env[SUBPROC_REPORT_PATH] = report_path
 
-        # Run pytest in subprocess with timeout
-        cmd = [sys.executable, "-m", "pytest", *nodeids]
+        # Run pytest in subprocess with timeout, tracking execution time
+        # Preserve rootdir and run subprocess from correct directory to ensure
+        # nodeids can be resolved
+        cmd = [sys.executable, "-m", "pytest"]
+
+        # Forward relevant pytest options to subprocess for consistency
+        # We filter out options that would interfere with subprocess execution
+        if hasattr(config, "invocation_params") and hasattr(
+            config.invocation_params, "args"
+        ):
+            forwarded_args = []
+            skip_next = False
+
+            for arg in config.invocation_params.args:
+                if skip_next:
+                    skip_next = False
+                    continue
+
+                # Skip our own plugin options
+                if arg in _PLUGIN_OPTIONS_WITH_VALUE:
+                    skip_next = True
+                    continue
+                if arg in _PLUGIN_FLAGS:
+                    continue
+
+                # Skip output/reporting options that would conflict
+                if any(arg.startswith(prefix) for prefix in _EXCLUDED_ARG_PREFIXES):
+                    continue
+                if arg in ("-x", "--exitfirst"):
+                    continue
+
+                # Skip test file paths and nodeids - we provide our own
+                if not arg.startswith("-") and ("::" in arg or arg.endswith(".py")):
+                    continue
+
+                forwarded_args.append(arg)
+
+            cmd.extend(forwarded_args)
+
+        # Pass rootdir to subprocess to ensure it uses the same project root
+        # (config.rootpath is available in pytest 7.0+, which is our minimum version)
+        if config.rootpath:
+            cmd.extend(["--rootdir", str(config.rootpath)])
+
+        # Add the test nodeids
+        cmd.extend(nodeids)
+
+        start_time = time.time()
+
+        # Determine the working directory for the subprocess
+        # Use rootpath if set, otherwise use invocation directory
+        # This ensures nodeids (which are relative to rootpath) can be resolved
+        subprocess_cwd = None
+        if config.rootpath:
+            subprocess_cwd = str(config.rootpath)
+        elif hasattr(config, "invocation_params") and hasattr(
+            config.invocation_params, "dir"
+        ):
+            subprocess_cwd = str(config.invocation_params.dir)
 
         try:
             proc = subprocess.run(
-                cmd, env=env, timeout=timeout, capture_output=False, check=False
+                cmd,
+                env=env,
+                timeout=group_timeout,
+                capture_output=False,
+                check=False,
+                cwd=subprocess_cwd,
             )
             returncode = proc.returncode
             timed_out = False
@@ -228,8 +325,10 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
             returncode = -1
             timed_out = True
 
+        execution_time = time.time() - start_time
+
         # Gather results from JSONL file
-        results: dict[str, dict[str, Any]] = {}
+        results: dict[str, dict[str, _TestRecord]] = {}
         report_file = Path(report_path)
         if report_file.exists():
             with report_file.open(encoding="utf-8") as f:
@@ -237,7 +336,7 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
                     file_line = line.strip()
                     if not file_line:
                         continue
-                    rec = json.loads(file_line)
+                    rec = cast(_TestRecord, json.loads(file_line))
                     nodeid = rec["nodeid"]
                     when = rec["when"]
 
@@ -250,9 +349,10 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
         # Handle timeout or crash
         if timed_out:
             msg = (
-                f"Subprocess group={group_name!r} timed out after {timeout} "
-                f"seconds. Increase timeout with --subprocess-timeout or "
-                f"subprocess_timeout ini option."
+                f"Subprocess group={group_name!r} timed out after {group_timeout} "
+                f"seconds (execution time: {execution_time:.2f}s). "
+                f"Increase timeout with --isolated-timeout, isolated_timeout ini, "
+                f"or @pytest.mark.isolated(timeout=N)."
             )
             for it in group_items:
                 emit_report(it, "call", "failed", longrepr=msg)
@@ -275,7 +375,7 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
             node_results = results.get(it.nodeid, {})
 
             # Emit setup, call, teardown in order
-            for when in ["setup", "call", "teardown"]:
+            for when in ["setup", "call", "teardown"]:  # type: ignore[assignment]
                 if when not in node_results:
                     # If missing a phase, synthesize a passing one
                     if when == "call" and not node_results:
@@ -292,7 +392,7 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
                 rec = node_results[when]
                 emit_report(
                     it,
-                    when=when,
+                    when=when,  # type: ignore[arg-type]
                     outcome=rec["outcome"],
                     longrepr=rec.get("longrepr", ""),
                     duration=rec.get("duration", 0.0),

{pytest_isolated-0.1.0.dist-info → pytest_isolated-0.3.0.dist-info}/METADATA

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: pytest-isolated
-Version: 0.1.0
+Version: 0.3.0
 Summary: Run marked pytest tests in grouped subprocesses (cross-platform).
 Author: pytest-isolated contributors
-License: MIT
+License-Expression: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -27,6 +26,9 @@ Dynamic: license-file
 
 # pytest-isolated
 
+[![Tests](https://github.com/dyollb/pytest-isolated/actions/workflows/test.yml/badge.svg)](https://github.com/dyollb/pytest-isolated/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/pytest-isolated.svg)](https://pypi.org/project/pytest-isolated/)
+
 A pytest plugin that runs marked tests in isolated subprocesses with intelligent grouping.
 
 ## Features
@@ -52,7 +54,7 @@ Mark tests to run in isolated subprocesses:
 ```python
 import pytest
 
-@pytest.mark.subprocess
+@pytest.mark.isolated
 def test_isolated():
     # Runs in a fresh subprocess
     assert True
@@ -61,16 +63,25 @@ def test_isolated():
 Tests with the same group run together in one subprocess:
 
 ```python
-@pytest.mark.subprocess(group="mygroup")
+@pytest.mark.isolated(group="mygroup")
 def test_one():
     shared_state.append(1)
 
-@pytest.mark.subprocess(group="mygroup")
+@pytest.mark.isolated(group="mygroup")
 def test_two():
     # Sees state from test_one
     assert len(shared_state) == 2
 ```
 
+Set timeout per test group:
+
+```python
+@pytest.mark.isolated(timeout=30)
+def test_with_timeout():
+    # This group gets 30 second timeout (overrides global setting)
+    expensive_operation()
+```
+
 Tests without an explicit group are automatically grouped by module.
 
 ## Configuration
@@ -78,30 +89,30 @@ Tests without an explicit group are automatically grouped by module.
 ### Command Line
 
 ```bash
-# Set subprocess timeout (seconds)
-pytest --subprocess-timeout=60
+# Set isolated test timeout (seconds)
+pytest --isolated-timeout=60
 
 # Disable subprocess isolation for debugging
-pytest --no-subprocess
+pytest --no-isolation
 
 # Combine with pytest debugger
-pytest --no-subprocess --pdb
+pytest --no-isolation --pdb
 ```
 
 ### pytest.ini / pyproject.toml
 
 ```ini
 [pytest]
-subprocess_timeout = 300
-subprocess_capture_passed = false
+isolated_timeout = 300
+isolated_capture_passed = false
 ```
 
 Or in `pyproject.toml`:
 
 ```toml
 [tool.pytest.ini_options]
-subprocess_timeout = "300"
-subprocess_capture_passed = false
+isolated_timeout = "300"
+isolated_capture_passed = false
 ```
 
 ## Use Cases
@@ -109,13 +120,13 @@ subprocess_capture_passed = false
 ### Testing Global State
 
 ```python
-@pytest.mark.subprocess
+@pytest.mark.isolated
 def test_modifies_environ():
     import os
     os.environ["MY_VAR"] = "value"
     # Won't affect other tests
 
-@pytest.mark.subprocess
+@pytest.mark.isolated
 def test_clean_environ():
     import os
     assert "MY_VAR" not in os.environ
@@ -124,13 +135,13 @@ def test_clean_environ():
 ### Testing Singletons
 
 ```python
-@pytest.mark.subprocess(group="singleton_tests")
+@pytest.mark.isolated(group="singleton_tests")
 def test_singleton_init():
     from myapp import DatabaseConnection
     db = DatabaseConnection.get_instance()
     assert db is not None
 
-@pytest.mark.subprocess(group="singleton_tests")
+@pytest.mark.isolated(group="singleton_tests")
 def test_singleton_reuse():
     db = DatabaseConnection.get_instance()
     # Same instance as previous test in group
@@ -139,7 +150,7 @@ def test_singleton_reuse():
 ### Testing Process Resources
 
 ```python
-@pytest.mark.subprocess
+@pytest.mark.isolated
 def test_signal_handlers():
     import signal
     signal.signal(signal.SIGTERM, custom_handler)
@@ -151,7 +162,7 @@ def test_signal_handlers():
 Failed tests automatically capture and display stdout/stderr:
 
 ```python
-@pytest.mark.subprocess
+@pytest.mark.isolated
 def test_failing():
     print("Debug info")
     assert False
@@ -167,7 +178,7 @@ pytest --junitxml=report.xml --durations=10
 
 **Fixtures**: Module/session fixtures run in each subprocess group. Cannot share fixture objects between parent and subprocess.
 
-**Debugging**: Use `--no-subprocess` to run all tests in the main process for easier debugging with `pdb` or IDE debuggers.
+**Debugging**: Use `--no-isolation` to run all tests in the main process for easier debugging with `pdb` or IDE debuggers.
 
 **Performance**: Subprocess creation adds ~100-500ms per group. Group related tests to minimize overhead.
 
@@ -176,7 +187,7 @@ pytest --junitxml=report.xml --durations=10
 ### Timeout Handling
 
 ```bash
-pytest --subprocess-timeout=30
+pytest --isolated-timeout=30
 ```
 
 Timeout errors are clearly reported with the group name and timeout duration.
@@ -197,24 +208,18 @@ if os.environ.get("PYTEST_RUNNING_IN_SUBPROCESS") == "1":
 
 ## Troubleshooting
 
-**Tests timing out**: Increase timeout with `--subprocess-timeout=600`
+**Tests timing out**: Increase timeout with `--isolated-timeout=600`
 
-**Missing output**: Enable capture for passed tests with `subprocess_capture_passed = true`
+**Missing output**: Enable capture for passed tests with `isolated_capture_passed = true`
 
 **Subprocess crashes**: Check for segfaults, OOM, or signal issues. Run with `-v` for details.
 
-## License
-
-MIT License - see LICENSE file for details.
+## Contributing
 
-## Changelog
+1. Install pre-commit: `pip install pre-commit && pre-commit install`
+1. Run tests: `pytest tests/ -v`
+1. Open an issue before submitting PRs for new features
 
-### 0.1.0 (2026-01-12)
+## License
 
-- Initial release
-- Process isolation with subprocess marker
-- Smart grouping by module or explicit group names
-- Timeout support
-- Complete test phase capture (setup/call/teardown)
-- JUnit XML and standard reporter integration
-- Comprehensive error handling and reporting
+MIT License - see LICENSE file for details.

pytest_isolated-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_isolated/__init__.py,sha256=b7RfFW9uJXumJ6DTDdg-VvSUEeh-Pc2srTjCKJRxB7k,89
+pytest_isolated/plugin.py,sha256=ISfxTMyJVaddrqCFZOdBXFnC4E_Lh22gRUaNRb1Wo8I,15179
+pytest_isolated/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_isolated-0.3.0.dist-info/licenses/LICENSE,sha256=WECJyowi685PZSnKcA4Tqs7jukfzbnk7iMPLnm_q4JI,1067
+pytest_isolated-0.3.0.dist-info/METADATA,sha256=CDzpvrFqvUFguTk9_Yr32h88GatvKDHCO0d7CsVC5Ug,5384
+pytest_isolated-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pytest_isolated-0.3.0.dist-info/entry_points.txt,sha256=HgRNPjIGoPBF1pkhma4UtaSwhpOVB8oZRZ0L1FcZXgk,45
+pytest_isolated-0.3.0.dist-info/top_level.txt,sha256=FAtpozhvI-YaiFoZMepi9JAm6e87mW-TM1Ovu5xLOxg,16
+pytest_isolated-0.3.0.dist-info/RECORD,,

{pytest_isolated-0.1.0.dist-info → pytest_isolated-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pytest_isolated-0.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-pytest_isolated/__init__.py,sha256=iqPlqv1sT1c10XcWOeYbJyRyIzeQk0Sa-OhOS14IMfg,89
-pytest_isolated/plugin.py,sha256=lLNjY5Jm5SmllySvVPRCF87fpQTnRx_RMtloKeM1m9U,11296
-pytest_isolated-0.1.0.dist-info/licenses/LICENSE,sha256=WECJyowi685PZSnKcA4Tqs7jukfzbnk7iMPLnm_q4JI,1067
-pytest_isolated-0.1.0.dist-info/METADATA,sha256=qfVoG6VGZCb-Dj5Wl12sGQH7WO-U2Gj4KcGV2H_FXzU,5131
-pytest_isolated-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_isolated-0.1.0.dist-info/entry_points.txt,sha256=HgRNPjIGoPBF1pkhma4UtaSwhpOVB8oZRZ0L1FcZXgk,45
-pytest_isolated-0.1.0.dist-info/top_level.txt,sha256=FAtpozhvI-YaiFoZMepi9JAm6e87mW-TM1Ovu5xLOxg,16
-pytest_isolated-0.1.0.dist-info/RECORD,,