bounded_subprocess 2.4.0__tar.gz → 2.6.0__tar.gz

bounded_subprocess-2.6.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python -m pytest:*)",
+      "Bash(uv run pytest:*)"
+    ]
+  }
+}

bounded_subprocess-2.6.0/AGENTS.md

@@ -0,0 +1,10 @@
+Use `uv run`to run and not `python`.
+
+## Publishing Process
+
+Increment the version number as appropriate in pyproject.toml. Delete old
+builds from dist/. Run uv sync to update the lock file. Commit the changes,
+which should have just changes to pyproject.taml and uv.lock. Run `uv build`
+and then `uv publish`. In the interactive prompt, you MUST enter __token__
+for the username. I know it says that, but I don't read what's on the screen.
+The password is in the keychain.

{bounded_subprocess-2.4.0 → bounded_subprocess-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bounded_subprocess
-Version: 2.4.0
+Version: 2.6.0
 Summary: A library to facilitate running subprocesses that may misbehave.
 Project-URL: Homepage, https://github.com/arjunguha/bounded_subprocess
 Project-URL: Bug Tracker, https://github.com/arjunguha/bounded_subprocess

{bounded_subprocess-2.4.0 → bounded_subprocess-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bounded_subprocess"
-version = "2.4.0"
+version = "2.6.0"
 authors = [
   { name="Arjun Guha" },
   { name="Ming-Ho Yee" },

{bounded_subprocess-2.4.0 → bounded_subprocess-2.6.0}/src/bounded_subprocess/bounded_subprocess_async.py

@@ -163,6 +163,9 @@ async def podman_run(
     env=None,
     stdin_data: Optional[str] = None,
     stdin_write_timeout: Optional[int] = None,
+    volumes: List[str] = [],
+    cwd: Optional[str] = None,
+    memory_limit_mb: Optional[int] = None,
 ) -> Result:
     """
     Run a subprocess in a podman container asynchronously with bounded stdout/stderr capture.
@@ -172,19 +175,33 @@ async def podman_run(
     the same as `run`, except for an additional `image` parameter to specify the
     container image to use.
 
+    Args:
+        args: Command arguments to run in the container.
+        image: Container image to use.
+        timeout_seconds: Maximum time to wait for the process to complete.
+        max_output_size: Maximum size in bytes for stdout/stderr capture.
+        env: Optional dictionary of environment variables.
+        stdin_data: Optional string data to write to stdin.
+        stdin_write_timeout: Optional timeout for writing stdin data.
+        volumes: Optional list of volume mount specifications (e.g., ["/host/path:/container/path"]).
+        cwd: Optional working directory path inside the container.
+        memory_limit_mb: Optional memory limit in megabytes for the container.
+
     Example:
 
     ```python
     import asyncio
-    from bounded_subprocess.bounded_subprocess_async import run_container
+    from bounded_subprocess.bounded_subprocess_async import podman_run
 
     async def main():
-        result = await run_container(
+        result = await podman_run(
             ["cat"],
             image="alpine:latest",
             timeout_seconds=5,
             max_output_size=1024,
             stdin_data="hello\n",
+            volumes=["/host/data:/container/data"],
+            cwd="/container/data",
         )
         print(result.exit_code)
         print(result.stdout.strip())
@@ -209,6 +226,18 @@ async def podman_run(
         for key, value in env.items():
             podman_args.extend(["-e", f"{key}={value}"])
 
+    # Handle volume mounts
+    for volume in volumes:
+        podman_args.extend(["-v", volume])
+
+    # Handle memory limit
+    if memory_limit_mb is not None:
+        podman_args.extend(["--memory", f"{memory_limit_mb}m", "--memory-swap", f"{memory_limit_mb}m"])
+
+    # Handle working directory
+    if cwd is not None:
+        podman_args.extend(["-w", cwd])
+
     podman_args.append(image)
     podman_args.extend(args)
 

{bounded_subprocess-2.4.0 → bounded_subprocess-2.6.0}/test/test_async.py

@@ -171,3 +171,77 @@ async def test_podman_run_unbounded_output():
     assert result.timeout is True
     # stderr may contain podman pull messages, which is fine
     assert len(result.stdout) == 1024
+
+
+@pytest.mark.asyncio
+async def test_podman_run_volumes():
+    """Test podman_run with volume mounts."""
+    import tempfile
+    
+    # Create a temporary file with test content
+    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as tmp_file:
+        tmp_file.write("test content\n")
+        tmp_path = tmp_file.name
+    
+    try:
+        # Mount the file and read it from the container
+        result = await podman_run(
+            ["cat", "/mnt/test.txt"],
+            image="alpine:latest",
+            timeout_seconds=5,
+            max_output_size=1024,
+            volumes=[f"{tmp_path}:/mnt/test.txt:ro"],
+        )
+        assert result.exit_code == 0
+        assert result.timeout is False
+        assert result.stdout == "test content\n"
+    finally:
+        # Clean up
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+
+
+@pytest.mark.asyncio
+async def test_podman_run_cwd():
+    """Test podman_run with working directory."""
+    result = await podman_run(
+        ["pwd"],
+        image="alpine:latest",
+        timeout_seconds=5,
+        max_output_size=1024,
+        cwd="/tmp",
+    )
+    assert result.exit_code == 0
+    assert result.timeout is False
+    assert result.stdout.strip() == "/tmp"
+
+
+@pytest.mark.asyncio
+async def test_podman_run_memory_limit_ok():
+    """Test podman_run with memory limit that is sufficient."""
+    result = await podman_run(
+        ["echo", "hello"],
+        image="alpine:latest",
+        timeout_seconds=10,
+        max_output_size=1024,
+        memory_limit_mb=64,
+    )
+    assert result.exit_code == 0
+    assert result.timeout is False
+    assert result.stdout.strip() == "hello"
+
+
+@pytest.mark.asyncio
+async def test_podman_run_memory_limit_oom():
+    """Test podman_run where the process exceeds the memory limit."""
+    # Allocate ~128MB in a container limited to 32MB
+    result = await podman_run(
+        ["python3", "-c", "x = bytearray(128 * 1024 * 1024)"],
+        image="python:3.12-alpine",
+        timeout_seconds=30,
+        max_output_size=4096,
+        memory_limit_mb=32,
+    )
+    assert result.exit_code != 0

{bounded_subprocess-2.4.0 → bounded_subprocess-2.6.0}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.9"
 resolution-markers = [
     "python_full_version >= '3.10'",
@@ -31,7 +31,7 @@ wheels = [
 
 [[package]]
 name = "bounded-subprocess"
-version = "2.4.0"
+version = "2.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "typeguard" },

bounded_subprocess-2.4.0/.git

@@ -1 +0,0 @@
-gitdir: /media/external0/arjun-nosudo/repos/arjunguha/bounded_subprocess/bare/worktrees/main

bounded_subprocess-2.4.0/AGENTS.md

@@ -1,5 +0,0 @@
-## Publishing Process
-
-Increment the version number as appropriate in pyproject.toml. Delete old
-builds from dist/. Run uv sync to update the lock file. Commit the changes,
-which should have just changes to pyproject.taml and uv.lock.