expt-logger 0.1.0.dev19__tar.gz → 0.1.0.dev21__tar.gz

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: expt-logger
-Version: 0.1.0.dev19
+Version: 0.1.0.dev21
 Summary: Simple experiment logging library
 Requires-Python: >=3.10
 Requires-Dist: requests>=2.31.0

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "expt-logger"
-version = "0.1.0.dev19"
+version = "0.1.0.dev21"
 description = "Simple experiment logging library"
 readme = "README.md"
 requires-python = ">=3.10"

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/src/expt_logger/__init__.py

@@ -31,8 +31,7 @@ def init(
     When attaching to an existing experiment:
     - Validates the experiment exists (raises APIError if not found)
     - Sets experiment status to "active"
-    - Main process: Syncs provided config to server (if any)
-    - Subprocess (is_main_process=False): Config parameter is ignored to avoid conflicts
+    - Syncs provided config to server (if any)
 
     Args:
         name: Optional experiment name (used when creating new experiment)
@@ -113,6 +112,7 @@ def log_rollout(
     step: int | None = None,
     mode: str | None = None,
     commit: bool = True,
+    id: str | None = None,
 ) -> None:
     """Log a rollout (conversation + rewards).
 
@@ -152,9 +152,28 @@ def log_rollout(
         step=step,
         mode=mode,
         commit=commit,
+        id=id
     )
 
 
+def log_environment(
+    rollout_id: str,
+    content: str,
+) -> None:
+    """Log an environment log entry associated with a rollout.
+
+    Args:
+        rollout_id: ID of the rollout this log entry is associated with
+        content: Log content string
+
+    Raises:
+        RuntimeError: If no active run exists
+    """
+    if _active_run is None:
+        raise RuntimeError("No active run. Call init() first.")
+    _active_run.log_environment(rollout_id=rollout_id, content=content)
+
+
 def log_error(
     error: Exception | str,
     step: int | None = None,
@@ -298,6 +317,7 @@ __all__ = [
     "init",
     "log",
     "log_rollout",
+    "log_environment",
     "log_error",
     "commit",
     "end",

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/src/expt_logger/client.py

@@ -280,6 +280,47 @@ class APIClient:
             payload = {"rollouts": chunk}
             self._request("POST", url, json=payload)
 
+    def log_env_logs(
+        self,
+        experiment_id: str,
+        rollout_id: str,
+        content: str,
+    ) -> None:
+        """Log an environment log entry for an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+            rollout_id: Rollout ID this log entry is associated with
+            content: Log content string
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}/api/experiments/{experiment_id}/env-logs"
+        payload = {"rolloutId": rollout_id, "content": content}
+        self._request("POST", url, json=payload)
+
+    def get_env_logs(
+        self,
+        experiment_id: str,
+        rollout_id: str,
+    ) -> list[dict]:
+        """Fetch environment logs for a specific rollout.
+
+        Args:
+            experiment_id: Experiment ID
+            rollout_id: Rollout ID to filter logs by
+
+        Returns:
+            List of env log entries
+
+        Raises:
+            APIError: If request fails
+        """
+        url = f"{self.base_url}/api/experiments/{experiment_id}/env-logs"
+        response = self._request("GET", url, params={"rolloutId": rollout_id})
+        return response.json()["logs"]
+
     def log_errors(
         self,
         experiment_id: str,

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/src/expt_logger/run.py

@@ -23,6 +23,7 @@ from expt_logger.types import (
     ConfigUpdateCommand,
     ErrorItem,
     LogCommand,
+    LogEnvironmentCommand,
     LogErrorCommand,
     LogRolloutCommand,
     MessageItem,
@@ -81,8 +82,9 @@ class Run:
             resolved_experiment_id = get_experiment_id(experiment_id, is_main_process=False)
             if resolved_experiment_id is not None:
                 self._experiment_id = resolved_experiment_id
-                # Subprocesses should not update config to avoid conflicts
-                self._validate_and_attach_experiment(config=None)
+                # Do not set the config if already attached to an experiment to avoid
+                # overwriting existing settings
+                self._validate_and_attach_experiment()
                 logger.info(
                     f"[expt_logger] Attached to experiment ID: {self._experiment_id} (subprocess)"
                 )
@@ -229,6 +231,7 @@ class Run:
         step: int | None = None,
         mode: str | None = None,
         commit: bool = True,
+        id: str | None = None,
     ) -> None:
         """Log a rollout (conversation + rewards).
 
@@ -239,6 +242,7 @@ class Run:
             step: Optional step number (overrides worker's step counter if provided)
             mode: Optional mode (defaults to "train")
             commit: Whether to flush buffer after logging
+            id: Optional identifier for this rollout
         """
         from expt_logger.validation import (
             validate_messages,
@@ -274,6 +278,7 @@ class Run:
             "rewards": reward_items,
             "mode": mode or "train",
             "step": step,
+            "id": id,
         }
 
         try:
@@ -284,6 +289,28 @@ class Run:
         if commit:
             self.commit()
 
+    def log_environment(
+        self,
+        rollout_id: str,
+        content: str,
+    ) -> None:
+        """Log an environment log entry associated with a rollout.
+
+        Args:
+            rollout_id: ID of the rollout this log entry is associated with
+            content: Log content string
+        """
+        env_cmd: LogEnvironmentCommand = {
+            "rollout_id": rollout_id,
+            "content": content,
+        }
+        try:
+            self._queue.put_nowait(("log_environment", env_cmd))
+        except Full:
+            logger.warning(
+                f"Command queue full, dropping environment log for rollout: {rollout_id}"
+            )
+
     def log_error(
         self,
         error: Exception | str,
@@ -423,6 +450,8 @@ class Run:
                             self._handle_log(cast(LogCommand, data))
                         elif command == "log_rollout":
                             self._handle_log_rollout(cast(LogRolloutCommand, data))
+                        elif command == "log_environment":
+                            self._handle_log_environment(cast(LogEnvironmentCommand, data))
                         elif command == "log_error":
                             self._handle_log_error(cast(LogErrorCommand, data))
                         elif command == "commit":
@@ -533,9 +562,22 @@ class Run:
             "messages": data["messages"],
             "rewards": data["rewards"],
         }
+        if data["id"] is not None:
+            rollout["id"] = data["id"]
 
         self._buffer.add_rollout(rollout)
 
+    def _handle_log_environment(self, data: LogEnvironmentCommand) -> None:
+        """Handle log_environment command.
+
+        Args:
+            data: Log environment command data with rollout_id and content
+        """
+        try:
+            self._client.log_env_logs(self._experiment_id, data["rollout_id"], data["content"])
+        except Exception as e:
+            logger.error(f"Error logging environment log: {e}", exc_info=True)
+
     def _handle_log_error(self, data: LogErrorCommand) -> None:
         """Handle log_error command.
 

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/src/expt_logger/types.py

@@ -36,6 +36,7 @@ class RolloutItem(TypedDict):
     promptText: str
     messages: list[MessageItem]
     rewards: list[RewardItem]
+    id: NotRequired[str]
 
 
 class ErrorItem(TypedDict):
@@ -75,6 +76,7 @@ class LogRolloutCommand(TypedDict):
     rewards: list[RewardItem]
     mode: str
     step: int | None
+    id: str | None
 
 
 class LogErrorCommand(TypedDict):
@@ -87,6 +89,13 @@ class LogErrorCommand(TypedDict):
     step: int | None
 
 
+class LogEnvironmentCommand(TypedDict):
+    """Command to log an environment log entry."""
+
+    rollout_id: str
+    content: str
+
+
 class CommitCommand(TypedDict):
     """Command to commit (flush) the buffer."""
 

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/tests/test_client.py

@@ -294,6 +294,18 @@ def test_log_rollouts(client):
         assert call_args[1]["json"] == {"rollouts": rollouts}
 
 
+def test_log_env_logs(client):
+    """Test logging environment logs."""
+    with patch.object(client, "_request") as mock_request:
+        client.log_env_logs("exp-123", "rollout-456", "step 1 observation")
+
+        mock_request.assert_called_once()
+        call_args = mock_request.call_args
+        assert call_args[0][0] == "POST"
+        assert call_args[0][1] == "https://test.example.com/api/experiments/exp-123/env-logs"
+        assert call_args[1]["json"] == {"rolloutId": "rollout-456", "content": "step 1 observation"}
+
+
 def test_log_errors(client):
     """Test logging errors."""
     with patch.object(client, "_request") as mock_request:

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/tests/test_global_api.py

@@ -134,6 +134,28 @@ def test_log_rollout_raises_if_no_active_run(mock_run):
     assert "No active run" in str(exc_info.value)
 
 
+def test_log_environment_delegates_to_run(mock_run):
+    """Test log_environment() delegates to the active run."""
+    _, run_instance = mock_run
+
+    expt_logger.init()
+    expt_logger.log_environment(rollout_id="rollout-abc", content="step 1 observation")
+
+    run_instance.log_environment.assert_called_once_with(
+        rollout_id="rollout-abc",
+        content="step 1 observation",
+    )
+
+
+def test_log_environment_raises_if_no_active_run():
+    """Test log_environment() raises RuntimeError if no active run."""
+    with pytest.raises(RuntimeError) as exc_info:
+        expt_logger.log_environment("rollout-abc", "some content")
+
+    assert "No active run" in str(exc_info.value)
+    assert "init()" in str(exc_info.value)
+
+
 def test_log_error_delegates_to_run(mock_run):
     """Test log_error() delegates to the active run."""
     _, run_instance = mock_run
@@ -393,6 +415,7 @@ def test_all_exports():
         "init",
         "log",
         "log_rollout",
+        "log_environment",
         "log_error",
         "commit",
         "end",

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/tests/test_integration_e2e.py

@@ -112,6 +112,22 @@ def fetch_rollouts(shared_api_key: str, base_url: str):
     return _fetch
 
 
+@pytest.fixture
+def fetch_env_logs(shared_api_key: str, base_url: str):
+    """Factory fixture for fetching environment log data."""
+
+    def _fetch(experiment_id: str, rollout_id: str):
+        response = requests.get(
+            f"{base_url}/api/experiments/{experiment_id}/env-logs",
+            params={"rolloutId": rollout_id},
+            headers={"Authorization": f"Bearer {shared_api_key}"},
+        )
+        assert response.status_code == 200
+        return response.json()["logs"]
+
+    return _fetch
+
+
 # ============================================================================
 # Test Class 1: Basic Workflow Tests
 # ============================================================================
@@ -1054,3 +1070,117 @@ class TestMultiProcess:
         # Worker metrics
         for i in range(num_workers):
             assert f"worker-{i + 1}-metric" in scalars
+
+
+# ============================================================================
+# Test Class 12: Environment Log Tests
+# ============================================================================
+
+
+@pytest.mark.integration
+class TestEnvironmentLogs:
+    """Environment log functionality."""
+
+    def test_log_environment_basic(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test basic environment log persists to server."""
+        run = expt_logger.init(
+            name="test-env-log-basic",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000001", "observation: step=1, reward=0.9")
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000001")
+        assert len(env_logs) == 1
+        assert env_logs[0]["content"] == "observation: step=1, reward=0.9"
+
+        expt_logger.end()
+
+    def test_log_environment_multiple_for_same_rollout(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test multiple environment logs for the same rollout are all stored."""
+        run = expt_logger.init(
+            name="test-env-log-multiple",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 1: action=left")
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 2: action=right")
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000002", "step 3: action=jump")
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000002")
+        assert len(env_logs) == 3
+        contents = {log["content"] for log in env_logs}
+        assert contents == {"step 1: action=left", "step 2: action=right", "step 3: action=jump"}
+
+        expt_logger.end()
+
+    def test_log_environment_different_rollouts(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test environment logs for different rollouts stay separate."""
+        run = expt_logger.init(
+            name="test-env-log-separate",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        expt_logger.log_environment("00000000-0000-0000-0000-00000000003a", "log for rollout A")
+        expt_logger.log_environment("00000000-0000-0000-0000-00000000003b", "log for rollout B")
+        time.sleep(0.5)
+
+        logs_a = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-00000000003a")
+        logs_b = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-00000000003b")
+        assert len(logs_a) == 1
+        assert logs_a[0]["content"] == "log for rollout A"
+        assert len(logs_b) == 1
+        assert logs_b[0]["content"] == "log for rollout B"
+
+        expt_logger.end()
+
+    def test_log_environment_multiline_content(
+        self,
+        shared_api_key: str,
+        base_url: str,
+        cleanup_experiments: list[str],
+        fetch_env_logs,
+    ) -> None:
+        """Test environment log with multiline content."""
+        run = expt_logger.init(
+            name="test-env-log-multiline",
+            api_key=shared_api_key,
+            base_url=base_url,
+        )
+        cleanup_experiments.append(run._experiment_id)
+
+        content = "obs: {x: 1.0, y: 2.0}\nreward: 0.5\ndone: false\ninfo: {step: 10}"
+        expt_logger.log_environment("00000000-0000-0000-0000-000000000004", content)
+        time.sleep(0.5)
+
+        env_logs = fetch_env_logs(run._experiment_id, "00000000-0000-0000-0000-000000000004")
+        assert len(env_logs) == 1
+        assert env_logs[0]["content"] == content
+
+        expt_logger.end()

{expt_logger-0.1.0.dev19 → expt_logger-0.1.0.dev21}/tests/test_run.py

@@ -1482,49 +1482,86 @@ def test_log_error_with_invalid_mode_empty(mock_client):
     run.end()
 
 
-def test_subprocess_does_not_update_config(mock_client):
-    """Test subprocess (is_main_process=False) does not update config even if provided."""
-    import os
-    import tempfile
+# ========== log_environment Tests ==========
 
+
+def test_log_environment_calls_client(mock_client):
+    """Test log_environment() calls client with correct args."""
     _, client_instance = mock_client
 
-    # Write experiment ID to temp file
-    temp_dir = tempfile.gettempdir()
-    experiment_id_file = os.path.join(temp_dir, "expt-logger-experiment-id.txt")
-    with open(experiment_id_file, "w") as f:
-        f.write("existing-exp-123")
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
 
-    try:
-        # Subprocess tries to init with a config
-        run = Run(
-            config={"subprocess_key": "should_be_ignored"},
-            api_key="test-key",
-            base_url="https://test.example.com",
-            is_main_process=False,
-        )
+    run.log_environment("rollout-abc", "step 1 observation")
 
-        # Should NOT create a new experiment
-        assert not client_instance.create_experiment.called
+    # Give worker time to process
+    time.sleep(0.1)
 
-        # Should call update_experiment to set status to active
-        assert client_instance.update_experiment.called
+    assert client_instance.log_env_logs.called
+    call_args = client_instance.log_env_logs.call_args
+    assert call_args[0][0] == "test-exp-id"
+    assert call_args[0][1] == "rollout-abc"
+    assert call_args[0][2] == "step 1 observation"
 
-        # Check that config was NOT included in the update call
-        update_calls = client_instance.update_experiment.call_args_list
-        # Find the call that sets status to active (during attach)
-        attach_call = None
-        for call in update_calls:
-            if call.kwargs.get("status") == "active":
-                attach_call = call
-                break
+    run.end()
 
-        assert attach_call is not None, "Should have called update_experiment with status='active'"
-        # Verify config was NOT passed (should be None)
-        assert attach_call.kwargs.get("config") is None
 
-        run.end()
-    finally:
-        # Cleanup
-        if os.path.isfile(experiment_id_file):
-            os.remove(experiment_id_file)
+def test_log_environment_multiple_calls(mock_client):
+    """Test log_environment() can be called multiple times for different rollouts."""
+    _, client_instance = mock_client
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+
+    run.log_environment("rollout-1", "log content 1")
+    run.log_environment("rollout-2", "log content 2")
+
+    # Give worker time to process
+    time.sleep(0.1)
+
+    assert client_instance.log_env_logs.call_count == 2
+    first_call = client_instance.log_env_logs.call_args_list[0]
+    second_call = client_instance.log_env_logs.call_args_list[1]
+    assert first_call[0][1] == "rollout-1"
+    assert first_call[0][2] == "log content 1"
+    assert second_call[0][1] == "rollout-2"
+    assert second_call[0][2] == "log content 2"
+
+    run.end()
+
+
+def test_log_environment_queue_full_handling(mock_client):
+    """Test that queue full is handled gracefully for environment logs."""
+    _, _ = mock_client
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+    run._queue = queue.Queue(maxsize=1)
+
+    with patch("expt_logger.run.logger") as mock_logger:
+        run.log_environment("rollout-1", "log 1")
+        run.log_environment("rollout-2", "log 2")  # Should trigger queue full
+
+        assert mock_logger.warning.called
+        warning_msg = mock_logger.warning.call_args[0][0]
+        assert "queue full" in warning_msg.lower()
+
+    run.end()
+
+
+def test_log_environment_api_error_is_logged(mock_client):
+    """Test that API errors from log_environment are caught and logged, not raised."""
+    _, client_instance = mock_client
+
+    client_instance.log_env_logs.side_effect = APIError("Server error")
+
+    run = Run(name="test-run", api_key="test-key", base_url="https://test.example.com")
+
+    with patch("expt_logger.run.logger") as mock_logger:
+        run.log_environment("rollout-abc", "some content")
+
+        # Give worker time to process and handle error
+        time.sleep(0.2)
+
+        assert run._worker_thread is not None
+        assert run._worker_thread.is_alive()
+        assert mock_logger.error.called
+
+    run.end()

expt_logger-0.1.0.dev19/.claude/settings.local.json

@@ -1,30 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(uv run mypy:*)",
-      "Bash(uv run pytest:*)",
-      "Bash(python -m pytest:*)",
-      "Bash(python example_config_validation.py:*)",
-      "Bash(uv run python:*)",
-      "Bash(ls:*)",
-      "Bash(curl:*)",
-      "Bash(cat:*)",
-      "Bash(EXPT_LOGGER_LOG_LEVEL=DEBUG uv run pytest:*)",
-      "Bash(EXPT_LOGGER_API_KEY=test EXPT_LOGGER_BASE_URL=http://localhost:3000 uv run python:*)",
-      "Bash(EXPT_LOGGER_API_KEY=test uv run python:*)",
-      "Bash(uv sync:*)",
-      "Bash(python -m json.tool:*)",
-      "Bash(uv run ruff:*)",
-      "Bash(find:*)",
-      "Bash(uv add:*)",
-      "Bash(python:*)",
-      "Bash(EXPT_LOGGER_LOG_LEVEL=DEBUG uv run python:*)",
-      "Bash(uv run:*)",
-      "Bash(git restore:*)",
-      "Bash(git checkout:*)",
-      "Bash(git rebase:*)",
-      "Bash(git add:*)",
-      "Bash(pip install:*)"
-    ]
-  }
-}