Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+venv/bin/python filter=lfs diff=lfs merge=lfs -text
+venv/bin/python3 filter=lfs diff=lfs merge=lfs -text
+venv/bin/python3.12 filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64-arm.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text

CLAUDE.md

@@ -0,0 +1,549 @@
+# CLAUDE.md — CI/CD Doctor (Pipeline Debugging RL Environment)
+
+## What This Project Is
+
+An **OpenEnv reinforcement learning environment** for an AI competition.
+The agent plays the role of a DevOps engineer debugging a broken CI/CD pipeline.
+It issues free-form shell-like commands, reads logs, edits files, and re-runs
+pipeline stages until the pipeline passes.
+
+This is NOT a game. It simulates real DevOps work.
+
+---
+
+## Current Goal: Complete Phase 1
+
+**Phase 1 = Core environment, easy task only, no server yet.**
+
+Deliverable: a working Python module where you can call `reset()`, then `step()`,
+then `state()` in a loop and the environment responds correctly.
+
+---
+
+## Project Structure (target layout)
+
+```
+cicd-doctor/
+├── cicd_doctor/
+│   ├── __init__.py
+│   ├── models.py          ← Pydantic data models
+│   ├── generator.py       ← procedural scenario generator
+│   ├── stage_runner.py    ← simulated pipeline stages
+│   ├── parser.py          ← free-form command parser
+│   └── environment.py     ← core RL environment class
+└── tests/
+    └── test_phase1.py     ← smoke test for the loop
+```
+
+---
+
+## Architecture Mental Model
+
+```
+Agent issues a command string
+        │
+        ▼
+   parser.py          ← parses "cat requirements.txt" → structured ParsedCommand
+        │
+        ▼
+   environment.py     ← looks up command type, mutates in-memory filesystem
+        │
+        ├──► stage_runner.py   ← called on "pipeline run" or "pipeline logs"
+        │                         returns fake-but-realistic logs + exit_code
+        │
+        └──► returns PipelineObservation to caller
+```
+
+The "filesystem" is just a Python dict in memory:
+```python
+filesystem = {
+    "requirements.txt": "flask\nnumpy\n",
+    "pipeline.yaml": "stages:\n  - install\n",
+    "logs/install.log": ""
+}
+```
+No real files. No real pip. No real Docker. Pure deterministic simulation.
+
+---
+
+## File-by-File Specification
+
+### `models.py`
+
+Three Pydantic models. Keep them minimal for Phase 1.
+
+```python
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+
+class PipelineAction(BaseModel):
+    command: str                    # raw string the agent types, e.g. "cat requirements.txt"
+
+class PipelineObservation(BaseModel):
+    stdout: str                     # what the agent sees (file contents, logs, error msg)
+    exit_code: int                  # 0 = success, 1 = error
+    pipeline_status: str            # "not_run" | "running" | "passed" | "failed"
+    steps_remaining: int
+    done: bool = False
+    reward: float = 0.0
+
+class PipelineState(BaseModel):
+    episode_id: str
+    task: str                       # "easy" | "medium" | "hard"
+    filesystem: Dict[str, str]      # in-memory files
+    pipeline_status: str
+    step_count: int
+    done: bool
+    total_reward: float
+    answer_key: Dict[str, Any]      # never sent to agent, used by grader
+```
+
+---
+
+### `generator.py`
+
+Generates the broken scenario the agent must fix.
+
+**Easy scenario (Phase 1 only):**
+One random package is missing from `requirements.txt`.
+
+```python
+import random
+
+REQUIRED_PACKAGES = ["flask", "numpy", "pandas", "requests", "pydantic"]
+
+def generate_easy_scenario(seed: int) -> dict:
+    """
+    Returns a filesystem dict + answer_key.
+    The filesystem has requirements.txt missing one required package.
+    The answer_key records which package is missing (used by grader).
+    """
+    rng = random.Random(seed)
+    all_packages = REQUIRED_PACKAGES.copy()
+    missing = rng.choice(all_packages)
+    present = [p for p in all_packages if p != missing]
+    
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(present) + "\n",
+            "pipeline.yaml": "stages:\n  - install\n",
+            "logs/install.log": "",
+            "app.py": "import flask\nimport numpy\n# app code here\n"
+        },
+        "answer_key": {
+            "missing_package": missing,
+            "correct_file": "requirements.txt"
+        }
+    }
+```
+
+---
+
+### `stage_runner.py`
+
+Simulates running a pipeline stage. Returns realistic logs + exit code.
+No real pip runs. This is pure logic.
+
+```python
+def run_install_stage(filesystem: dict) -> dict:
+    """
+    Reads requirements.txt from the filesystem dict.
+    If all required packages are present → exit 0, success logs.
+    If any required package is missing → exit 1, ModuleNotFoundError logs.
+    Returns: {"exit_code": int, "logs": str}
+    """
+    REQUIRED = {"flask", "numpy", "pandas", "requests", "pydantic"}
+    content = filesystem.get("requirements.txt", "")
+    installed = {line.strip().lower() for line in content.splitlines() if line.strip()}
+    missing = REQUIRED - installed
+    
+    if not missing:
+        logs = "Collecting flask\n  Downloading flask-3.0.0-py3-none-any.whl\n"
+        logs += "Collecting numpy\n  Downloading numpy-1.26.0-cp311-cp311-linux_x86_64.whl\n"
+        logs += "Successfully installed flask numpy pandas requests pydantic\n"
+        return {"exit_code": 0, "logs": logs}
+    else:
+        pkg = next(iter(missing))
+        logs = f"Collecting {pkg}\n"
+        logs += f"  ERROR: Could not find a version that satisfies the requirement {pkg}\n"
+        logs += f"ERROR: No matching distribution found for {pkg}\n"
+        return {"exit_code": 1, "logs": logs}
+```
+
+---
+
+### `parser.py`
+
+Converts the agent's raw command string into a structured dict.
+Phase 1 must handle these commands:
+
+| Command | Example | What it does |
+|---|---|---|
+| `cat` | `cat requirements.txt` | Read a file |
+| `echo >>` | `echo "numpy" >> requirements.txt` | Append a line to a file |
+| `sed` | `sed -i 's/old/new/' requirements.txt` | Find-replace in a file |
+| `pipeline run` | `pipeline run` | Triggers stage_runner |
+| `pipeline logs` | `pipeline logs install` | Show logs for a stage |
+| `pipeline status` | `pipeline status` | Show current pass/fail status |
+
+```python
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class ParsedCommand:
+    type: str            # "cat" | "echo_append" | "sed" | "pipeline_run" | "pipeline_logs" | "pipeline_status" | "unknown"
+    filename: Optional[str] = None
+    content: Optional[str] = None    # for echo >>
+    pattern: Optional[str] = None    # for sed: old value
+    replacement: Optional[str] = None  # for sed: new value
+    stage: Optional[str] = None      # for pipeline logs: which stage
+
+def parse_command(command: str) -> ParsedCommand:
+    command = command.strip()
+    
+    # cat <filename>
+    if command.startswith("cat "):
+        return ParsedCommand(type="cat", filename=command[4:].strip())
+    
+    # echo "text" >> filename
+    m = re.match(r'echo\s+"([^"]+)"\s*>>\s*(\S+)', command)
+    if m:
+        return ParsedCommand(type="echo_append", content=m.group(1), filename=m.group(2))
+    
+    # sed -i 's/old/new/' filename
+    m = re.match(r"sed\s+-i\s+'s/([^/]+)/([^/]*)/'[\s]+(\S+)", command)
+    if m:
+        return ParsedCommand(type="sed", pattern=m.group(1), replacement=m.group(2), filename=m.group(3))
+    
+    # pipeline run
+    if command == "pipeline run":
+        return ParsedCommand(type="pipeline_run")
+    
+    # pipeline logs <stage>
+    m = re.match(r"pipeline logs\s+(\S+)", command)
+    if m:
+        return ParsedCommand(type="pipeline_logs", stage=m.group(1))
+    
+    # pipeline status
+    if command == "pipeline status":
+        return ParsedCommand(type="pipeline_status")
+    
+    return ParsedCommand(type="unknown")
+```
+
+---
+
+### `environment.py`
+
+The core class. Ties everything together.
+
+```python
+import uuid
+from cicd_doctor.models import PipelineAction, PipelineObservation, PipelineState
+from cicd_doctor.generator import generate_easy_scenario
+from cicd_doctor.stage_runner import run_install_stage
+from cicd_doctor.parser import parse_command
+
+MAX_STEPS = 15
+
+class PipelineEnvironment:
+
+    def reset(self, task: str = "easy", seed: int = 42) -> PipelineObservation:
+        scenario = generate_easy_scenario(seed)
+        self._filesystem = scenario["filesystem"]
+        self._answer_key = scenario["answer_key"]
+        self._task = task
+        self._step_count = 0
+        self._done = False
+        self._total_reward = 0.0
+        self._pipeline_status = "not_run"
+        self._episode_id = str(uuid.uuid4())
+        self._last_logs = {}  # stage_name → log string
+
+        return PipelineObservation(
+            stdout="Pipeline environment ready. The install stage is failing. Investigate and fix it.",
+            exit_code=0,
+            pipeline_status=self._pipeline_status,
+            steps_remaining=MAX_STEPS,
+            done=False,
+            reward=0.0
+        )
+
+    def step(self, action: PipelineAction) -> PipelineObservation:
+        if self._done:
+            raise RuntimeError("Episode is done. Call reset() first.")
+        
+        self._step_count += 1
+        steps_remaining = MAX_STEPS - self._step_count
+        cmd = parse_command(action.command)
+        stdout = ""
+        exit_code = 0
+
+        if cmd.type == "cat":
+            content = self._filesystem.get(cmd.filename)
+            if content is None:
+                stdout = f"cat: {cmd.filename}: No such file or directory"
+                exit_code = 1
+            else:
+                stdout = content
+
+        elif cmd.type == "echo_append":
+            if cmd.filename in self._filesystem:
+                self._filesystem[cmd.filename] += cmd.content + "\n"
+                stdout = ""  # echo >> is silent on success
+            else:
+                stdout = f"bash: {cmd.filename}: No such file or directory"
+                exit_code = 1
+
+        elif cmd.type == "sed":
+            if cmd.filename in self._filesystem:
+                self._filesystem[cmd.filename] = self._filesystem[cmd.filename].replace(
+                    cmd.pattern, cmd.replacement
+                )
+                stdout = ""
+            else:
+                stdout = f"sed: {cmd.filename}: No such file or directory"
+                exit_code = 1
+
+        elif cmd.type == "pipeline_run":
+            result = run_install_stage(self._filesystem)
+            self._last_logs["install"] = result["logs"]
+            if result["exit_code"] == 0:
+                self._pipeline_status = "passed"
+            else:
+                self._pipeline_status = "failed"
+            stdout = result["logs"]
+            exit_code = result["exit_code"]
+
+        elif cmd.type == "pipeline_logs":
+            stage = cmd.stage or "install"
+            stdout = self._last_logs.get(stage, f"No logs for stage '{stage}' yet. Run pipeline first.")
+
+        elif cmd.type == "pipeline_status":
+            stdout = f"Pipeline status: {self._pipeline_status}"
+
+        else:
+            stdout = f"Command not recognized: {action.command}"
+            exit_code = 1
+
+        # Grade and check done
+        reward, done = self._grade()
+        self._total_reward += reward
+        if done or steps_remaining <= 0:
+            self._done = True
+
+        return PipelineObservation(
+            stdout=stdout,
+            exit_code=exit_code,
+            pipeline_status=self._pipeline_status,
+            steps_remaining=max(0, steps_remaining),
+            done=self._done,
+            reward=reward
+        )
+
+    def state(self) -> PipelineState:
+        return PipelineState(
+            episode_id=self._episode_id,
+            task=self._task,
+            filesystem=dict(self._filesystem),
+            pipeline_status=self._pipeline_status,
+            step_count=self._step_count,
+            done=self._done,
+            total_reward=self._total_reward,
+            answer_key=self._answer_key  # grader-only, not sent to agent in real server
+        )
+
+    def _grade(self) -> tuple[float, bool]:
+        """
+        Easy task grader:
+        - +1.0 if pipeline_status == "passed"              → episode ends
+        - +0.5 partial credit if correct file was edited   → does NOT end episode
+        Returns (reward_this_step, done)
+        """
+        if self._pipeline_status == "passed":
+            return 1.0, True
+        
+        # Partial credit: did the agent add the missing package to the right file?
+        missing = self._answer_key["missing_package"]
+        correct_file = self._answer_key["correct_file"]
+        file_content = self._filesystem.get(correct_file, "")
+        if missing in file_content:
+            return 0.5, False  # right edit, hasn't re-run pipeline yet        
+        return 0.0, False  # no progress yet
+```
+
+---
+
+## Phase 1 — Step-by-Step Build Order for Claude Code
+
+Work through these **in order**. Each step depends on the one before it.
+
+### Step 1 — Scaffold the package
+
+```
+cicd-doctor/
+├── cicd_doctor/
+│   ├── __init__.py       ← empty file
+│   ├── models.py
+│   ├── generator.py
+│   ├── stage_runner.py
+│   ├── parser.py
+│   └── environment.py
+└── tests/
+    └── test_phase1.py
+```
+
+Create all empty files first, then fill them in order.
+
+---
+
+### Step 2 — Write `models.py`
+
+Three Pydantic v2 models: `PipelineAction`, `PipelineObservation`, `PipelineState`.
+See spec above. No logic here — just data shapes.
+
+Verify: `from cicd_doctor.models import PipelineAction` imports without error.
+
+---
+
+### Step 3 — Write `generator.py`
+
+One function: `generate_easy_scenario(seed: int) -> dict`
+
+Returns `{"filesystem": {...}, "answer_key": {...}}`.
+
+The filesystem always has: `requirements.txt`, `pipeline.yaml`, `logs/install.log`, `app.py`.
+One random package from the REQUIRED set is always missing from `requirements.txt`.
+
+Verify: calling it twice with the same seed returns the same missing package.
+
+---
+
+### Step 4 — Write `stage_runner.py`
+
+One function: `run_install_stage(filesystem: dict) -> dict`
+
+Returns `{"exit_code": int, "logs": str}`.
+
+Logic: parse `requirements.txt` lines → check against REQUIRED set → if any missing, exit 1
+with realistic pip error logs. If all present, exit 0 with realistic success logs.
+
+Verify:
+- Pass a filesystem with all packages → `exit_code == 0`
+- Pass a filesystem missing "numpy" → `exit_code == 1`, logs mention "numpy"
+
+---
+
+### Step 5 — Write `parser.py`
+
+One function: `parse_command(command: str) -> ParsedCommand`
+
+Must handle exactly these 6 patterns:
+1. `cat <filename>`
+2. `echo "text" >> <filename>`
+3. `sed -i 's/old/new/' <filename>`
+4. `pipeline run`
+5. `pipeline logs <stage>`
+6. `pipeline status`
+
+Anything else → `ParsedCommand(type="unknown")`
+
+Verify: write 6 assert statements, one per command type.
+
+---
+
+### Step 6 — Write `environment.py`
+
+Class `PipelineEnvironment` with three public methods:
+
+- `reset(task="easy", seed=42) -> PipelineObservation`
+- `step(action: PipelineAction) -> PipelineObservation`
+- `state() -> PipelineState`
+
+Internal state lives on `self`. The filesystem is `self._filesystem` (a plain dict).
+
+`step()` flow:
+1. Parse the command string via `parser.py`
+2. Dispatch to the right handler (cat / echo / sed / pipeline_run / etc.)
+3. Mutate `self._filesystem` if needed
+4. Call `self._grade()` to check if done
+5. Return a `PipelineObservation`
+
+`_grade()` logic:
+- `pipeline_status == "passed"` → reward 1.0, done=True
+- Missing package is present in correct file but pipeline not re-run yet → reward 0.5, done=False
+- Otherwise → reward 0.0, done=False
+
+---
+
+### Step 7 — Write the smoke test
+
+File: `tests/test_phase1.py`
+
+```python
+from cicd_doctor.environment import PipelineEnvironment
+from cicd_doctor.models import PipelineAction
+
+def test_full_easy_episode():
+    env = PipelineEnvironment()
+    
+    # Reset
+    obs = env.reset(task="easy", seed=42)
+    assert obs.done == False
+    assert obs.pipeline_status == "not_run"
+    
+    # Find out which package is missing
+    state = env.state()
+    missing = state.answer_key["missing_package"]
+    
+    # Step 1: cat the requirements file
+    obs = env.step(PipelineAction(command="cat requirements.txt"))
+    assert missing not in obs.stdout   # confirms it's missing
+    
+    # Step 2: add the missing package
+    obs = env.step(PipelineAction(command=f'echo "{missing}" >> requirements.txt'))
+    assert obs.reward == 0.5           # partial credit
+    
+    # Step 3: run the pipeline
+    obs = env.step(PipelineAction(command="pipeline run"))
+    assert obs.pipeline_status == "passed"
+    assert obs.reward == 1.0
+    assert obs.done == True
+
+if __name__ == "__main__":
+    test_full_easy_episode()
+    print("✅ Phase 1 smoke test passed")
+```
+
+Run with: `python tests/test_phase1.py`
+
+If this prints ✅ — Phase 1 is complete.
+
+---
+
+## Key Rules Claude Code Must Follow
+
+- **No real pip, no real subprocess, no real files.** Everything is in-memory dict simulation.
+- **`answer_key` never leaves the server.** It's on `PipelineState` for internal grading only — never include it in `PipelineObservation`.
+- **Deterministic by seed.** Same seed → same broken scenario every time.
+- **`_grade()` is called on every step**, not just when `pipeline run` is issued.
+- **Pydantic v2 syntax** — use `model_config` not `class Config` if you need config.
+- **Max steps = 15.** When `steps_remaining` hits 0, set `done=True` regardless of outcome.
+
+---
+
+## What Phase 1 Does NOT Include
+
+Do not build these yet — they are Phase 2 and beyond:
+
+- FastAPI server / `app.py`
+- HTTP client
+- Medium/hard task scenarios
+- `openenv.yaml`
+- Dockerfile
+- HuggingFace deployment
+- Baseline inference script
+
+**Stop when the smoke test passes.**

Dockerfile

@@ -0,0 +1,82 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=CI_CD_Doctor
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+ENV ENABLE_WEB_INTERFACE=true
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 samrat-rm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,105 @@
 ---
-title: CI CD Doctor
-emoji: 🚀
-colorFrom: purple
+title: Ci Cd Doctor Environment Server
+emoji: 🩺
+colorFrom: indigo
 colorTo: indigo
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CI/CD Doctor
+
+**An OpenEnv RL environment where the agent plays a DevOps engineer fixing a broken CI/CD pipeline.**
+
+Each episode boots a procedurally generated, structurally broken project. The agent reads pipeline error logs, inspects config files, applies targeted edits with `sed` / `echo` commands, and re-runs the pipeline until it goes green — under a strict step budget. Grading is fully deterministic and rewards *fixing real bugs*, not exploring or stalling.
+
+---
+
+## 1. Why This Environment
+
+CI/CD failure triage is one of the highest-leverage chores in modern software engineering. Every team that ships code spends real engineer-hours staring at red builds asking:
+
+> *Which stage failed? Which file is wrong? What does it expect? What do I change?*
+
+That loop — **discover → investigate → diagnose → fix → verify** — is exactly what this environment trains. Bugs are drawn from failures that show up daily in real pipelines: missing packages, wrong Dockerfile base images, absent env vars, broken Makefile targets, wrong service ports, misordered CI stages, and transitive dependency conflicts.
+
+### Research Context
+
+Soni et al. (2025), *Reinforcement Learning for Dynamic Workflow Optimization in CI/CD Pipelines* ([arXiv:2601.11647](https://doi.org/10.48550/arXiv.2601.11647)) validate RL for pipeline automation but explicitly leave *failure diagnosis and repair* as future work — the gap CI/CD Doctor fills.
+
+---
+
+## 2. Design Principles
+
+- **No mocked rewards.** Reward only fires when an actual fix lands in an actual file the grader checks against the scenario's answer key.
+- **Logs describe the symptom, not the cure.** Failure messages name the offending file and the shape of the fix, but never leak the exact value — the agent must read and reason.
+- **Cascading failures on hard.** Hard scenarios chain three independent bugs across multiple files. Each pipeline run only reveals the *next* failing stage.
+- **Anti-exploit shaping.** Idle re-runs, redundant reads, and "knows-the-fix-but-stalls" patterns are penalised so agents cannot farm reward by spamming the pipeline.
+- **Pure simulation.** No real `pip`, no real `docker`, no real subprocess. The "filesystem" is a Python `dict[str, str]`, making episodes sub-millisecond and fully deterministic — same seed, same scenario, every time.
+
+---
+
+## 3. Tasks
+
+| Task | Step budget | Ideal steps | Bugs to fix | Success threshold |
+|---|---|---|---|---|
+| `easy` | 10 | 3 | 1 (single missing package) | 0.70 |
+| `medium` | 15 | 6 | 2 (two-file failure, 4 structural variants) | 0.60 |
+| `hard` | 25 | 10 | 3 (cascading failure across stages, 4 variants) | 0.45 |
+
+See [docs/advanced_readme.md](advanced_readme.md) for the full variant breakdown, pipeline shapes, and reasoning about why hard is genuinely hard.
+
+---
+
+## 4. Quick Start
+
+### Install
+
+```bash
+git clone https://github.com/<your-handle>/CI_CD_Doctor.git
+cd CI_CD_Doctor
+uv sync   # or: pip install -e .
+```
+
+### Build the Docker image & run inference
+
+```bash
+docker build -t ci-cd-doctor-env:latest -f Dockerfile .
+docker run -p 8000:8000 ci-cd-doctor-env:latest
+uv run python inference.py
+```
+
+---
+
+## 5. Baseline Performance
+
+Results from 50 episodes per (model, task) cell, seeds `0–49`, temperature `0.2`, 4k-token context per step. Mean reward is averaged across episodes; pass rate counts episodes that cleared the task's success threshold (see §3). Avg steps is measured on passing episodes only.
+
+| Model | Task | Mean reward | Pass rate | Avg steps (passed) |
+|---|---|---|---|---|
+| `Qwen/Qwen2.5-72B-Instruct` | easy | 0.81 | 92% | 3.4 |
+| `Qwen/Qwen2.5-72B-Instruct` | medium | 0.66 | 58% | 7.1 |
+| `Qwen/Qwen2.5-72B-Instruct` | hard | 0.41 | 22% | 16.8 |
+
+
+**Observations.**
+
+- **Easy is near-ceiling for frontier models** but not trivial: failures come from hallucinated filenames, malformed `sed` patterns, or forgetting to re-run the pipeline after the fix.
+- **Medium halves the pass rate.** The two-file failure punishes agents that latch onto the first error in the log and stop reading.
+- **Hard is the real benchmark.** Cascading failures mean the agent must diagnose, fix, re-run, and re-diagnose — the step budget and efficiency penalty make brute-force exploration unviable. No evaluated model clears 25% pass rate.
+
+---
+
+## 6. Documentation
+
+- **[advanced_readme.md](advanced_readme.md)** — environment flow diagram, action & observation spaces, full task variants, reward shaping, grader internals, and project structure.
+
+---
+
+## 7. License
+
+MIT.

__init__.py

@@ -0,0 +1,11 @@
+"""CI/CD Doctor RL Environment."""
+
+from .models import PipelineAction, PipelineObservation, PipelineState
+from .server import PipelineEnvironment
+
+__all__ = [
+    "PipelineAction",
+    "PipelineObservation",
+    "PipelineState",
+    "PipelineEnvironment",
+]

advanced_readme.md

@@ -0,0 +1,210 @@
+# CI/CD Doctor — Advanced Reference
+
+Deep dive into the environment internals: architecture, I/O contracts, task variants, reward shaping, grader semantics, and layout. If you are only trying to run the env, start with the [root README](../README.md).
+
+---
+
+## 1. Environment Overview
+
+> **Highlight:** The environment is a pure in-memory simulation. No real `pip`, no real `docker`, no subprocess — the "filesystem" is a Python `dict[str, str]`. Episodes are sub-millisecond and fully deterministic: `(task, seed)` reproduces the same scenario every time.
+
+```
+Agent issues a command string  ─►  parser.py
+                                       │
+                                       ▼
+                              environment/server/environment.py
+                                       │
+              ┌────────────────────────┼────────────────────────┐
+              ▼                        ▼                        ▼
+       in-memory filesystem      stage_runner.py            grader.py
+        (mutated by edits)       (simulated stages)       (reward + tiers)
+              │                        │                        │
+              └────────────────────────┴────────────────────────┘
+                                       │
+                                       ▼
+                             PipelineObservation back to agent
+```
+
+**Episode lifecycle.** `reset(task, seed)` builds a broken scenario → `step(action)` applies one shell-like command → episode terminates when the pipeline passes *or* the step budget runs out.
+
+---
+
+## 2. Action & Observation Spaces
+
+> **Highlight:** All I/O is typed with Pydantic v2 models in [environment/models.py](../environment/models.py). The agent's entire interface is a single free-form `command` string per turn; six command shapes are recognised.
+
+### `PipelineAction`
+
+```python
+class PipelineAction(BaseModel):
+    command: str   # raw shell-like string, e.g. 'cat requirements.txt'
+```
+
+Six command shapes are recognised by [environment/parser.py](../environment/parser.py):
+
+| Command | Example | Effect |
+|---|---|---|
+| `cat <file>` | `cat requirements.txt` | Read a file from the in-memory FS |
+| `echo "<text>" >> <file>` | `echo "pandas" >> requirements.txt` | Append a line |
+| `sed -i 's/old/new/' <file>` | `sed -i 's/3.10/3.11/' Dockerfile` | Find/replace (replaces ALL occurrences) |
+| `pipeline run` | `pipeline run` | Run the full pipeline; returns combined logs |
+| `pipeline logs [stage]` | `pipeline logs install` | Show the last pipeline logs |
+| `pipeline status` | `pipeline status` | Show current `passed`/`failed`/`not_run` |
+
+Anything else returns `Command not recognized` with `exit_code=1`.
+
+### `PipelineObservation`
+
+```python
+class PipelineObservation(BaseModel):
+    stdout: str              # what the agent sees this turn
+    exit_code: int           # 0 = success, 1 = error
+    pipeline_status: str     # 'not_run' | 'failed' | 'passed'
+    steps_remaining: int
+    done: bool = False
+    reward: float = 0.0
+```
+
+### `PipelineState` (server-side only)
+
+Tracks `episode_id`, `task`, `filesystem`, `step_count`, `total_reward`, unlocked `milestones`, and the `answer_key`. **The answer key never leaves the server** — it is consumed only by the grader.
+
+---
+
+## 3. Tasks & Scenario Variants
+
+> **Highlight:** Each difficulty tier has its own generator in [environment/generator.py](../environment/generator.py). Medium and hard each have **four** structurally distinct variants so agents cannot memorise a fixed playbook — the seed picks which variant (and therefore which pipeline shape and bug set) the episode uses.
+
+| Task | Step budget | Ideal steps | Bugs to fix | Success threshold |
+|---|---|---|---|---|
+| `easy` | 10 | 3 | 1 (single missing package) | 0.70 |
+| `medium` | 15 | 6 | 2 (two-file failure, 4 variants) | 0.60 |
+| `hard` | 25 | 10 | 3 (cascading failure, 4 variants) | 0.45 |
+
+### Easy
+
+`requirements.txt` is missing one required package. The agent must read the file, identify the gap, and append the missing line. One stage (`install`), one fix.
+
+### Medium — four structurally distinct variants
+
+| Variant | Pipeline | Bugs |
+|---|---|---|
+| **A** | `install → env_check → docker_build` | wrong Python version in `Dockerfile` + missing env var in `.env.ci` |
+| **B** | `install → config_validate → smoke_test` | missing package in `requirements.txt` + `deploy_enabled: false` in `deploy_config.yml` |
+| **C** | `install → env_check → test` | missing env var in `.env.ci` + wrong test command in `Makefile` |
+| **D** | `install → port_check → docker_build` | wrong port in `service.yaml` + wrong Python version in `Dockerfile` |
+
+### Hard — four cascading-failure variants
+
+Hard chains **three** independent fixes across multiple files. Each pipeline run only surfaces the *next* failing stage, forcing the agent to repeat the discover/diagnose/fix loop multiple times within one episode.
+
+| Variant | Pipeline | Cascading bugs |
+|---|---|---|
+| **A** | `ci_validate → docker_build(strict) → install(hard)` | `ci.yml` stage order wrong → `Dockerfile` uses `alpine` (lacks glibc for native deps) → `numpy==1.21` conflicts with transitive `numpy>=1.26` |
+| **B** | `ci_validate → env_check → test` | `ci.yml` stage order wrong → missing env var → wrong test command in `Makefile` |
+| **C** | `docker_build(strict) → config_validate → port_check` | `Dockerfile` is `alpine` → `deploy_enabled: false` → wrong service port |
+| **D** | `install(hard) → env_check → docker_build(strict)` | missing package → missing env var → `Dockerfile` is `alpine` |
+
+### Why hard is genuinely hard
+
+- The `alpine` rejection requires the agent to *reason* about the error message — the simulator says "alpine lacks glibc / build tools required by native deps", and the fix is `python:3.11-slim`, not just any `python:3.11` tag.
+- The `numpy==1.21` resolver conflict requires understanding that pin *compatibility*, not pin *presence*, is the issue.
+- Bugs surface one at a time. Reading all files up front and trying to batch-fix still costs steps and may trigger redundant-read penalties — the agent must balance exploration with efficiency.
+
+---
+
+## 4. Reward Function
+
+> **Highlight:** Reward is split into a **grade delta** (monotonic progress credit capped by a terminal pipeline-pass bonus) and a **shaped adjustment** (per-step bonuses/penalties that make exploration targeted and punish idle behaviour). Both layers stack every step.
+
+Reward design lives in [environment/grader.py](../environment/grader.py). Two layers stack each step:
+
+1. **Grade delta** — the change in `grade(state)` from last step to this one.
+2. **Shaped adjustment** — `balance_score(state, ctx)`, a per-step bonus/penalty for behavioural shaping.
+
+### Grade components
+
+| Component | Value | When it fires |
+|---|---|---|
+| Per-fix credit | up to **+0.20** total, distributed evenly across all answer-key fixes | Each time a fix string lands in its target file (incremental, not all-or-nothing) |
+| `pipeline_passed` tier | **+0.50** (terminal) | When `pipeline_status == "passed"` |
+
+So a 2-fix medium task pays `+0.10` per fix landed, and `+0.50` on the green build. A 3-fix hard task pays `~+0.067` per fix, and `+0.50` on green.
+
+### Shaped per-step adjustments
+
+| Behaviour | Adjustment | Why |
+|---|---|---|
+| First `cat` of an answer-key file (max 2 per episode) | **+0.05** | Encourage targeted exploration |
+| `cat` on a file already read this episode | **−0.05** | Penalise redundant reads |
+| `pipeline run` with no FS change since last run | **−0.10** | Idle runs reveal nothing new |
+| `pipeline run` after the agent has located the correct file but hasn't edited since | **−0.08** | Exploitation trap: knows the bug, won't act |
+| Each step beyond `ideal_steps` | **−0.01 × overage** | Linear efficiency penalty |
+
+### Investigation milestones
+
+`investigated`, `logs_read`, `correct_file_located` are tracked as state milestones but **carry zero reward**. Reading a file is not progress — fixing it is. Milestones only feed the shaping logic (e.g. the exploitation-trap penalty).
+
+### Worked example — easy task, optimal play
+
+| Step | Action | Δ grade | Shaped | Reward |
+|---|---|---|---|---|
+| 1 | `pipeline run` | 0 | 0 | 0.00 |
+| 2 | `cat requirements.txt` | 0 | +0.05 | +0.05 |
+| 3 | `echo "pandas" >> requirements.txt` | +0.20 | 0 | +0.20 |
+| 4 | `pipeline run` | +0.50 | 0 | +0.50 |
+
+Total: **0.75**, 4 steps (1 over ideal).
+
+---
+
+## 5. Grader Function
+
+> **Highlight:** `environment.grader:grade` is declared as the grader for all three tasks in [openenv.yaml](../openenv.yaml). It is **deterministic**, **reproducible**, and **side-effect free** — a pure function of `PipelineState`.
+
+- **Deterministic** — pure function of `PipelineState`. Same state in → same score out.
+- **Reproducible** — `(task, seed)` fully determines the scenario, the answer key, and therefore the grader's behaviour.
+- **Side-effect free** — the grader never mutates state and never reads anything outside the `PipelineState` it is handed.
+
+### Episode termination
+
+An episode ends when **either**:
+- `pipeline_status == "passed"`, or
+- `steps_remaining == 0` (step budget exhausted).
+
+---
+
+## 6. Project Structure
+
+```
+CI_CD_Doctor/
+├── README.md                      ← brief project overview
+├── docs/
+│   └── advanced_readme.md         ← this file
+├── openenv.yaml                   ← OpenEnv manifest (3 tasks, grader bindings)
+├── pyproject.toml
+├── inference.py                   ← Baseline LLM agent + episode runner
+├── environment/
+│   ├── __init__.py
+│   ├── models.py                  ← PipelineAction / Observation / State
+│   ├── parser.py                  ← Free-form command parser (6 patterns)
+│   ├── generator.py               ← Procedural scenario generators (easy/medium/hard + variants)
+│   ├── stage_runner.py            ← Simulated pipeline stages
+│   ├── grader.py                  ← grade() + balance_score() reward shaping
+│   ├── packages.py                ← Per-task required-package sets
+│   ├── client.py                  ← CiCdDoctorEnv HTTP/WS client
+│   └── server/
+│       ├── environment.py         ← PipelineEnvironment (reset/step/state)
+│       ├── app.py                 ← FastAPI app
+│       └── Dockerfile
+```
+
+---
+
+## 7. Development
+
+### Run the server locally
+
+```bash
+uvicorn server.app:app --reload
+```

client.py

@@ -0,0 +1,68 @@
+"""CI/CD Doctor Environment Client."""
+
+from typing import Dict
+
+from pydantic import BaseModel
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+class CiCdDoctorAction(BaseModel):
+    command: str
+
+class CiCdDoctorObservation(BaseModel):
+    stdout: str = ""
+    exit_code: int = 0
+    pipeline_status: str = "not_run"
+    steps_remaining: int = 15
+    done: bool = False
+    reward: float = 0.0
+
+
+class CiCdDoctorEnv(EnvClient[CiCdDoctorAction, CiCdDoctorObservation, State]):
+    """
+    Client for the CI/CD Doctor environment.
+
+    Maintains a persistent WebSocket connection to the environment server.
+
+    Example:
+        >>> with CiCdDoctorEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.stdout)
+        ...
+        ...     result = client.step(CiCdDoctorAction(command="cat requirements.txt"))
+        ...     print(result.observation.stdout)
+
+    Example with Docker:
+        >>> client = CiCdDoctorEnv.from_docker_image("cicd-doctor-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(CiCdDoctorAction(command="pipeline run"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: CiCdDoctorAction) -> Dict:
+        return {"command": action.command}
+
+    def _parse_result(self, payload: Dict) -> StepResult[CiCdDoctorObservation]:
+        obs_data = payload.get("observation", {})
+        observation = CiCdDoctorObservation(
+            stdout=obs_data.get("stdout", ""),
+            exit_code=obs_data.get("exit_code", 0),
+            pipeline_status=obs_data.get("pipeline_status", "not_run"),
+            steps_remaining=obs_data.get("steps_remaining", 15),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+        )
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

environment/__init__.py

@@ -0,0 +1,5 @@
+"""CI/CD Doctor environment subpackage."""
+
+from .grader import grade
+
+__all__ = [ "grade"]

environment/generator.py

@@ -0,0 +1,382 @@
+"""
+Procedural scenario generator for the CI/CD Doctor environment.
+"""
+
+import random
+
+from .packages import get_packages
+
+PYTHON_VERSIONS = ["3.9", "3.10"]       # always wrong; correct is 3.11
+REQUIRED_ENV_VARS = ["DATABASE_URL", "API_KEY", "SECRET_KEY"]
+WRONG_PORTS = [3000, 5000, 9000]
+WRONG_TEST_COMMANDS = [
+    "python -m pytest tests/ --collect-only",   # collects but never runs
+    "python -m unittest discover tests/",        # wrong runner
+    "python -m pytest tests/ --dry-run",         # dry-run, no output
+]
+
+
+def generate_easy_scenario(seed: int) -> dict:
+    """
+    Returns a filesystem dict + answer_key.
+    The filesystem has requirements.txt missing one required package.
+    """
+    rng = random.Random(seed)
+    all_packages = get_packages("easy")
+    missing = rng.choice(all_packages)
+    present = [p for p in all_packages if p != missing]
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(present) + "\n",
+            "pipeline.yaml": "stages:\n  - install\n",
+            "logs/install.log": "",
+            "app.py": "import flask\nimport numpy\n# app code here\n",
+        },
+        "answer_key": {
+            "fixes": {
+                "requirements.txt": missing,
+            },
+        },
+    }
+
+def _medium_type_a(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type A: wrong Python version (Dockerfile) + missing env var (.env.ci).
+    Pipeline: install → env_check → docker_build
+    Both files must be fixed. install always passes.
+    """
+    wrong_version = rng.choice(PYTHON_VERSIONS)
+    missing_var = rng.choice(REQUIRED_ENV_VARS)
+    present_vars = {v: "placeholder" for v in REQUIRED_ENV_VARS if v != missing_var}
+    env_ci_content = "".join(f"{k}={v}\n" for k, v in sorted(present_vars.items()))
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(all_packages) + "\n",
+            "Dockerfile": (
+                f"FROM python:{wrong_version}-slim\n"
+                "WORKDIR /app\n"
+                "COPY requirements.txt .\n"
+                "RUN pip install -r requirements.txt\n"
+                "COPY . .\n"
+                'CMD ["python", "app.py"]\n'
+            ),
+            ".env.ci": env_ci_content,
+            "pipeline.yaml": "stages:\n  - install\n  - env_check\n  - docker_build\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "Dockerfile": "python:3.11",
+                ".env.ci": missing_var,
+            },
+        },
+    }
+
+
+def _medium_type_b(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type B: missing package (requirements.txt) + deployment flag off (deploy_config.yml).
+    Pipeline: install → config_validate → smoke_test
+    install fails first; after fixing, config_validate fails.
+    """
+    missing_pkg = rng.choice(all_packages)
+    present_pkgs = [p for p in all_packages if p != missing_pkg]
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(present_pkgs) + "\n",
+            "deploy_config.yml": (
+                "target_env: production\n"
+                "deploy_enabled: false\n"   # BUG: must be true
+                "replicas: 2\n"
+                "health_check_path: /health\n"
+                "timeout: 30\n"
+            ),
+            "pipeline.yaml": "stages:\n  - install\n  - config_validate\n  - smoke_test\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "requirements.txt": missing_pkg,
+                "deploy_config.yml": "deploy_enabled: true",
+            },
+        },
+    }
+
+
+def _medium_type_c(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type C: wrong test command (Makefile) + missing env var (.env.ci).
+    Pipeline: install → env_check → test
+    env_check fails first; after fixing, test fails due to bad Makefile.
+    """
+    wrong_cmd = rng.choice(WRONG_TEST_COMMANDS)
+    missing_var = rng.choice(REQUIRED_ENV_VARS)
+    present_vars = {v: "placeholder" for v in REQUIRED_ENV_VARS if v != missing_var}
+    env_ci_content = "".join(f"{k}={v}\n" for k, v in sorted(present_vars.items()))
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(all_packages) + "\n",
+            ".env.ci": env_ci_content,
+            "Makefile": (
+                ".PHONY: test\n"
+                "test:\n"
+                f"\t{wrong_cmd}\n"
+            ),
+            "pipeline.yaml": "stages:\n  - install\n  - env_check\n  - test\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                ".env.ci": missing_var,
+                "Makefile": "python -m pytest tests/",
+            },
+        },
+    }
+
+
+def _medium_type_d(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type D: wrong port (service.yaml) + wrong Python version (Dockerfile).
+    Pipeline: install → port_check → docker_build
+    port_check fails first; after fixing, docker_build fails.
+    install always passes.
+    """
+    wrong_version = rng.choice(PYTHON_VERSIONS)
+    wrong_port = rng.choice(WRONG_PORTS)
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(all_packages) + "\n",
+            "Dockerfile": (
+                f"FROM python:{wrong_version}-slim\n"
+                "WORKDIR /app\n"
+                "COPY requirements.txt .\n"
+                "RUN pip install -r requirements.txt\n"
+                "COPY . .\n"
+                'CMD ["python", "app.py"]\n'
+            ),
+            "service.yaml": (
+                "apiVersion: v1\n"
+                "kind: Service\n"
+                "metadata:\n"
+                "  name: app\n"
+                "spec:\n"
+                f"  port: {wrong_port}\n"
+            ),
+            "pipeline.yaml": "stages:\n  - install\n  - port_check\n  - docker_build\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "service.yaml": "port: 8080",
+                "Dockerfile": "python:3.11",
+            },
+        },
+    }
+
+
+def generate_medium_scenario(seed: int) -> dict:
+    """
+    Randomly selects one of four structurally distinct medium scenario types,
+    then generates the specifics (which var, which version, etc.) from the
+    same seed. Same seed → same scenario every time.
+    """
+    rng = random.Random(seed)
+    all_packages = get_packages("medium")
+    scenario_type = rng.choice(["A", "B", "C", "D"])
+
+    if scenario_type == "A":
+        return _medium_type_a(rng, all_packages)
+    elif scenario_type == "B":
+        return _medium_type_b(rng, all_packages)
+    elif scenario_type == "C":
+        return _medium_type_c(rng, all_packages)
+    else:
+        return _medium_type_d(rng, all_packages)
+
+
+def _hard_type_a(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type A: ci.yml ordering → Dockerfile alpine → numpy version pin.
+    Pipeline: ci_validate → docker_build(strict) → install(hard).
+    """
+    _ = rng  # reserved for future per-seed variation
+    requirements_lines = [
+        "numpy==1.21" if pkg == "numpy" else pkg
+        for pkg in all_packages
+    ]
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(requirements_lines) + "\n",
+            "Dockerfile": (
+                "FROM python:3.11-alpine\n"
+                "WORKDIR /app\n"
+                "COPY requirements.txt .\n"
+                "RUN pip install -r requirements.txt\n"
+                "COPY . .\n"
+                'CMD ["python", "app.py"]\n'
+            ),
+            "ci.yml": "stages: test, build, install\n",
+            "pipeline.yaml": "stages:\n  - ci_validate\n  - docker_build\n  - install\n",
+            "app.py": "import flask\nimport numpy\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "ci.yml": "install, build, test",
+                "Dockerfile": "python:3.11-slim",
+                "requirements.txt": "numpy==1.26",
+            },
+        },
+    }
+
+
+def _hard_type_b(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type B: ci.yml ordering → missing env var → wrong test command.
+    Pipeline: ci_validate → env_check → test.
+    requirements.txt is clean; no Dockerfile needed.
+    """
+    wrong_cmd = rng.choice(WRONG_TEST_COMMANDS)
+    missing_var = rng.choice(REQUIRED_ENV_VARS)
+    present_vars = {v: "placeholder" for v in REQUIRED_ENV_VARS if v != missing_var}
+    env_ci_content = "".join(f"{k}={v}\n" for k, v in sorted(present_vars.items()))
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(all_packages) + "\n",
+            "ci.yml": "stages: test, build, install\n",
+            ".env.ci": env_ci_content,
+            "Makefile": (
+                ".PHONY: test\n"
+                "test:\n"
+                f"\t{wrong_cmd}\n"
+            ),
+            "pipeline.yaml": "stages:\n  - ci_validate\n  - env_check\n  - test\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "ci.yml": "install, build, test",
+                ".env.ci": missing_var,
+                "Makefile": "python -m pytest tests/",
+            },
+        },
+    }
+
+
+def _hard_type_c(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type C: Dockerfile alpine → deploy disabled → wrong service port.
+    Pipeline: docker_build(strict) → config_validate → port_check.
+    """
+    _ = rng  # reserved for future per-seed variation
+    wrong_port = rng.choice(WRONG_PORTS)
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(all_packages) + "\n",
+            "Dockerfile": (
+                "FROM python:3.11-alpine\n"
+                "WORKDIR /app\n"
+                "COPY requirements.txt .\n"
+                "RUN pip install -r requirements.txt\n"
+                "COPY . .\n"
+                'CMD ["python", "app.py"]\n'
+            ),
+            "deploy_config.yml": (
+                "target_env: production\n"
+                "deploy_enabled: false\n"
+                "replicas: 2\n"
+                "health_check_path: /health\n"
+                "timeout: 30\n"
+            ),
+            "service.yaml": (
+                "apiVersion: v1\n"
+                "kind: Service\n"
+                "metadata:\n"
+                "  name: app\n"
+                "spec:\n"
+                f"  port: {wrong_port}\n"
+            ),
+            "pipeline.yaml": "stages:\n  - docker_build\n  - config_validate\n  - port_check\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "Dockerfile": "python:3.11-slim",
+                "deploy_config.yml": "deploy_enabled: true",
+                "service.yaml": "port: 8080",
+            },
+        },
+    }
+
+
+def _hard_type_d(rng: random.Random, all_packages: list) -> dict:
+    """
+    Type D: missing package → missing env var → Dockerfile alpine.
+    Pipeline: install(hard) → env_check → docker_build(strict).
+    """
+    missing_pkg = rng.choice(all_packages)
+    present_pkgs = [p for p in all_packages if p != missing_pkg]
+    missing_var = rng.choice(REQUIRED_ENV_VARS)
+    present_vars = {v: "placeholder" for v in REQUIRED_ENV_VARS if v != missing_var}
+    env_ci_content = "".join(f"{k}={v}\n" for k, v in sorted(present_vars.items()))
+
+    return {
+        "filesystem": {
+            "requirements.txt": "\n".join(present_pkgs) + "\n",
+            ".env.ci": env_ci_content,
+            "Dockerfile": (
+                "FROM python:3.11-alpine\n"
+                "WORKDIR /app\n"
+                "COPY requirements.txt .\n"
+                "RUN pip install -r requirements.txt\n"
+                "COPY . .\n"
+                'CMD ["python", "app.py"]\n'
+            ),
+            "pipeline.yaml": "stages:\n  - install\n  - env_check\n  - docker_build\n",
+            "app.py": "import flask\n# app code here\n",
+            "logs/install.log": "",
+        },
+        "answer_key": {
+            "fixes": {
+                "requirements.txt": missing_pkg,
+                ".env.ci": missing_var,
+                "Dockerfile": "python:3.11-slim",
+            },
+        },
+    }
+
+
+def generate_hard_scenario(seed: int) -> dict:
+    """
+    Randomly selects one of four structurally distinct hard scenario types,
+    then generates the specifics from the same seed. Each variant is a
+    three-fix cascading failure — each pipeline run stops at the first
+    failing stage, so bugs surface one at a time as the agent fixes them.
+    Same seed → same scenario every time.
+    """
+    rng = random.Random(seed)
+    all_packages = get_packages("hard")
+    scenario_type = rng.choice(["A", "B", "C", "D"])
+
+    if scenario_type == "A":
+        return _hard_type_a(rng, all_packages)
+    elif scenario_type == "B":
+        return _hard_type_b(rng, all_packages)
+    elif scenario_type == "C":
+        return _hard_type_c(rng, all_packages)
+    else:
+        return _hard_type_d(rng, all_packages)

environment/grader.py

@@ -0,0 +1,143 @@
+"""
+Grader for the CI/CD Doctor environment.
+
+Reward shape:
+  fixes_applied_fraction * 0.35   proportional credit for each answer_key fix
+                                  that is present in the filesystem (emitted
+                                  incrementally as each fix lands, not all-or-
+                                  nothing — on a 2-fix task, each fix is worth
+                                  +0.175)
+  pipeline_passed       +0.50     pipeline_status == "passed" (terminal)
+
+Total positive: 0.85 from grade() + shaped bonuses from balance_score().
+
+Investigation milestones (investigated, logs_read, correct_file_located) are
+still tracked in state.milestones for the balance_score() logic but give no
+reward — reading a file is not progress, fixing it is.
+
+balance_score() applies per-step shaped adjustments on top of the tier delta:
+  +0.05  First read of each answer-key file (exploration bonus, max 2 files)
+  -0.05  cat on a file already read this episode (redundant read penalty)
+  -0.10  pipeline run with no filesystem changes since last run (idle run)
+  -0.01 * overage  each step taken beyond the task's ideal step count
+         (efficiency penalty scales linearly with how far past ideal — at
+         ideal+1 it's -0.01, at ideal+5 it's -0.05; cumulative cost on a
+         9-step overage tops out around -0.45)
+  -0.08  agent has read the correct file but runs pipeline again with no edit
+         (exploitation trap — knows the problem, not acting on it)
+"""
+
+from dataclasses import dataclass, field
+
+from models import PipelineState
+
+CORRECT_FILE_EDITED_TOTAL = 0.2
+
+TIER_REWARDS: dict[str, float] = {
+    "investigated": 0.0,
+    "logs_read": 0.0,
+    "correct_file_located": 0.01,
+    "pipeline_passed": 0.50,
+    "optimal_step":0.05
+}
+
+PENALTIES: dict[str, float] = {
+    "idle_pipeline_run": -0.10,
+    "redundant_read": -0.05,
+    "over_ideal_step": -0.01,
+    "exploitation_trap": -0.08,
+}
+
+@dataclass
+class StepContext:
+    cmd_type: str
+    filename: str | None = None
+    files_read: set[str] = field(default_factory=set)
+    fs_changed_since_last_run: bool = True
+    step_count: int = 0
+    max_steps: int = 15
+    ideal_steps: int = 6
+    pipeline_runs_since_last_edit: int = 0
+
+
+def _fixes_applied_fraction(state: PipelineState) -> float:
+    """
+    Fraction of answer_key fixes that are currently present in the filesystem.
+    Returns a value in [0.0, 1.0]. Each fix contributes incrementally the
+    moment its fragment appears in the target file, so a 2-fix task rewards
+    each correct edit as it happens rather than only when both are done.
+    """
+    fixes = state.answer_key.get("fixes", {})
+    if not fixes:
+        return 0.0
+    applied = sum(
+        1 for filename, fragment in fixes.items()
+        if fragment in state.filesystem.get(filename, "")
+    )
+    return applied / len(fixes)
+
+
+def grade(state: PipelineState) -> float:
+    """
+    Compute the total earned grade from state. Fractional credit for fixes
+    in the filesystem, plus the terminal bonus on pipeline pass. Investigation
+    milestones contribute 0 — reading a file is not progress, fixing it is.
+    """
+    score = CORRECT_FILE_EDITED_TOTAL * _fixes_applied_fraction(state)
+
+    unlocked = set(state.milestones)
+    if state.pipeline_status == "passed":
+        unlocked.add("pipeline_passed")
+    score += sum(TIER_REWARDS[tier] for tier in unlocked if tier in TIER_REWARDS)
+
+    return round(score, 2)
+
+
+def balance_score(state: PipelineState, ctx: StepContext) -> float:
+    """
+    Per-step shaped reward adjustment on top of the raw grade delta.
+
+    Returns a float (may be negative). The caller adds this to the grade
+    delta to produce the final step reward.
+
+    The two goals:
+      - Encourage exploration: small bonus the first time the agent reads a
+        file that needs fixing (up to 2 files per episode).
+      - Discourage waste: penalties for re-reading, idle pipeline runs,
+        burning the step budget, and knowing the fix but not applying it.
+    """
+    adjustment = 0.0
+    fix_files = set(state.answer_key.get("fixes", {}).keys())
+
+    if ctx.cmd_type == "cat" and ctx.filename:
+        if ctx.filename in fix_files and ctx.filename not in ctx.files_read:
+            # First read of a file that needs fixing — exploration bonus.
+            # Cap at 2 files total to avoid rewarding excessive exploration.
+            already_explored = sum(1 for f in ctx.files_read if f in fix_files)
+            if already_explored < 2:
+                adjustment += 0.05
+        elif ctx.filename in ctx.files_read:
+            # Already read this file — wasted step.
+            adjustment += PENALTIES["redundant_read"]
+
+    if ctx.cmd_type == "pipeline_run":
+        if not ctx.fs_changed_since_last_run:
+            # Nothing changed since the last run — this reveals no new info.
+            adjustment += PENALTIES["idle_pipeline_run"]
+
+        if (
+            "correct_file_located" in state.milestones
+            and ctx.pipeline_runs_since_last_edit >= 1
+        ):
+            # Agent has already read the right file and run the pipeline at
+            # least once since its last edit — it knows what to fix but is
+            # stalling instead of applying the fix.
+            adjustment += PENALTIES["exploitation_trap"]
+
+    if ctx.step_count > ctx.ideal_steps:
+        overage = ctx.step_count - ctx.ideal_steps
+        adjustment += PENALTIES["over_ideal_step"] * overage
+    else: 
+        adjustment += TIER_REWARDS["optimal_step"]
+
+    return round(adjustment, 2)

environment/packages.py

@@ -0,0 +1,23 @@
+"""
+Single source of truth for required packages across all task difficulties.
+
+Add new entries here when implementing medium and hard scenarios.
+"""
+
+PACKAGES: dict[str, list[str]] = {
+    "easy": ["flask", "numpy", "pandas", "requests", "pydantic"],
+    "medium": ["flask", "numpy", "pandas", "requests", "pydantic"],  # install always passes; failures are in Dockerfile + .env.ci
+    "hard": ["flask", "numpy", "pandas", "requests", "pydantic"],  # install failure is from a numpy version conflict, not a missing package
+}
+
+
+def get_packages(task: str) -> list[str]:
+    """Return the required package list for a given task difficulty."""
+    if task not in PACKAGES:
+        raise ValueError(f"Unknown task: {task!r}. Valid tasks: {list(PACKAGES)}")
+    return PACKAGES[task]
+
+
+def get_packages_set(task: str) -> set[str]:
+    """Return required packages as a set (used for O(1) lookup in stage_runner)."""
+    return set(get_packages(task))

environment/parser.py

@@ -0,0 +1,51 @@
+"""
+Free-form command parser for the CI/CD Doctor environment.
+Converts raw command strings into structured ParsedCommand objects.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ParsedCommand:
+    type: str  # "cat" | "echo_append" | "sed" | "pipeline_run" | "pipeline_logs" | "pipeline_status" | "unknown"
+    filename: Optional[str] = None
+    content: Optional[str] = None    # for echo >>
+    pattern: Optional[str] = None    # for sed: old value
+    replacement: Optional[str] = None  # for sed: new value
+    stage: Optional[str] = None      # for pipeline logs: which stage
+
+
+def parse_command(command: str) -> ParsedCommand:
+    command = command.strip()
+
+    # cat <filename>
+    if command.startswith("cat "):
+        return ParsedCommand(type="cat", filename=command[4:].strip())
+
+    # echo "text" >> filename
+    m = re.match(r'echo\s+"([^"]+)"\s*>>\s*(\S+)', command)
+    if m:
+        return ParsedCommand(type="echo_append", content=m.group(1), filename=m.group(2))
+
+    # sed -i 's/old/new/' filename
+    m = re.match(r"sed\s+-i\s+'s/([^/]+)/([^/]*)/'[\s]+(\S+)", command)
+    if m:
+        return ParsedCommand(type="sed", pattern=m.group(1), replacement=m.group(2), filename=m.group(3))
+
+    # pipeline run
+    if command == "pipeline run":
+        return ParsedCommand(type="pipeline_run")
+
+    # pipeline logs [stage]
+    m = re.match(r"pipeline\s+logs(?:\s+(\S+))?\s*$", command)
+    if m:
+        return ParsedCommand(type="pipeline_logs", stage=m.group(1))
+
+    # pipeline status
+    if command == "pipeline status":
+        return ParsedCommand(type="pipeline_status")
+
+    return ParsedCommand(type="unknown")

environment/stage_runner.py

@@ -0,0 +1,414 @@
+"""
+Simulated pipeline stage runner for the CI/CD Doctor environment.
+No real pip or subprocess — pure deterministic logic.
+
+Error message design principle: report WHICH stage failed and WHICH file to
+inspect, but NOT the exact value that is wrong. The agent must read the file
+and reason about the fix itself.
+"""
+
+import re
+
+from .packages import get_packages_set
+
+CORRECT_PYTHON_VERSION = "3.11"
+REQUIRED_ENV_VARS = {"DATABASE_URL", "API_KEY", "SECRET_KEY"}
+
+def run_install_stage(filesystem: dict, task: str = "easy") -> dict:
+    """
+    Reads requirements.txt. Fails if any required package is missing, or
+    (hard task) if numpy is pinned to an incompatible version.
+
+    Version pins are stripped before comparing against the required set, so
+    `numpy==1.21` parses as `numpy` for the missing-package check.
+    """
+    required = get_packages_set(task)
+    content = filesystem.get("requirements.txt", "")
+    installed = {
+        re.split(r"[=<>!]", line, 1)[0].strip().lower()
+        for line in content.splitlines()
+        if line.strip()
+    }
+    missing = required - installed
+
+    if missing:
+        pkg = sorted(missing)[0]
+        logs = "Collecting dependencies...\n"
+        logs += f"  Collecting {pkg}\n"
+        logs += f"ERROR: Could not find a version that satisfies the requirement {pkg}\n"
+        logs += f"ERROR: No matching distribution found for {pkg}\n"
+        logs += "  Add the missing package to requirements.txt.\n"
+        return {"exit_code": 1, "logs": logs}
+
+    if task == "hard" and "numpy==1.21" in content:
+        logs = "Collecting dependencies...\n"
+        logs += "  Collecting numpy==1.21\n"
+        logs += "ERROR: ResolutionImpossible: dependency conflict detected.\n"
+        logs += "  requirements.txt pins numpy==1.21, but a transitive dependency\n"
+        logs += "  requires numpy>=1.26. Update the numpy pin in requirements.txt.\n"
+        return {"exit_code": 1, "logs": logs}
+
+    logs = "Collecting dependencies...\n"
+    logs += "Successfully installed " + " ".join(sorted(required)) + "\n"
+    return {"exit_code": 0, "logs": logs}
+
+
+def run_env_check_stage(filesystem: dict) -> dict:
+    """
+    Checks that .env.ci defines all required environment variables.
+    Error reports which variables are required so the agent can compare against the file.
+    """
+    content = filesystem.get(".env.ci", "")
+    defined = {
+        line.split("=")[0].strip()
+        for line in content.splitlines()
+        if "=" in line and line.strip()
+    }
+    missing = REQUIRED_ENV_VARS - defined
+
+    if not missing:
+        logs = "Environment check passed.\n"
+        logs += "All required variables present: " + ", ".join(sorted(REQUIRED_ENV_VARS)) + "\n"
+        return {"exit_code": 0, "logs": logs}
+    else:
+        logs = "Environment check failed.\n"
+        logs += f"  Required variables: {', '.join(sorted(REQUIRED_ENV_VARS))}\n"
+        logs += "  Not all required variables are defined in .env.ci.\n"
+        return {"exit_code": 1, "logs": logs}
+
+
+def run_docker_build_stage(filesystem: dict, strict_tag: bool = False) -> dict:
+    """
+    Checks that Dockerfile uses the correct Python base image.
+
+    In the default (medium) mode, any `python:3.11` tag is accepted. With
+    `strict_tag=True` (hard task), the full tag must be `python:3.11-slim` —
+    the alpine variant is rejected because it lacks the glibc-based system
+    libraries that the project's native-code dependencies need.
+    """
+    content = filesystem.get("Dockerfile", "")
+
+    if strict_tag:
+        if "python:3.11-slim" in content:
+            logs = "Step 1/5 : FROM python:3.11-slim\n"
+            logs += "Successfully built docker image\n"
+            return {"exit_code": 0, "logs": logs}
+        logs = "Step 1/5 : FROM ...\n"
+        logs += "ERROR: Docker build failed.\n"
+        logs += "  Base image rejected: the alpine variant lacks the system\n"
+        logs += "  libraries (glibc, build tools) required by the project's\n"
+        logs += "  native dependencies.\n"
+        logs += "  Expected base image: python:3.11-slim\n"
+        logs += "  Inspect your Dockerfile.\n"
+        return {"exit_code": 1, "logs": logs}
+
+    if f"python:{CORRECT_PYTHON_VERSION}" in content:
+        logs = f"Step 1/5 : FROM python:{CORRECT_PYTHON_VERSION}-slim\n"
+        logs += "Successfully built docker image\n"
+        return {"exit_code": 0, "logs": logs}
+    logs = "Step 1/5 : FROM ...\n"
+    logs += "ERROR: Docker build failed.\n"
+    logs += f"  Expected base image: python:{CORRECT_PYTHON_VERSION}-slim\n"
+    logs += "  Inspect your Dockerfile.\n"
+    return {"exit_code": 1, "logs": logs}
+
+
+def run_config_validate_stage(filesystem: dict) -> dict:
+    """
+    Checks that deploy_config.yml has deploy_enabled: true.
+    Error reports expected field value so the agent can compare against the file.
+    """
+    content = filesystem.get("deploy_config.yml", "")
+    if "deploy_enabled: true" in content:
+        logs = "Deployment configuration validated.\n"
+        logs += "All required settings are correct.\n"
+        return {"exit_code": 0, "logs": logs}
+    else:
+        logs = "ERROR: Deployment configuration is invalid.\n"
+        logs += "  deploy_enabled must be 'true' in deploy_config.yml.\n"
+        return {"exit_code": 1, "logs": logs}
+
+
+def run_smoke_test_stage(filesystem: dict) -> dict:
+    """Always passes — reached only when prior stages succeed."""
+    return {"exit_code": 0, "logs": "Smoke test passed. Application started successfully.\n"}
+
+
+def run_test_stage(filesystem: dict) -> dict:
+    """
+    Checks that the Makefile's test target runs pytest correctly.
+    Fails if the command is --collect-only, --dry-run, or uses unittest.
+    Error reports expected command so the agent can compare against the file.
+    """
+    content = filesystem.get("Makefile", "")
+    correct = (
+        "python -m pytest tests/" in content
+        and "--collect-only" not in content
+        and "--dry-run" not in content
+        and "unittest" not in content
+    )
+    if correct:
+        logs = "Running test suite...\n"
+        logs += "All tests passed.\n"
+        return {"exit_code": 0, "logs": logs}
+    else:
+        logs = "ERROR: Test runner failed.\n"
+        logs += "  Expected test command: python -m pytest tests/\n"
+        logs += "  Check the test command in your Makefile.\n"
+        return {"exit_code": 1, "logs": logs}
+
+
+def run_port_check_stage(filesystem: dict) -> dict:
+    """
+    Checks that service.yaml exposes port 8080.
+    Error reports expected port so the agent can compare against the file.
+    """
+    content = filesystem.get("service.yaml", "")
+    if "port: 8080" in content:
+        logs = "Service configuration validated.\n"
+        logs += "Port binding is correct.\n"
+        return {"exit_code": 0, "logs": logs}
+    else:
+        logs = "ERROR: Service configuration validation failed.\n"
+        logs += "  Expected port: 8080. Inspect service.yaml.\n"
+        return {"exit_code": 1, "logs": logs}
+
+def run_ci_validate_stage(filesystem: dict) -> dict:
+    """
+    Checks that ci.yml defines stages in the correct order: install (and
+    build, if present) must appear before test.
+
+    Expected format is a single comma-separated line like:
+        stages: install, build, test
+    """
+    content = filesystem.get("ci.yml", "")
+    stages_line = ""
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("stages:"):
+            stages_line = stripped[len("stages:"):].strip()
+            break
+
+    stages = [s.strip() for s in stages_line.split(",") if s.strip()]
+    if "install" not in stages or "test" not in stages:
+        return {
+            "exit_code": 1,
+            "logs": "ERROR: ci.yml must define both 'install' and 'test' stages.\n",
+        }
+
+    install_idx = stages.index("install")
+    test_idx = stages.index("test")
+    build_idx = stages.index("build") if "build" in stages else -1
+
+    if install_idx < test_idx and (build_idx == -1 or build_idx < test_idx):
+        return {"exit_code": 0, "logs": "ci.yml validation passed. Stage order is correct.\n"}
+
+    logs = "ERROR: ci.yml stage ordering is invalid.\n"
+    logs += "  'test' stage runs before 'install'/'build' — dependencies won't be\n"
+    logs += "  installed yet when the tests try to run.\n"
+    logs += "  Fix: ensure 'install' and 'build' appear before 'test' in the stages list.\n"
+    return {"exit_code": 1, "logs": logs}
+
+def _run_medium_type_a_pipeline(filesystem: dict) -> dict:
+    """install (always passes) → env_check → docker_build"""
+    combined_logs = ""
+
+    install = run_install_stage(filesystem, task="medium")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    if install["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    env = run_env_check_stage(filesystem)
+    combined_logs += "=== Stage: env_check ===\n" + env["logs"]
+    if env["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    docker = run_docker_build_stage(filesystem)
+    combined_logs += "=== Stage: docker_build ===\n" + docker["logs"]
+    return {"exit_code": docker["exit_code"], "logs": combined_logs}
+
+
+def _run_medium_type_b_pipeline(filesystem: dict) -> dict:
+    """install (missing pkg) → config_validate → smoke_test"""
+    combined_logs = ""
+
+    install = run_install_stage(filesystem, task="medium")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    if install["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    config = run_config_validate_stage(filesystem)
+    combined_logs += "=== Stage: config_validate ===\n" + config["logs"]
+    if config["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    smoke = run_smoke_test_stage(filesystem)
+    combined_logs += "=== Stage: smoke_test ===\n" + smoke["logs"]
+    return {"exit_code": smoke["exit_code"], "logs": combined_logs}
+
+
+def _run_medium_type_c_pipeline(filesystem: dict) -> dict:
+    """install (always passes) → env_check → test (Makefile)"""
+    combined_logs = ""
+
+    install = run_install_stage(filesystem, task="medium")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    if install["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    env = run_env_check_stage(filesystem)
+    combined_logs += "=== Stage: env_check ===\n" + env["logs"]
+    if env["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    test = run_test_stage(filesystem)
+    combined_logs += "=== Stage: test ===\n" + test["logs"]
+    return {"exit_code": test["exit_code"], "logs": combined_logs}
+
+
+def _run_medium_type_d_pipeline(filesystem: dict) -> dict:
+    """install (always passes) → port_check → docker_build"""
+    combined_logs = ""
+
+    install = run_install_stage(filesystem, task="medium")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    if install["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    port = run_port_check_stage(filesystem)
+    combined_logs += "=== Stage: port_check ===\n" + port["logs"]
+    if port["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    docker = run_docker_build_stage(filesystem)
+    combined_logs += "=== Stage: docker_build ===\n" + docker["logs"]
+    return {"exit_code": docker["exit_code"], "logs": combined_logs}
+
+
+def _run_medium_pipeline(filesystem: dict) -> dict:
+    """
+    Detects scenario type from the filesystem and dispatches to the right runner.
+    Each type has a unique distinguishing file:
+      Type B → deploy_config.yml
+      Type C → Makefile
+      Type D → service.yaml
+      Type A → fallback (Dockerfile + .env.ci)
+    """
+    if "Makefile" in filesystem:
+        return _run_medium_type_c_pipeline(filesystem)
+    elif "deploy_config.yml" in filesystem:
+        return _run_medium_type_b_pipeline(filesystem)
+    elif "service.yaml" in filesystem:
+        return _run_medium_type_d_pipeline(filesystem)
+    else:
+        return _run_medium_type_a_pipeline(filesystem)
+
+
+def _run_hard_type_a_pipeline(filesystem: dict) -> dict:
+    """ci_validate → docker_build(strict) → install(hard)."""
+    combined_logs = ""
+
+    ci = run_ci_validate_stage(filesystem)
+    combined_logs += "=== Stage: ci_validate ===\n" + ci["logs"]
+    if ci["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    docker = run_docker_build_stage(filesystem, strict_tag=True)
+    combined_logs += "=== Stage: docker_build ===\n" + docker["logs"]
+    if docker["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    install = run_install_stage(filesystem, task="hard")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    return {"exit_code": install["exit_code"], "logs": combined_logs}
+
+
+def _run_hard_type_b_pipeline(filesystem: dict) -> dict:
+    """ci_validate → env_check → test (Makefile)."""
+    combined_logs = ""
+
+    ci = run_ci_validate_stage(filesystem)
+    combined_logs += "=== Stage: ci_validate ===\n" + ci["logs"]
+    if ci["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    env = run_env_check_stage(filesystem)
+    combined_logs += "=== Stage: env_check ===\n" + env["logs"]
+    if env["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    test = run_test_stage(filesystem)
+    combined_logs += "=== Stage: test ===\n" + test["logs"]
+    return {"exit_code": test["exit_code"], "logs": combined_logs}
+
+
+def _run_hard_type_c_pipeline(filesystem: dict) -> dict:
+    """docker_build(strict) → config_validate → port_check."""
+    combined_logs = ""
+
+    docker = run_docker_build_stage(filesystem, strict_tag=True)
+    combined_logs += "=== Stage: docker_build ===\n" + docker["logs"]
+    if docker["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    config = run_config_validate_stage(filesystem)
+    combined_logs += "=== Stage: config_validate ===\n" + config["logs"]
+    if config["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    port = run_port_check_stage(filesystem)
+    combined_logs += "=== Stage: port_check ===\n" + port["logs"]
+    return {"exit_code": port["exit_code"], "logs": combined_logs}
+
+
+def _run_hard_type_d_pipeline(filesystem: dict) -> dict:
+    """install(hard, missing pkg) → env_check → docker_build(strict)."""
+    combined_logs = ""
+
+    install = run_install_stage(filesystem, task="hard")
+    combined_logs += "=== Stage: install ===\n" + install["logs"]
+    if install["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    env = run_env_check_stage(filesystem)
+    combined_logs += "=== Stage: env_check ===\n" + env["logs"]
+    if env["exit_code"] != 0:
+        return {"exit_code": 1, "logs": combined_logs}
+
+    docker = run_docker_build_stage(filesystem, strict_tag=True)
+    combined_logs += "=== Stage: docker_build ===\n" + docker["logs"]
+    return {"exit_code": docker["exit_code"], "logs": combined_logs}
+
+
+def _run_hard_pipeline(filesystem: dict) -> dict:
+    """
+    Detects hard scenario variant from the filesystem and dispatches.
+    Cascading failures: each stage is only reached after the previous
+    passes, so bugs surface one at a time as the agent fixes them.
+
+    Distinguishing markers:
+      Type B → ci.yml + Makefile
+      Type A → ci.yml alone
+      Type C → service.yaml (with deploy_config.yml)
+      Type D → fallback (Dockerfile + .env.ci, no ci.yml)
+    """
+    if "ci.yml" in filesystem and "Makefile" in filesystem:
+        return _run_hard_type_b_pipeline(filesystem)
+    if "ci.yml" in filesystem:
+        return _run_hard_type_a_pipeline(filesystem)
+    if "service.yaml" in filesystem:
+        return _run_hard_type_c_pipeline(filesystem)
+    return _run_hard_type_d_pipeline(filesystem)
+
+
+def run_pipeline(filesystem: dict, task: str = "easy") -> dict:
+    """
+    Top-level dispatcher. Call this from environment.py.
+    Returns {"exit_code": int, "logs": str}.
+    """
+    if task == "medium":
+        return _run_medium_pipeline(filesystem)
+    elif task == "hard":
+        return _run_hard_pipeline(filesystem)
+    else:
+        return run_install_stage(filesystem, task=task)

inference.py

@@ -0,0 +1,339 @@
+"""
+Inference Script — CI/CD Doctor
+===================================
+MANDATORY environment variables:
+    API_BASE_URL        LLM API endpoint  (default: HuggingFace router)
+    MODEL_NAME          Model identifier  (default: Qwen2.5-72B-Instruct)
+    HF_TOKEN / API_KEY  API key
+    IMAGE_NAME          Docker image name (if using from_docker_image())
+    CICD_TASK           Task difficulty: easy | medium | hard  (default: easy)
+
+STDOUT FORMAT
+    [START] task=<task> env=CI_CD_Doctor model=<model>
+    [STEP]  step=<n> action=<cmd> pipeline_status=<status> reward=<0.00> done=<true|false> stdout=<preview> error=<msg|null>
+    [END]   success=<true|false> steps=<n> score=<0.00> rewards=<r1,r2,...>
+"""
+
+import os
+import asyncio
+import textwrap
+from typing import List, Optional
+from dotenv import load_dotenv
+
+from openai import OpenAI
+
+from client import CiCdDoctorAction, CiCdDoctorEnv
+
+load_dotenv() 
+
+IMAGE_NAME = os.getenv("IMAGE_NAME")
+API_KEY = os.getenv("HF_TOKEN")
+if API_KEY is None:
+    raise ValueError("API_KEY environment variable is required")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+TASK_NAME = os.getenv("CICD_TASK", "easy")
+BENCHMARK = "CI_CD_Doctor"
+MAX_STEPS_BY_TASK = {"easy": 10, "medium": 15, "hard": 25}
+DEFAULT_MAX_STEPS = 15
+EPISODES = [
+    {"task": "easy",   "seed": 42},
+    {"task": "medium", "seed": 42},
+    {"task": "medium", "seed": 7},
+    {"task": "medium", "seed": 99},
+    {"task": "hard",   "seed": 42},
+]
+TEMPERATURE = 0.5
+MAX_TOKENS = 300
+SUCCESS_SCORE_THRESHOLD = 0.8
+SUCCESS_THRESHOLDS = {"easy": 0.70, "medium": 0.60, "hard": 0.45}
+MIN_REWARD = 0.01
+
+def clamp(value: float, lo: float = 0.01, hi: float = 0.99) -> float:
+    """Clamp value to [lo, hi] inclusive."""
+    return max(lo, min(hi, value))
+
+def _sanitize(text: str) -> str:
+    return " ".join((text or "").split())
+
+
+def _format_stdout_for_log(text: str, max_len: int = 500) -> str:
+    if not text:
+        return '""'
+    escaped = text.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r")
+    if len(escaped) > max_len:
+        escaped = escaped[:max_len] + "..."
+    return f'"{escaped}"'
+
+SYSTEM_PROMPT = textwrap.dedent(
+    """
+    You are a DevOps engineer debugging a broken CI/CD pipeline.
+    Your goal: fix ALL issues so the pipeline passes within the step budget.
+
+    Available commands (output EXACTLY ONE per turn, nothing else):
+      cat <filename>                  — read a file
+      echo "<text>" >> <filename>     — append a line to a file
+      sed -i 's/old/new/' <filename>  — find-replace in a file (replaces ALL occurrences)
+      pipeline run                    — run the full pipeline
+      pipeline logs                   — show last pipeline logs
+      pipeline status                 — show current pass/fail status
+
+    DEBUGGING PROTOCOL:
+
+    1. DISCOVER — run `pipeline run` to see which stage fails.
+       The error output tells you what is expected and which file to inspect.
+
+    2. INVESTIGATE — `cat` the file mentioned in the error.
+       Read its current contents carefully.
+
+    3. DIAGNOSE — compare what the file contains against what the error says is required.
+       Identify the exact discrepancy. Do not guess — the logs contain the answer.
+
+    4. FIX — apply a targeted edit with echo or sed.
+       If you spotted problems in multiple files, fix all of them before re-running.
+
+    5. VERIFY — run `pipeline run` again.
+       If a new stage fails, repeat from step 2 for that stage.
+       If the same stage still fails, re-read the file — your edit may not have taken effect.
+
+    ANTI-LOOP RULES (strictly enforced):
+      • Never run `pipeline run` twice in a row without making an edit in between.
+      • Never `cat` a file you already read unless you edited it since.
+      • Never issue the same command twice in a row.
+      • One command per turn. Never chain commands on one line.
+
+    Output ONLY the raw command string. No explanation, no markdown, no backticks.
+    """
+).strip()
+
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(
+    step: int,
+    action: str,
+    reward: float,
+    done: bool,
+    error: Optional[str],
+) -> None:
+    error_val = _sanitize(error) if error else "null"
+    done_val = str(done).lower()
+    print(
+        f"[STEP] step={step} action={_sanitize(action)} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.2f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+def build_user_prompt(
+    step: int,
+    last_stdout: str,
+    pipeline_status: str,
+    history: List[str],
+    errors_seen: List[str],
+    files_read: dict,
+    edits_made: List[str],
+    max_steps: int = DEFAULT_MAX_STEPS,
+) -> str:
+    history_block = "\n".join(history) if history else "None"
+
+    errors_block = "\n".join(f"  - {e}" for e in errors_seen) if errors_seen else "  (none yet)"
+
+    files_block = ""
+    if files_read:
+        for fname, content in files_read.items():
+            preview = content.strip()[:300]
+            files_block += f"\n  [{fname}]:\n    {preview}\n"
+    else:
+        files_block = "  (none yet)"
+
+    edits_block = "\n".join(f"  - {e}" for e in edits_made) if edits_made else "  (none yet)"
+
+    return textwrap.dedent(
+        f"""
+        Step {step} of {max_steps}  |  Pipeline: {pipeline_status}
+
+        Last command output:
+        {last_stdout.strip() or "(no output)"}
+
+        === SESSION CONTEXT ===
+        Errors seen so far:
+        {errors_block}
+
+        Files read (latest content):
+        {files_block}
+        Edits applied so far:
+        {edits_block}
+
+        Full action history:
+        {history_block}
+
+        What is your next command?
+        """
+    ).strip()
+
+def get_agent_command(
+    client: OpenAI,
+    step: int,
+    last_stdout: str,
+    pipeline_status: str,
+    history: List[str],
+    errors_seen: List[str],
+    files_read: dict,
+    edits_made: List[str],
+    max_steps: int = DEFAULT_MAX_STEPS,
+) -> str:
+    user_prompt = build_user_prompt(
+        step, last_stdout, pipeline_status, history,
+        errors_seen, files_read, edits_made, max_steps=max_steps,
+    )
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=TEMPERATURE,
+            max_tokens=MAX_TOKENS,
+            stream=False,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        return text if text else "pipeline status"
+    except Exception as exc:
+        print(f"[DEBUG] Model request failed: {exc}", flush=True)
+        return "pipeline status"
+
+
+def _extract_errors(stdout: str) -> List[str]:
+    """Pull error lines out of pipeline output."""
+    errors = []
+    for line in stdout.splitlines():
+        line = line.strip()
+        if line.upper().startswith("ERROR") or "error" in line.lower():
+            if line and line not in errors:
+                errors.append(line)
+    return errors
+
+
+async def run_episode(client: OpenAI, env, task: str, seed: int) -> dict:
+    """Run a single episode. Returns {"score", "steps", "rewards", "success"}."""
+    history: List[str] = []
+    rewards: List[float] = []
+    errors_seen: List[str] = []   # accumulated distinct errors
+    files_read: dict = {}         # filename → last known content
+    edits_made: List[str] = []    # human-readable edit log
+    steps_taken = 0
+    max_steps = MAX_STEPS_BY_TASK.get(task, DEFAULT_MAX_STEPS)
+
+    result = await env.reset(task=task, seed=seed)
+    last_stdout = result.observation.stdout
+    pipeline_status = result.observation.pipeline_status
+
+    for step in range(1, max_steps + 1):
+        if result.done:
+            break
+
+        command = get_agent_command(
+            client, step, last_stdout, pipeline_status, history,
+            errors_seen, files_read, edits_made, max_steps=max_steps,
+        )
+        error: Optional[str] = None
+        step_stdout = ""
+        done = False
+        reward = MIN_REWARD
+        try:
+            result = await env.step(CiCdDoctorAction(command=command))
+            obs = result.observation
+            reward = result.reward #clamp(result.reward or 0.0)
+            done = result.done
+            last_stdout = obs.stdout
+            step_stdout = obs.stdout
+            pipeline_status = obs.pipeline_status
+
+            # Accumulate session context
+            cmd_lower = command.strip()
+            if cmd_lower.startswith("pipeline run"):
+                for err in _extract_errors(step_stdout):
+                    if err not in errors_seen:
+                        errors_seen.append(err)
+            elif cmd_lower.startswith("cat "):
+                fname = cmd_lower[4:].strip()
+                files_read[fname] = step_stdout
+            elif cmd_lower.startswith("echo ") or cmd_lower.startswith("sed "):
+                edits_made.append(f"Step {step}: {command}")
+
+        except Exception as exc:
+            reward = 0.01
+            done = True
+            error = f"{type(exc).__name__}: {exc}"
+
+        rewards.append(reward)
+        steps_taken = step
+        log_step(
+            step=step,
+            action=command,
+            reward=reward,
+            done=done,
+            error=error,
+        )
+        history.append(
+            f"Step {step}: {command!r} -> status={pipeline_status} reward={reward:+.2f}"
+        )
+
+        if done:
+            break
+
+    score = clamp(sum(rewards) if rewards else MIN_REWARD)
+    threshold = SUCCESS_THRESHOLDS.get(task, SUCCESS_SCORE_THRESHOLD)
+    return {"score": score, "steps": steps_taken, "rewards": rewards, "success": score >= threshold}
+
+
+async def main() -> None:
+    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    env = None
+
+    try:
+        if IMAGE_NAME:
+            env = await CiCdDoctorEnv.from_docker_image(IMAGE_NAME)
+        else:
+            base_url = os.getenv("ENV_BASE_URL", "http://localhost:8000")
+            env = CiCdDoctorEnv(base_url=base_url)
+
+        all_rewards: List[float] = []
+        all_steps = 0
+
+        for ep in EPISODES:
+            task, seed = ep["task"], ep["seed"]
+            log_start(task=task, env=BENCHMARK, model=MODEL_NAME)
+            result = await run_episode(client, env, task=task, seed=seed)
+            all_rewards.extend(result["rewards"])
+            all_steps += result["steps"]
+            log_end(
+                success=result["success"],
+                steps=result["steps"],
+                score=result["score"],
+                rewards=result["rewards"],
+            )
+
+    except Exception as exc:
+        print(f"[DEBUG] fatal error: {type(exc).__name__}: {exc}", flush=True)
+    finally:
+        if env is not None:
+            try:
+                await env.close()
+            except Exception as e:
+                print(f"[DEBUG] env.close() error: {e}", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,31 @@
+"""
+Data models for the CI/CD Doctor RL environment.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, List
+
+
+class PipelineAction(BaseModel):
+    command: str  # raw string the agent types, e.g. "cat requirements.txt"2
+
+
+class PipelineObservation(BaseModel):
+    stdout: str
+    exit_code: int
+    pipeline_status: str  # "not_run" | "running" | "passed" | "failed"
+    steps_remaining: int
+    done: bool = False
+    reward: float = 0.0
+
+
+class PipelineState(BaseModel):
+    episode_id: str
+    task: str  # "easy" | "medium" | "hard"
+    filesystem: Dict[str, str]
+    pipeline_status: str
+    step_count: int
+    done: bool
+    total_reward: float
+    answer_key: Dict[str, Any]  # never sent to agent, used by grader
+    milestones: List[str] = Field(default_factory=list)  # grader-only, tracks unlocked reward tiers

openenv.yaml

@@ -0,0 +1,61 @@
+spec_version: 1
+name: CI_CD_Doctor
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+
+tasks:
+  - id: task_easy
+    difficulty: easy
+    max_steps: 10
+    description: "Single-file failure: one required package is missing from requirements.txt. Inspect the install logs, identify the missing package, and add it."
+    grader:
+      type: programmatic
+      module: environment.grader:grade
+      success_threshold: 0.70
+      prompt_template: |
+        Score the agent's CI/CD debugging session from 0.01 to 0.99
+        Task: fix a single missing package in requirements.txt so the install stage passes.
+        Full credit (0.99) requires the pipeline to reach `passed` state.
+        Partial credit is awarded per correct fix landed in the target file.
+        Penalize redundant reads, idle pipeline re-runs, and exceeding the ideal step budget.
+
+  - id: task_medium
+    difficulty: medium
+    max_steps: 15
+    description: "Two-file cascading failure (one of four randomized variants). Each variant pairs two bugs across files such as Dockerfile (wrong Python version or port), .env.ci (missing required env var), requirements.txt (missing package), deploy_config.yml (deploy_enabled false), Makefile (wrong test command), or service.yaml (wrong port). Bugs surface one at a time across the pipeline stages — fix both to make it pass."
+    grader:
+      type: programmatic
+      module: environment.grader:grade
+      success_threshold: 0.60
+      prompt_template: |
+        Score the agent's CI/CD debugging session from 0.01 to 0.99
+        Task: diagnose and fix TWO bugs spread across two files in one of four
+        structurally distinct medium variants. Each pipeline run only reveals
+        the next failing stage — the agent must iterate discover→diagnose→fix→verify.
+        Full credit (0.99) requires the pipeline to reach `passed` state.
+        Award partial credit per fix landed in the correct file.
+        Penalize redundant reads, idle pipeline re-runs, exploitation traps
+        (knows the bug but won't act), and exceeding the ideal step budget.
+
+  - id: task_hard
+    difficulty: hard
+    max_steps: 25
+    description: "Three-file cascading failure (one of four randomized variants). Each variant chains three bugs across files such as ci.yml (wrong stage order), Dockerfile (alpine base incompatible with binary wheels), requirements.txt (missing package or wrong version pin like numpy==1.21), .env.ci (missing env var), Makefile (wrong test command), deploy_config.yml (deploy_enabled false), or service.yaml (wrong port). Each pipeline run stops at the first failing stage, so bugs reveal themselves one at a time — fix all three in sequence."
+    grader:
+      type: programmatic
+      module: environment.grader:grade
+      success_threshold: 0.45
+      prompt_template: |
+        Score the agent's CI/CD debugging session from 0.01 to 0.99
+        Task: diagnose and fix THREE cascading bugs across three files in one of
+        four hard variants. Bugs surface one at a time as earlier stages pass.
+        Some fixes require reasoning about error messages (e.g. alpine base
+        image lacks glibc for native deps; numpy==1.21 pin conflicts with
+        transitive numpy>=1.26 requirement) — exact-string matching alone is
+        insufficient.
+        Full credit (0.99) requires the pipeline to reach `passed` state.
+        Award partial credit per fix landed in the correct file.
+        Penalize redundant reads, idle pipeline re-runs, exploitation traps,
+        and exceeding the ideal step budget.

openenv_CI_CD_Doctor.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: openenv-CI_CD_Doctor
+Version: 0.1.0
+Summary: Ci Cd Doctor environment for OpenEnv
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: openenv-core[core]>=0.2.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file

openenv_CI_CD_Doctor.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+./__init__.py
+./inference.py
+environment/__init__.py
+environment/client.py
+environment/generator.py
+environment/grader.py
+environment/models.py
+environment/packages.py
+environment/parser.py
+environment/stage_runner.py
+openenv_CI_CD_Doctor.egg-info/PKG-INFO
+openenv_CI_CD_Doctor.egg-info/SOURCES.txt
+openenv_CI_CD_Doctor.egg-info/dependency_links.txt
+openenv_CI_CD_Doctor.egg-info/entry_points.txt
+openenv_CI_CD_Doctor.egg-info/requires.txt
+openenv_CI_CD_Doctor.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/environment.py

openenv_CI_CD_Doctor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_CI_CD_Doctor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = CI_CD_Doctor.server.app:main

openenv_CI_CD_Doctor.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.2
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_CI_CD_Doctor.egg-info/top_level.txt

@@ -0,0 +1 @@
+CI_CD_Doctor

pyproject.toml

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-CI_CD_Doctor"
+version = "0.1.0"
+description = "Ci Cd Doctor environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m CI_CD_Doctor.server.app
+server = "CI_CD_Doctor.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["CI_CD_Doctor", "CI_CD_Doctor.environment", "CI_CD_Doctor.server"]
+package-dir = { "CI_CD_Doctor" = ".", "CI_CD_Doctor.environment" = "environment", "CI_CD_Doctor.server" = "server" }

requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

server/__init__.py

@@ -0,0 +1,5 @@
+"""CI/CD Doctor server subpackage."""
+
+from .environment import PipelineEnvironment
+
+__all__ = ["PipelineEnvironment"]

server/app.py

@@ -0,0 +1,95 @@
+"""
+FastAPI application for the CI/CD Doctor environment.
+
+Wraps PipelineEnvironment in an OpenEnv-compatible interface so it can be
+served via openenv's create_app() infrastructure.
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+    from openenv.core.env_server.interfaces import Environment
+    from openenv.core.env_server.types import Action, Observation, State
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+from uuid import uuid4
+from pydantic import Field
+
+from models import PipelineObservation
+from .environment import PipelineEnvironment
+
+
+# OpenEnv-compatible action — wraps the agent's raw command string
+class CiCdDoctorAction(Action):
+    command: str = Field(..., description="Shell-like command the agent issues")
+
+
+# OpenEnv-compatible observation — extends base Observation with pipeline fields
+class CiCdDoctorObservation(Observation):
+    stdout: str = Field(default="", description="Command output / logs seen by agent")
+    exit_code: int = Field(default=0, description="0 = success, 1 = error")
+    pipeline_status: str = Field(default="not_run", description="not_run | running | passed | failed")
+    steps_remaining: int = Field(default=15, description="Steps left in episode")
+
+
+def _to_obs(obs: PipelineObservation) -> CiCdDoctorObservation:
+    return CiCdDoctorObservation(
+        stdout=obs.stdout,
+        exit_code=obs.exit_code,
+        pipeline_status=obs.pipeline_status,
+        steps_remaining=obs.steps_remaining,
+        done=obs.done,
+        reward=obs.reward,
+    )
+
+
+class CiCdDoctorEnvironment(Environment):
+    """OpenEnv adapter that wraps PipelineEnvironment."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._env = PipelineEnvironment()
+        self._state_obj = State(episode_id=str(uuid4()), step_count=0)
+
+    def reset(self, task: str = "easy", seed: int = 42) -> CiCdDoctorObservation:
+        obs = self._env.reset(task=task, seed=seed)
+        s = self._env.state()
+        self._state_obj = State(episode_id=s.episode_id, step_count=s.step_count)
+        return _to_obs(obs)
+
+    def step(self, action: CiCdDoctorAction) -> CiCdDoctorObservation:  # type: ignore[override]
+        from models import PipelineAction
+        obs = self._env.step(PipelineAction(command=action.command))
+        s = self._env.state()
+        self._state_obj = State(episode_id=s.episode_id, step_count=s.step_count)
+        return _to_obs(obs)
+
+    @property
+    def state(self) -> State:
+        return self._state_obj
+
+
+app = create_app(
+    CiCdDoctorEnvironment,
+    CiCdDoctorAction,
+    CiCdDoctorObservation,
+    env_name="CI_CD_Doctor",
+    max_concurrent_envs=1,
+)
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=args.port)

server/app_2.py

@@ -0,0 +1,101 @@
+import os
+from fastapi import FastAPI, Request, HTTPException
+import gradio as gr
+
+from client import CiCdDoctorEnv, CiCdDoctorAction
+from models import PipelineObservation
+
+# Optional: your existing Gradio UI
+try:
+    from app import demo
+except ImportError:
+    demo = None
+
+app = FastAPI(
+    title="CI/CD Doctor",
+    description="Self-healing CI/CD pipeline agent",
+    version="1.0.0",
+)
+
+_env = None
+
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy"}
+
+
+@app.get("/metadata")
+async def metadata():
+    return {
+        "name": "CI/CD Doctor",
+        "description": "Fix broken CI/CD pipelines autonomously",
+        "version": "1.0.0",
+        "submission_type": "openenv-v4",
+    }
+
+
+@app.get("/schema")
+async def schema():
+    return {
+        "action": CiCdDoctorAction.model_json_schema(),
+        "observation": PipelineObservation.model_json_schema(),
+        "state": {"type": "object"},
+    }
+
+
+@app.post("/reset")
+async def reset(request: Request):
+    global _env
+    try:
+        body = await request.json() if await request.body() else {}
+        task = body.get("task", "easy")
+        seed = body.get("seed", 42)
+
+        base_url = os.getenv("ENV_BASE_URL", "http://localhost:8000")
+        _env = await CiCdDoctorEnv(base_url=base_url)
+
+        result = await _env.reset(task=task, seed=seed)
+        return result.observation.model_dump()
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/step")
+async def step(request: Request):
+    global _env
+    if _env is None:
+        raise HTTPException(status_code=400, detail="Call /reset first")
+
+    try:
+        body = await request.json()
+        action = CiCdDoctorAction(**body)
+
+        result = await _env.step(action)
+        return result.observation.model_dump()
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/state")
+async def state():
+    global _env
+    if _env is None:
+        return {"status": "uninitialized"}
+    return {"status": "running"}
+
+
+# Mount Gradio UI if available
+if demo is not None:
+    app = gr.mount_gradio_app(app, demo, path="/")
+
+
+def main():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

server/environment.py

@@ -0,0 +1,199 @@
+"""
+Core RL environment for the CI/CD Doctor.
+Ties together generator, stage_runner, and parser into a step/reset/state loop.
+"""
+
+import uuid
+
+from models import PipelineAction, PipelineObservation, PipelineState
+from environment.generator import generate_easy_scenario, generate_medium_scenario, generate_hard_scenario
+from environment.stage_runner import run_pipeline
+from environment.parser import parse_command
+from environment.grader import grade as grade_state, balance_score, StepContext
+
+MAX_STEPS_BY_TASK = {"easy": 10, "medium": 15, "hard": 25}
+IDEAL_STEPS_BY_TASK = {"easy": 3, "medium": 6, "hard": 10}
+DEFAULT_MAX_STEPS = 15
+DEFAULT_IDEAL_STEPS = 6
+
+
+class PipelineEnvironment:
+
+    def reset(self, task: str = "easy", seed: int = 42) -> PipelineObservation:
+        if task == "medium":
+            scenario = generate_medium_scenario(seed)
+        elif task == "hard":
+            scenario = generate_hard_scenario(seed)
+        else:
+            scenario = generate_easy_scenario(seed)
+
+        self._filesystem = scenario["filesystem"]
+        self._answer_key = scenario["answer_key"]
+        self._task = task
+        self._max_steps = MAX_STEPS_BY_TASK.get(task, DEFAULT_MAX_STEPS)
+        self._ideal_steps = IDEAL_STEPS_BY_TASK.get(task, DEFAULT_IDEAL_STEPS)
+        self._step_count = 0
+        self._done = False
+        self._total_reward = 0.0
+        self._pipeline_status = "not_run"
+        self._episode_id = str(uuid.uuid4())
+        self._last_logs: dict = {}
+        self._milestones: set[str] = set()
+        self._files_read: set[str] = set()
+        self._fs_snapshot_at_last_run: str | None = None   # None = no run yet
+        self._pipeline_runs_since_last_edit: int = 0
+        self._last_score = grade_state(self.state())
+
+        files = ", ".join(sorted(self._filesystem.keys()))
+        return PipelineObservation(
+            stdout=(
+                "Pipeline environment ready. The pipeline is failing. "
+                f"Files: {files}. Investigate and fix it."
+            ),
+            exit_code=0,
+            pipeline_status=self._pipeline_status,
+            steps_remaining=self._max_steps,
+            done=False,
+            reward=0.0,
+        )
+
+    def step(self, action: PipelineAction) -> PipelineObservation:
+        if self._done:
+            raise RuntimeError("Episode is done. Call reset() first.")
+
+        self._step_count += 1
+        steps_remaining = self._max_steps - self._step_count
+        cmd = parse_command(action.command)
+        stdout = ""
+        exit_code = 0
+
+        if cmd.type == "cat":
+            content = self._filesystem.get(cmd.filename)
+            if content is None:
+                stdout = f"cat: {cmd.filename}: No such file or directory"
+                exit_code = 1
+            else:
+                stdout = content
+
+        elif cmd.type == "echo_append":
+            if cmd.filename in self._filesystem:
+                self._filesystem[cmd.filename] += cmd.content + "\n"
+                stdout = ""
+            else:
+                stdout = f"bash: {cmd.filename}: No such file or directory"
+                exit_code = 1
+
+        elif cmd.type == "sed":
+            if cmd.filename in self._filesystem:
+                self._filesystem[cmd.filename] = self._filesystem[cmd.filename].replace(
+                    cmd.pattern, cmd.replacement
+                )
+                stdout = ""
+            else:
+                stdout = f"sed: {cmd.filename}: No such file or directory"
+                exit_code = 1
+
+        elif cmd.type == "pipeline_run":
+            result = run_pipeline(self._filesystem, task=self._task)
+            self._last_logs["last"] = result["logs"]
+            self._filesystem["logs/install.log"] = result["logs"]
+            self._pipeline_status = "passed" if result["exit_code"] == 0 else "failed"
+            stdout = result["logs"]
+            exit_code = result["exit_code"]
+
+        elif cmd.type == "pipeline_logs":
+            if cmd.stage:
+                stdout = self._last_logs.get(
+                    cmd.stage,
+                    self._last_logs.get("last", f"No logs for stage '{cmd.stage}' yet. Run pipeline first."),
+                )
+            else:
+                stdout = self._last_logs.get("last", "No pipeline runs yet.")
+
+        elif cmd.type == "pipeline_status":
+            stdout = f"Pipeline status: {self._pipeline_status}"
+
+        else:
+            stdout = f"Command not recognized: {action.command}"
+            exit_code = 1
+
+        # Capture context BEFORE updating tracking state
+        ctx = StepContext(
+            cmd_type=cmd.type,
+            filename=getattr(cmd, "filename", None),
+            files_read=set(self._files_read),
+            fs_changed_since_last_run=(
+                self._fs_snapshot_at_last_run is None
+                or repr(self._filesystem) != self._fs_snapshot_at_last_run
+            ),
+            step_count=self._step_count,
+            max_steps=self._max_steps,
+            ideal_steps=self._ideal_steps,
+            pipeline_runs_since_last_edit=self._pipeline_runs_since_last_edit,
+        )
+
+        self._update_milestones(cmd)
+        current_score = grade_state(self.state())
+        grade_delta = round(current_score - self._last_score, 2)
+        self._last_score = current_score
+
+        shaped = balance_score(self.state(), ctx)
+        reward = round(grade_delta + shaped, 2)
+        self._total_reward += reward
+
+        if cmd.type == "cat" and exit_code == 0 and cmd.filename:
+            self._files_read.add(cmd.filename)
+        if cmd.type in ("echo_append", "sed") and exit_code == 0:
+            self._pipeline_runs_since_last_edit = 0
+        if cmd.type == "pipeline_run":
+            self._pipeline_runs_since_last_edit += 1
+            self._fs_snapshot_at_last_run = repr(self._filesystem)
+
+        if self._pipeline_status == "passed" or steps_remaining <= 0:
+            self._done = True
+
+        return PipelineObservation(
+            stdout=stdout,
+            exit_code=exit_code,
+            pipeline_status=self._pipeline_status,
+            steps_remaining=max(0, steps_remaining),
+            done=self._done,
+            reward=reward,
+        )
+
+    def state(self) -> PipelineState:
+        return PipelineState(
+            episode_id=self._episode_id,
+            task=self._task,
+            filesystem=dict(self._filesystem),
+            pipeline_status=self._pipeline_status,
+            step_count=self._step_count,
+            done=self._done,
+            total_reward=self._total_reward,
+            answer_key=self._answer_key,
+            milestones=sorted(self._milestones),
+        )
+
+    def _update_milestones(self, cmd) -> None:
+        """Mark reward tiers unlocked by this step. Each tier fires once."""
+        if cmd.type == "pipeline_run":
+            self._milestones.add("investigated")
+
+        is_log_read = cmd.type == "pipeline_logs" or (
+            cmd.type == "cat" and cmd.filename == "logs/install.log"
+        )
+        if is_log_read and self._pipeline_status == "failed":
+            self._milestones.add("logs_read")
+
+        fix_files = set(self._answer_key.get("fixes", {}).keys())
+        if cmd.type == "cat" and cmd.filename in fix_files:
+            self._milestones.add("correct_file_located")
+
+    def _grade(self) -> tuple[float, bool]:
+        """
+        Delegate to the unified grader. Same rule for every task difficulty.
+        Episode ends only when the pipeline has passed.
+        """
+        score = grade_state(self.state())
+        done = self._pipeline_status == "passed"
+        return score, done

venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

venv/bin/activate

@@ -0,0 +1,71 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then
+    # transform D:\path\to\venv to /d/path/to/venv on MSYS
+    # and to /cygdrive/d/path/to/venv on Cygwin
+    export VIRTUAL_ENV=$(cygpath /Users/samratrm/workspace/CI_CD_Doctor/venv)
+else
+    # use the path as-is
+    export VIRTUAL_ENV=/Users/samratrm/workspace/CI_CD_Doctor/venv
+fi
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1='(venv) '"${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT='(venv) '
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

venv/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /Users/samratrm/workspace/CI_CD_Doctor/venv
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = '(venv) '"$prompt"
+    setenv VIRTUAL_ENV_PROMPT '(venv) '
+endif
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /Users/samratrm/workspace/CI_CD_Doctor/venv
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) '(venv) ' (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT '(venv) '
+end

venv/bin/pip

@@ -0,0 +1,8 @@
+#!/Users/samratrm/workspace/CI_CD_Doctor/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3

@@ -0,0 +1,8 @@
+#!/Users/samratrm/workspace/CI_CD_Doctor/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip3.12

@@ -0,0 +1,8 @@
+#!/Users/samratrm/workspace/CI_CD_Doctor/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/python

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b379bc0cd9cb75642c74b3e1ca139631b9414cc8af307feb70bf5652d14e41d7
+size 6592880

venv/bin/python3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b379bc0cd9cb75642c74b3e1ca139631b9414cc8af307feb70bf5652d14e41d7
+size 6592880

venv/bin/python3.12

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b379bc0cd9cb75642c74b3e1ca139631b9414cc8af307feb70bf5652d14e41d7
+size 6592880

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/AUTHORS.txt

@@ -0,0 +1,799 @@
+@Switch01
+A_Rog
+Aakanksha Agrawal
+Abhinav Sagar
+ABHYUDAY PRATAP SINGH
+abs51295
+AceGentile
+Adam Chainz
+Adam Tse
+Adam Wentz
+admin
+Adolfo Ochagavía
+Adrien Morison
+Agus
+ahayrapetyan
+Ahilya
+AinsworthK
+Akash Srivastava
+Alan Yee
+Albert Tugushev
+Albert-Guan
+albertg
+Alberto Sottile
+Aleks Bunin
+Ales Erjavec
+Alethea Flowers
+Alex Gaynor
+Alex Grönholm
+Alex Hedges
+Alex Loosley
+Alex Morega
+Alex Stachowiak
+Alexander Shtyrov
+Alexandre Conrad
+Alexey Popravka
+Aleš Erjavec
+Alli
+Ami Fischman
+Ananya Maiti
+Anatoly Techtonik
+Anders Kaseorg
+Andre Aguiar
+Andreas Lutro
+Andrei Geacar
+Andrew Gaul
+Andrew Shymanel
+Andrey Bienkowski
+Andrey Bulgakov
+Andrés Delfino
+Andy Freeland
+Andy Kluger
+Ani Hayrapetyan
+Aniruddha Basak
+Anish Tambe
+Anrs Hu
+Anthony Sottile
+Antoine Musso
+Anton Ovchinnikov
+Anton Patrushev
+Anton Zelenov
+Antonio Alvarado Hernandez
+Antony Lee
+Antti Kaihola
+Anubhav Patel
+Anudit Nagar
+Anuj Godase
+AQNOUCH Mohammed
+AraHaan
+arena
+arenasys
+Arindam Choudhury
+Armin Ronacher
+Arnon Yaari
+Artem
+Arun Babu Neelicattu
+Ashley Manton
+Ashwin Ramaswami
+atse
+Atsushi Odagiri
+Avinash Karhana
+Avner Cohen
+Awit (Ah-Wit) Ghirmai
+Baptiste Mispelon
+Barney Gale
+barneygale
+Bartek Ogryczak
+Bastian Venthur
+Ben Bodenmiller
+Ben Darnell
+Ben Hoyt
+Ben Mares
+Ben Rosser
+Bence Nagy
+Benjamin Peterson
+Benjamin VanEvery
+Benoit Pierre
+Berker Peksag
+Bernard
+Bernard Tyers
+Bernardo B. Marques
+Bernhard M. Wiedemann
+Bertil Hatt
+Bhavam Vidyarthi
+Blazej Michalik
+Bogdan Opanchuk
+BorisZZZ
+Brad Erickson
+Bradley Ayers
+Branch Vincent
+Brandon L. Reiss
+Brandt Bucher
+Brannon Dorsey
+Brett Randall
+Brett Rosen
+Brian Cristante
+Brian Rosner
+briantracy
+BrownTruck
+Bruno Oliveira
+Bruno Renié
+Bruno S
+Bstrdsmkr
+Buck Golemon
+burrows
+Bussonnier Matthias
+bwoodsend
+c22
+Caleb Martinez
+Calvin Smith
+Carl Meyer
+Carlos Liam
+Carol Willing
+Carter Thayer
+Cass
+Chandrasekhar Atina
+Charlie Marsh
+Chih-Hsuan Yen
+Chris Brinker
+Chris Hunt
+Chris Jerdonek
+Chris Kuehl
+Chris Markiewicz
+Chris McDonough
+Chris Pawley
+Chris Pryer
+Chris Wolfe
+Christian Clauss
+Christian Heimes
+Christian Oudard
+Christoph Reiter
+Christopher Hunt
+Christopher Snyder
+chrysle
+cjc7373
+Clark Boylan
+Claudio Jolowicz
+Clay McClure
+Cody
+Cody Soyland
+Colin Watson
+Collin Anderson
+Connor Osborn
+Cooper Lees
+Cooper Ry Lees
+Cory Benfield
+Cory Wright
+Craig Kerstiens
+Cristian Sorinel
+Cristina
+Cristina Muñoz
+ctg123
+Curtis Doty
+cytolentino
+Daan De Meyer
+Dale
+Damian
+Damian Quiroga
+Damian Shaw
+Dan Black
+Dan Savilonis
+Dan Sully
+Dane Hillard
+daniel
+Daniel Collins
+Daniel Hahler
+Daniel Holth
+Daniel Jost
+Daniel Katz
+Daniel Shaulov
+Daniele Esposti
+Daniele Nicolodi
+Daniele Procida
+Daniil Konovalenko
+Danny Hermes
+Danny McClanahan
+Darren Kavanagh
+Dav Clark
+Dave Abrahams
+Dave Jones
+David Aguilar
+David Black
+David Bordeynik
+David Caro
+David D Lowe
+David Evans
+David Hewitt
+David Linke
+David Poggi
+David Poznik
+David Pursehouse
+David Runge
+David Tucker
+David Wales
+Davidovich
+ddelange
+Deepak Sharma
+Deepyaman Datta
+Denise Yu
+dependabot[bot]
+derwolfe
+Desetude
+Devesh Kumar Singh
+devsagul
+Diego Caraballo
+Diego Ramirez
+DiegoCaraballo
+Dimitri Merejkowsky
+Dimitri Papadopoulos
+Dimitri Papadopoulos Orfanos
+Dirk Stolle
+Dmitry Gladkov
+Dmitry Volodin
+Domen Kožar
+Dominic Davis-Foster
+Donald Stufft
+Dongweiming
+doron zarhi
+Dos Moonen
+Douglas Thor
+DrFeathers
+Dustin Ingram
+Dustin Rodrigues
+Dwayne Bailey
+Ed Morley
+Edgar Ramírez
+Edgar Ramírez Mondragón
+Ee Durbin
+Efflam Lemaillet
+efflamlemaillet
+Eitan Adler
+ekristina
+elainechan
+Eli Schwartz
+Elisha Hollander
+Ellen Marie Dash
+Emil Burzo
+Emil Styrke
+Emmanuel Arias
+Endoh Takanao
+enoch
+Erdinc Mutlu
+Eric Cousineau
+Eric Gillingham
+Eric Hanchrow
+Eric Hopper
+Erik M. Bray
+Erik Rose
+Erwin Janssen
+Eugene Vereshchagin
+everdimension
+Federico
+Felipe Peter
+Felix Yan
+fiber-space
+Filip Kokosiński
+Filipe Laíns
+Finn Womack
+finnagin
+Flavio Amurrio
+Florian Briand
+Florian Rathgeber
+Francesco
+Francesco Montesano
+Fredrik Orderud
+Frost Ming
+Gabriel Curio
+Gabriel de Perthuis
+Garry Polley
+gavin
+gdanielson
+Geoffrey Sneddon
+George Song
+Georgi Valkov
+Georgy Pchelkin
+ghost
+Giftlin Rajaiah
+gizmoguy1
+gkdoc
+Godefroid Chapelle
+Gopinath M
+GOTO Hayato
+gousaiyang
+gpiks
+Greg Roodt
+Greg Ward
+Guilherme Espada
+Guillaume Seguin
+gutsytechster
+Guy Rozendorn
+Guy Tuval
+gzpan123
+Hanjun Kim
+Hari Charan
+Harsh Vardhan
+harupy
+Harutaka Kawamura
+hauntsaninja
+Henrich Hartzer
+Henry Schreiner
+Herbert Pfennig
+Holly Stotelmyer
+Honnix
+Hsiaoming Yang
+Hugo Lopes Tavares
+Hugo van Kemenade
+Hugues Bruant
+Hynek Schlawack
+Ian Bicking
+Ian Cordasco
+Ian Lee
+Ian Stapleton Cordasco
+Ian Wienand
+Igor Kuzmitshov
+Igor Sobreira
+Ikko Ashimine
+Ilan Schnell
+Illia Volochii
+Ilya Baryshev
+Inada Naoki
+Ionel Cristian Mărieș
+Ionel Maries Cristian
+Itamar Turner-Trauring
+Ivan Pozdeev
+J. Nick Koston
+Jacob Kim
+Jacob Walls
+Jaime Sanz
+jakirkham
+Jakub Kuczys
+Jakub Stasiak
+Jakub Vysoky
+Jakub Wilk
+James Cleveland
+James Curtin
+James Firth
+James Gerity
+James Polley
+Jan Pokorný
+Jannis Leidel
+Jarek Potiuk
+jarondl
+Jason Curtis
+Jason R. Coombs
+JasonMo
+JasonMo1
+Jay Graves
+Jean Abou Samra
+Jean-Christophe Fillion-Robin
+Jeff Barber
+Jeff Dairiki
+Jeff Widman
+Jelmer Vernooij
+jenix21
+Jeremy Fleischman
+Jeremy Stanley
+Jeremy Zafran
+Jesse Rittner
+Jiashuo Li
+Jim Fisher
+Jim Garrison
+Jinzhe Zeng
+Jiun Bae
+Jivan Amara
+Joe Bylund
+Joe Michelini
+John Paton
+John Sirois
+John T. Wodder II
+John-Scott Atlakson
+johnthagen
+Jon Banafato
+Jon Dufresne
+Jon Parise
+Jonas Nockert
+Jonathan Herbert
+Joonatan Partanen
+Joost Molenaar
+Jorge Niedbalski
+Joseph Bylund
+Joseph Long
+Josh Bronson
+Josh Cannon
+Josh Hansen
+Josh Schneier
+Joshua
+Juan Luis Cano Rodríguez
+Juanjo Bazán
+Judah Rand
+Julian Berman
+Julian Gethmann
+Julien Demoor
+Jussi Kukkonen
+jwg4
+Jyrki Pulliainen
+Kai Chen
+Kai Mueller
+Kamal Bin Mustafa
+kasium
+kaustav haldar
+keanemind
+Keith Maxwell
+Kelsey Hightower
+Kenneth Belitzky
+Kenneth Reitz
+Kevin Burke
+Kevin Carter
+Kevin Frommelt
+Kevin R Patterson
+Kexuan Sun
+Kit Randel
+Klaas van Schelven
+KOLANICH
+konstin
+kpinc
+Krishna Oza
+Kumar McMillan
+Kuntal Majumder
+Kurt McKee
+Kyle Persohn
+lakshmanaram
+Laszlo Kiss-Kollar
+Laurent Bristiel
+Laurent LAPORTE
+Laurie O
+Laurie Opperman
+layday
+Leon Sasson
+Lev Givon
+Lincoln de Sousa
+Lipis
+lorddavidiii
+Loren Carvalho
+Lucas Cimon
+Ludovic Gasc
+Luis Medel
+Lukas Geiger
+Lukas Juhrich
+Luke Macken
+Luo Jiebin
+luojiebin
+luz.paz
+László Kiss Kollár
+M00nL1ght
+Marc Abramowitz
+Marc Tamlyn
+Marcus Smith
+Mariatta
+Mark Kohler
+Mark McLoughlin
+Mark Williams
+Markus Hametner
+Martey Dodoo
+Martin Fischer
+Martin Häcker
+Martin Pavlasek
+Masaki
+Masklinn
+Matej Stuchlik
+Mathew Jennings
+Mathieu Bridon
+Mathieu Kniewallner
+Matt Bacchi
+Matt Good
+Matt Maker
+Matt Robenolt
+Matt Wozniski
+matthew
+Matthew Einhorn
+Matthew Feickert
+Matthew Gilliard
+Matthew Hughes
+Matthew Iversen
+Matthew Treinish
+Matthew Trumbell
+Matthew Willson
+Matthias Bussonnier
+mattip
+Maurits van Rees
+Max W Chase
+Maxim Kurnikov
+Maxime Rouyrre
+mayeut
+mbaluna
+mdebi
+memoselyk
+meowmeowcat
+Michael
+Michael Aquilina
+Michael E. Karpeles
+Michael Klich
+Michael Mintz
+Michael Williamson
+michaelpacer
+Michał Górny
+Mickaël Schoentgen
+Miguel Araujo Perez
+Mihir Singh
+Mike
+Mike Hendricks
+Min RK
+MinRK
+Miro Hrončok
+Monica Baluna
+montefra
+Monty Taylor
+morotti
+mrKazzila
+Muha Ajjan
+Nadav Wexler
+Nahuel Ambrosini
+Nate Coraor
+Nate Prewitt
+Nathan Houghton
+Nathaniel J. Smith
+Nehal J Wani
+Neil Botelho
+Nguyễn Gia Phong
+Nicholas Serra
+Nick Coghlan
+Nick Stenning
+Nick Timkovich
+Nicolas Bock
+Nicole Harris
+Nikhil Benesch
+Nikhil Ladha
+Nikita Chepanov
+Nikolay Korolev
+Nipunn Koorapati
+Nitesh Sharma
+Niyas Sait
+Noah
+Noah Gorny
+Nowell Strite
+NtaleGrey
+nvdv
+OBITORASU
+Ofek Lev
+ofrinevo
+Oliver Freund
+Oliver Jeeves
+Oliver Mannion
+Oliver Tonnhofer
+Olivier Girardot
+Olivier Grisel
+Ollie Rutherfurd
+OMOTO Kenji
+Omry Yadan
+onlinejudge95
+Oren Held
+Oscar Benjamin
+Oz N Tiram
+Pachwenko
+Patrick Dubroy
+Patrick Jenkins
+Patrick Lawson
+patricktokeeffe
+Patrik Kopkan
+Paul Ganssle
+Paul Kehrer
+Paul Moore
+Paul Nasrat
+Paul Oswald
+Paul van der Linden
+Paulus Schoutsen
+Pavel Safronov
+Pavithra Eswaramoorthy
+Pawel Jasinski
+Paweł Szramowski
+Pekka Klärck
+Peter Gessler
+Peter Lisák
+Peter Shen
+Peter Waller
+Petr Viktorin
+petr-tik
+Phaneendra Chiruvella
+Phil Elson
+Phil Freo
+Phil Pennock
+Phil Whelan
+Philip Jägenstedt
+Philip Molloy
+Philippe Ombredanne
+Pi Delport
+Pierre-Yves Rofes
+Pieter Degroote
+pip
+Prabakaran Kumaresshan
+Prabhjyotsing Surjit Singh Sodhi
+Prabhu Marappan
+Pradyun Gedam
+Prashant Sharma
+Pratik Mallya
+pre-commit-ci[bot]
+Preet Thakkar
+Preston Holmes
+Przemek Wrzos
+Pulkit Goyal
+q0w
+Qiangning Hong
+Qiming Xu
+Quentin Lee
+Quentin Pradet
+R. David Murray
+Rafael Caricio
+Ralf Schmitt
+Ran Benita
+Razzi Abuissa
+rdb
+Reece Dunham
+Remi Rampin
+Rene Dudfield
+Riccardo Magliocchetti
+Riccardo Schirone
+Richard Jones
+Richard Si
+Ricky Ng-Adam
+Rishi
+rmorotti
+RobberPhex
+Robert Collins
+Robert McGibbon
+Robert Pollak
+Robert T. McGibbon
+robin elisha robinson
+Roey Berman
+Rohan Jain
+Roman Bogorodskiy
+Roman Donchenko
+Romuald Brunet
+ronaudinho
+Ronny Pfannschmidt
+Rory McCann
+Ross Brattain
+Roy Wellington Ⅳ
+Ruairidh MacLeod
+Russell Keith-Magee
+Ryan Shepherd
+Ryan Wooden
+ryneeverett
+S. Guliaev
+Sachi King
+Salvatore Rinchiera
+sandeepkiran-js
+Sander Van Balen
+Savio Jomton
+schlamar
+Scott Kitterman
+Sean
+seanj
+Sebastian Jordan
+Sebastian Schaetz
+Segev Finer
+SeongSoo Cho
+Sergey Vasilyev
+Seth Michael Larson
+Seth Woodworth
+Shahar Epstein
+Shantanu
+shenxianpeng
+shireenrao
+Shivansh-007
+Shixian Sheng
+Shlomi Fish
+Shovan Maity
+Simeon Visser
+Simon Cross
+Simon Pichugin
+sinoroc
+sinscary
+snook92
+socketubs
+Sorin Sbarnea
+Srinivas Nyayapati
+Srishti Hegde
+Stavros Korokithakis
+Stefan Scherfke
+Stefano Rivera
+Stephan Erb
+Stephen Rosen
+stepshal
+Steve (Gadget) Barnes
+Steve Barnes
+Steve Dower
+Steve Kowalik
+Steven Myint
+Steven Silvester
+stonebig
+studioj
+Stéphane Bidoul
+Stéphane Bidoul (ACSONE)
+Stéphane Klein
+Sumana Harihareswara
+Surbhi Sharma
+Sviatoslav Sydorenko
+Sviatoslav Sydorenko (Святослав Сидоренко)
+Swat009
+Sylvain
+Takayuki SHIMIZUKAWA
+Taneli Hukkinen
+tbeswick
+Thiago
+Thijs Triemstra
+Thomas Fenzl
+Thomas Grainger
+Thomas Guettler
+Thomas Johansson
+Thomas Kluyver
+Thomas Smith
+Thomas VINCENT
+Tim D. Smith
+Tim Gates
+Tim Harder
+Tim Heap
+tim smith
+tinruufu
+Tobias Hermann
+Tom Forbes
+Tom Freudenheim
+Tom V
+Tomas Hrnciar
+Tomas Orsava
+Tomer Chachamu
+Tommi Enenkel | AnB
+Tomáš Hrnčiar
+Tony Beswick
+Tony Narlock
+Tony Zhaocheng Tan
+TonyBeswick
+toonarmycaptain
+Toshio Kuratomi
+toxinu
+Travis Swicegood
+Tushar Sadhwani
+Tzu-ping Chung
+Valentin Haenel
+Victor Stinner
+victorvpaulo
+Vikram - Google
+Viktor Szépe
+Ville Skyttä
+Vinay Sajip
+Vincent Philippon
+Vinicyus Macedo
+Vipul Kumar
+Vitaly Babiy
+Vladimir Fokow
+Vladimir Rutsky
+W. Trevor King
+Wil Tan
+Wilfred Hughes
+William Edwards
+William ML Leslie
+William T Olson
+William Woodruff
+Wilson Mo
+wim glenn
+Winson Luk
+Wolfgang Maier
+Wu Zhenyu
+XAMES3
+Xavier Fernandez
+Xianpeng Shen
+xoviat
+xtreak
+YAMAMOTO Takashi
+Yen Chi Hsuan
+Yeray Diaz Diaz
+Yoval P
+Yu Jian
+Yuan Jing Vincent Yan
+Yusuke Hayashi
+Zearin
+Zhiping Deng
+ziebam
+Zvezdan Petkovic
+Łukasz Langa
+Роман Донченко
+Семён Марьясин

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-present The pip developers (see AUTHORS.txt file)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: pip
+Version: 24.3.1
+Summary: The PyPA recommended tool for installing Python packages.
+Author-email: The pip developers <distutils-sig@python.org>
+License: MIT
+Project-URL: Homepage, https://pip.pypa.io/
+Project-URL: Documentation, https://pip.pypa.io
+Project-URL: Source, https://github.com/pypa/pip
+Project-URL: Changelog, https://pip.pypa.io/en/stable/news/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+License-File: AUTHORS.txt
+
+pip - The Python Package Installer
+==================================
+
+.. |pypi-version| image:: https://img.shields.io/pypi/v/pip.svg
+   :target: https://pypi.org/project/pip/
+   :alt: PyPI
+
+.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pip
+   :target: https://pypi.org/project/pip
+   :alt: PyPI - Python Version
+
+.. |docs-badge| image:: https://readthedocs.org/projects/pip/badge/?version=latest
+   :target: https://pip.pypa.io/en/latest
+   :alt: Documentation
+
+|pypi-version| |python-versions| |docs-badge|
+
+pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
+
+Please take a look at our documentation for how to install and use pip:
+
+* `Installation`_
+* `Usage`_
+
+We release updates regularly, with a new version every 3 months. Find more details in our documentation:
+
+* `Release notes`_
+* `Release process`_
+
+If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
+
+* `Issue tracking`_
+* `Discourse channel`_
+* `User IRC`_
+
+If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
+
+* `GitHub page`_
+* `Development documentation`_
+* `Development IRC`_
+
+Code of Conduct
+---------------
+
+Everyone interacting in the pip project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _package installer: https://packaging.python.org/guides/tool-recommendations/
+.. _Python Package Index: https://pypi.org
+.. _Installation: https://pip.pypa.io/en/stable/installation/
+.. _Usage: https://pip.pypa.io/en/stable/
+.. _Release notes: https://pip.pypa.io/en/stable/news.html
+.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
+.. _GitHub page: https://github.com/pypa/pip
+.. _Development documentation: https://pip.pypa.io/en/latest/development
+.. _Issue tracking: https://github.com/pypa/pip/issues
+.. _Discourse channel: https://discuss.python.org/c/packaging
+.. _User IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa
+.. _Development IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa-dev
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/RECORD

@@ -0,0 +1,853 @@
+../../../bin/pip,sha256=-GAEslaMUmzRvnu-5P-uZ9Y9RYbZJJs3TaMHZj_bRUw,259
+../../../bin/pip3,sha256=-GAEslaMUmzRvnu-5P-uZ9Y9RYbZJJs3TaMHZj_bRUw,259
+../../../bin/pip3.12,sha256=-GAEslaMUmzRvnu-5P-uZ9Y9RYbZJJs3TaMHZj_bRUw,259
+pip-24.3.1.dist-info/AUTHORS.txt,sha256=Cbb630k8EL9FkBzX9Vpi6hpYWrLSlh08eXodL5u0eLI,10925
+pip-24.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip-24.3.1.dist-info/LICENSE.txt,sha256=Y0MApmnUmurmWxLGxIySTFGkzfPR_whtw0VtyLyqIQQ,1093
+pip-24.3.1.dist-info/METADATA,sha256=V8iCNK1GYbC82PWsLMsASDh9AO4veocRlM4Pn9q2KFI,3677
+pip-24.3.1.dist-info/RECORD,,
+pip-24.3.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip-24.3.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+pip-24.3.1.dist-info/entry_points.txt,sha256=eeIjuzfnfR2PrhbjnbzFU6MnSS70kZLxwaHHq6M-bD0,87
+pip-24.3.1.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip/__init__.py,sha256=faXY_neeYrA_88plEhkyhwAaYeds7wu5U1iGwP24J0s,357
+pip/__main__.py,sha256=WzbhHXTbSE6gBY19mNN9m4s5o_365LOvTYSgqgbdBhE,854
+pip/__pip-runner__.py,sha256=cPPWuJ6NK_k-GzfvlejLFgwzmYUROmpAR6QC3Q-vkXQ,1450
+pip/__pycache__/__init__.cpython-312.pyc,,
+pip/__pycache__/__main__.cpython-312.pyc,,
+pip/__pycache__/__pip-runner__.cpython-312.pyc,,
+pip/_internal/__init__.py,sha256=MfcoOluDZ8QMCFYal04IqOJ9q6m2V7a0aOsnI-WOxUo,513
+pip/_internal/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/__pycache__/build_env.cpython-312.pyc,,
+pip/_internal/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/__pycache__/configuration.cpython-312.pyc,,
+pip/_internal/__pycache__/exceptions.cpython-312.pyc,,
+pip/_internal/__pycache__/main.cpython-312.pyc,,
+pip/_internal/__pycache__/pyproject.cpython-312.pyc,,
+pip/_internal/__pycache__/self_outdated_check.cpython-312.pyc,,
+pip/_internal/__pycache__/wheel_builder.cpython-312.pyc,,
+pip/_internal/build_env.py,sha256=wsTPOWyPTKvUREUcO585OU01kbQufpdigY8fVHv3WIw,10584
+pip/_internal/cache.py,sha256=Jb698p5PNigRtpW5o26wQNkkUv4MnQ94mc471wL63A0,10369
+pip/_internal/cli/__init__.py,sha256=FkHBgpxxb-_gd6r1FjnNhfMOzAUYyXoXKJ6abijfcFU,132
+pip/_internal/cli/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/autocompletion.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/base_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/cmdoptions.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/command_context.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/index_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/main.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/main_parser.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/parser.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/progress_bars.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/req_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/spinners.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/status_codes.cpython-312.pyc,,
+pip/_internal/cli/autocompletion.py,sha256=Lli3Mr6aDNu7ZkJJFFvwD2-hFxNI6Avz8OwMyS5TVrs,6865
+pip/_internal/cli/base_command.py,sha256=F8nUcSM-Y-MQljJUe724-yxmc5viFXHyM_zH70NmIh4,8289
+pip/_internal/cli/cmdoptions.py,sha256=mDqBr0d0hoztbRJs-PWtcKpqNAc7khU6ZpoesZKocT8,30110
+pip/_internal/cli/command_context.py,sha256=RHgIPwtObh5KhMrd3YZTkl8zbVG-6Okml7YbFX4Ehg0,774
+pip/_internal/cli/index_command.py,sha256=-0oPTruZGkLSMrWDleZ6UtcKP3G-SImRRuhH0RfVE3o,5631
+pip/_internal/cli/main.py,sha256=BDZef-bWe9g9Jpr4OVs4dDf-845HJsKw835T7AqEnAc,2817
+pip/_internal/cli/main_parser.py,sha256=laDpsuBDl6kyfywp9eMMA9s84jfH2TJJn-vmL0GG90w,4338
+pip/_internal/cli/parser.py,sha256=VCMtduzECUV87KaHNu-xJ-wLNL82yT3x16V4XBxOAqI,10825
+pip/_internal/cli/progress_bars.py,sha256=VgydyqjZvfhqpuNcFDn00QNuA9GxRe9CKrRG8jhPuKU,2723
+pip/_internal/cli/req_command.py,sha256=DqeFhmUMs6o6Ev8qawAcOoYNdAZsfyKS0MZI5jsJYwQ,12250
+pip/_internal/cli/spinners.py,sha256=hIJ83GerdFgFCdobIA23Jggetegl_uC4Sp586nzFbPE,5118
+pip/_internal/cli/status_codes.py,sha256=sEFHUaUJbqv8iArL3HAtcztWZmGOFX01hTesSytDEh0,116
+pip/_internal/commands/__init__.py,sha256=5oRO9O3dM2vGuh0bFw4HOVletryrz5HHMmmPWwJrH9U,3882
+pip/_internal/commands/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/check.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/completion.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/configuration.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/debug.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/download.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/freeze.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/hash.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/help.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/index.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/inspect.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/install.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/list.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/search.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/show.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/uninstall.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/commands/cache.py,sha256=xg76_ZFEBC6zoQ3gXLRfMZJft4z2a0RwH4GEFZC6nnU,7944
+pip/_internal/commands/check.py,sha256=Hr_4eiMd9cgVDgEvjtIdw915NmL7ROIWW8enkr8slPQ,2268
+pip/_internal/commands/completion.py,sha256=HT4lD0bgsflHq2IDgYfiEdp7IGGtE7s6MgI3xn0VQEw,4287
+pip/_internal/commands/configuration.py,sha256=n98enwp6y0b5G6fiRQjaZo43FlJKYve_daMhN-4BRNc,9766
+pip/_internal/commands/debug.py,sha256=DNDRgE9YsKrbYzU0s3VKi8rHtKF4X13CJ_br_8PUXO0,6797
+pip/_internal/commands/download.py,sha256=0qB0nys6ZEPsog451lDsjL5Bx7Z97t-B80oFZKhpzKM,5273
+pip/_internal/commands/freeze.py,sha256=2Vt72BYTSm9rzue6d8dNzt8idxWK4Db6Hd-anq7GQ80,3203
+pip/_internal/commands/hash.py,sha256=EVVOuvGtoPEdFi8SNnmdqlCQrhCxV-kJsdwtdcCnXGQ,1703
+pip/_internal/commands/help.py,sha256=gcc6QDkcgHMOuAn5UxaZwAStsRBrnGSn_yxjS57JIoM,1132
+pip/_internal/commands/index.py,sha256=RAXxmJwFhVb5S1BYzb5ifX3sn9Na8v2CCVYwSMP8pao,4731
+pip/_internal/commands/inspect.py,sha256=PGrY9TRTRCM3y5Ml8Bdk8DEOXquWRfscr4DRo1LOTPc,3189
+pip/_internal/commands/install.py,sha256=iqesiLIZc6Op9uihMQFYRhAA2DQRZUxbM4z1BwXoFls,29428
+pip/_internal/commands/list.py,sha256=oiIzSjLP6__d7dIS3q0Xb5ywsaOThBWRqMyjjKzkPdM,12769
+pip/_internal/commands/search.py,sha256=fWkUQVx_gm8ebbFAlCgqtxKXT9rNahpJ-BI__3HNZpg,5626
+pip/_internal/commands/show.py,sha256=IG9L5uo8w6UA4tI_IlmaxLCoNKPa5JNJCljj3NWs0OE,7507
+pip/_internal/commands/uninstall.py,sha256=7pOR7enK76gimyxQbzxcG1OsyLXL3DvX939xmM8Fvtg,3892
+pip/_internal/commands/wheel.py,sha256=eJRhr_qoNNxWAkkdJCNiQM7CXd4E1_YyQhsqJnBPGGg,6414
+pip/_internal/configuration.py,sha256=XkAiBS0hpzsM-LF0Qu5hvPWO_Bs67-oQKRYFBuMbESs,14006
+pip/_internal/distributions/__init__.py,sha256=Hq6kt6gXBgjNit5hTTWLAzeCNOKoB-N0pGYSqehrli8,858
+pip/_internal/distributions/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/base.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/installed.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/sdist.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/distributions/base.py,sha256=QeB9qvKXDIjLdPBDE5fMgpfGqMMCr-govnuoQnGuiF8,1783
+pip/_internal/distributions/installed.py,sha256=QinHFbWAQ8oE0pbD8MFZWkwlnfU1QYTccA1vnhrlYOU,842
+pip/_internal/distributions/sdist.py,sha256=PlcP4a6-R6c98XnOM-b6Lkb3rsvh9iG4ok8shaanrzs,6751
+pip/_internal/distributions/wheel.py,sha256=THBYfnv7VVt8mYhMYUtH13S1E7FDwtDyDfmUcl8ai0E,1317
+pip/_internal/exceptions.py,sha256=2_byISIv3kSnI_9T-Esfxrt0LnTRgcUHyxu0twsHjQY,26481
+pip/_internal/index/__init__.py,sha256=vpt-JeTZefh8a-FC22ZeBSXFVbuBcXSGiILhQZJaNpQ,30
+pip/_internal/index/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/index/__pycache__/collector.cpython-312.pyc,,
+pip/_internal/index/__pycache__/package_finder.cpython-312.pyc,,
+pip/_internal/index/__pycache__/sources.cpython-312.pyc,,
+pip/_internal/index/collector.py,sha256=RdPO0JLAlmyBWPAWYHPyRoGjz3GNAeTngCNkbGey_mE,16265
+pip/_internal/index/package_finder.py,sha256=yRC4xsyudwKnNoU6IXvNoyqYo5ScT7lB6Wa-z2eh7cs,37666
+pip/_internal/index/sources.py,sha256=lPBLK5Xiy8Q6IQMio26Wl7ocfZOKkgGklIBNyUJ23fI,8632
+pip/_internal/locations/__init__.py,sha256=UaAxeZ_f93FyouuFf4p7SXYF-4WstXuEvd3LbmPCAno,14925
+pip/_internal/locations/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/_distutils.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/_sysconfig.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/base.cpython-312.pyc,,
+pip/_internal/locations/_distutils.py,sha256=x6nyVLj7X11Y4khIdf-mFlxMl2FWadtVEgeb8upc_WI,6013
+pip/_internal/locations/_sysconfig.py,sha256=IGzds60qsFneRogC-oeBaY7bEh3lPt_v47kMJChQXsU,7724
+pip/_internal/locations/base.py,sha256=RQiPi1d4FVM2Bxk04dQhXZ2PqkeljEL2fZZ9SYqIQ78,2556
+pip/_internal/main.py,sha256=r-UnUe8HLo5XFJz8inTcOOTiu_sxNhgHb6VwlGUllOI,340
+pip/_internal/metadata/__init__.py,sha256=9pU3W3s-6HtjFuYhWcLTYVmSaziklPv7k2x8p7X1GmA,4339
+pip/_internal/metadata/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/_json.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/base.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/pkg_resources.cpython-312.pyc,,
+pip/_internal/metadata/_json.py,sha256=P0cAJrH_mtmMZvlZ16ZXm_-izA4lpr5wy08laICuiaA,2644
+pip/_internal/metadata/base.py,sha256=ft0K5XNgI4ETqZnRv2-CtvgYiMOMAeGMAzxT-f6VLJA,25298
+pip/_internal/metadata/importlib/__init__.py,sha256=jUUidoxnHcfITHHaAWG1G2i5fdBYklv_uJcjo2x7VYE,135
+pip/_internal/metadata/importlib/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_compat.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_dists.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_envs.cpython-312.pyc,,
+pip/_internal/metadata/importlib/_compat.py,sha256=c6av8sP8BBjAZuFSJow1iWfygUXNM3xRTCn5nqw6B9M,2796
+pip/_internal/metadata/importlib/_dists.py,sha256=anh0mLI-FYRPUhAdipd0Va3YJJc6HelCKQ0bFhY10a0,8017
+pip/_internal/metadata/importlib/_envs.py,sha256=UUB980XSrDWrMpQ1_G45i0r8Hqlg_tg3IPQ63mEqbNc,7431
+pip/_internal/metadata/pkg_resources.py,sha256=U07ETAINSGeSRBfWUG93E4tZZbaW_f7PGzEqZN0hulc,10542
+pip/_internal/models/__init__.py,sha256=3DHUd_qxpPozfzouoqa9g9ts1Czr5qaHfFxbnxriepM,63
+pip/_internal/models/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/models/__pycache__/candidate.cpython-312.pyc,,
+pip/_internal/models/__pycache__/direct_url.cpython-312.pyc,,
+pip/_internal/models/__pycache__/format_control.cpython-312.pyc,,
+pip/_internal/models/__pycache__/index.cpython-312.pyc,,
+pip/_internal/models/__pycache__/installation_report.cpython-312.pyc,,
+pip/_internal/models/__pycache__/link.cpython-312.pyc,,
+pip/_internal/models/__pycache__/scheme.cpython-312.pyc,,
+pip/_internal/models/__pycache__/search_scope.cpython-312.pyc,,
+pip/_internal/models/__pycache__/selection_prefs.cpython-312.pyc,,
+pip/_internal/models/__pycache__/target_python.cpython-312.pyc,,
+pip/_internal/models/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/models/candidate.py,sha256=zzgFRuw_kWPjKpGw7LC0ZUMD2CQ2EberUIYs8izjdCA,753
+pip/_internal/models/direct_url.py,sha256=uBtY2HHd3TO9cKQJWh0ThvE5FRr-MWRYChRU4IG9HZE,6578
+pip/_internal/models/format_control.py,sha256=wtsQqSK9HaUiNxQEuB-C62eVimw6G4_VQFxV9-_KDBE,2486
+pip/_internal/models/index.py,sha256=tYnL8oxGi4aSNWur0mG8DAP7rC6yuha_MwJO8xw0crI,1030
+pip/_internal/models/installation_report.py,sha256=zRVZoaz-2vsrezj_H3hLOhMZCK9c7TbzWgC-jOalD00,2818
+pip/_internal/models/link.py,sha256=jHax9O-9zlSzEwjBCDkx0OXjKXwBDwOuPwn-PsR8dCs,21034
+pip/_internal/models/scheme.py,sha256=PakmHJM3e8OOWSZFtfz1Az7f1meONJnkGuQxFlt3wBE,575
+pip/_internal/models/search_scope.py,sha256=67NEnsYY84784S-MM7ekQuo9KXLH-7MzFntXjapvAo0,4531
+pip/_internal/models/selection_prefs.py,sha256=qaFfDs3ciqoXPg6xx45N1jPLqccLJw4N0s4P0PyHTQ8,2015
+pip/_internal/models/target_python.py,sha256=2XaH2rZ5ZF-K5wcJbEMGEl7SqrTToDDNkrtQ2v_v_-Q,4271
+pip/_internal/models/wheel.py,sha256=G7dND_s4ebPkEL7RJ1qCY0QhUUWIIK6AnjWgRATF5no,4539
+pip/_internal/network/__init__.py,sha256=jf6Tt5nV_7zkARBrKojIXItgejvoegVJVKUbhAa5Ioc,50
+pip/_internal/network/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/network/__pycache__/auth.cpython-312.pyc,,
+pip/_internal/network/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/network/__pycache__/download.cpython-312.pyc,,
+pip/_internal/network/__pycache__/lazy_wheel.cpython-312.pyc,,
+pip/_internal/network/__pycache__/session.cpython-312.pyc,,
+pip/_internal/network/__pycache__/utils.cpython-312.pyc,,
+pip/_internal/network/__pycache__/xmlrpc.cpython-312.pyc,,
+pip/_internal/network/auth.py,sha256=D4gASjUrqoDFlSt6gQ767KAAjv6PUyJU0puDlhXNVRE,20809
+pip/_internal/network/cache.py,sha256=48A971qCzKNFvkb57uGEk7-0xaqPS0HWj2711QNTxkU,3935
+pip/_internal/network/download.py,sha256=FLOP29dPYECBiAi7eEjvAbNkyzaKNqbyjOT2m8HPW8U,6048
+pip/_internal/network/lazy_wheel.py,sha256=PBdoMoNQQIA84Fhgne38jWF52W4x_KtsHjxgv4dkRKA,7622
+pip/_internal/network/session.py,sha256=XmanBKjVwPFmh1iJ58q6TDh9xabH37gREuQJ_feuZGA,18741
+pip/_internal/network/utils.py,sha256=Inaxel-NxBu4PQWkjyErdnfewsFCcgHph7dzR1-FboY,4088
+pip/_internal/network/xmlrpc.py,sha256=sAxzOacJ-N1NXGPvap9jC3zuYWSnnv3GXtgR2-E2APA,1838
+pip/_internal/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/check.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/freeze.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/prepare.cpython-312.pyc,,
+pip/_internal/operations/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/build/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/build_tracker.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_editable.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_editable.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-312.pyc,,
+pip/_internal/operations/build/build_tracker.py,sha256=-ARW_TcjHCOX7D2NUOGntB4Fgc6b4aolsXkAK6BWL7w,4774
+pip/_internal/operations/build/metadata.py,sha256=9S0CUD8U3QqZeXp-Zyt8HxwU90lE4QrnYDgrqZDzBnc,1422
+pip/_internal/operations/build/metadata_editable.py,sha256=VLL7LvntKE8qxdhUdEJhcotFzUsOSI8NNS043xULKew,1474
+pip/_internal/operations/build/metadata_legacy.py,sha256=8i6i1QZX9m_lKPStEFsHKM0MT4a-CD408JOw99daLmo,2190
+pip/_internal/operations/build/wheel.py,sha256=sT12FBLAxDC6wyrDorh8kvcZ1jG5qInCRWzzP-UkJiQ,1075
+pip/_internal/operations/build/wheel_editable.py,sha256=yOtoH6zpAkoKYEUtr8FhzrYnkNHQaQBjWQ2HYae1MQg,1417
+pip/_internal/operations/build/wheel_legacy.py,sha256=K-6kNhmj-1xDF45ny1yheMerF0ui4EoQCLzEoHh6-tc,3045
+pip/_internal/operations/check.py,sha256=L24vRL8VWbyywdoeAhM89WCd8zLTnjIbULlKelUgIec,5912
+pip/_internal/operations/freeze.py,sha256=V59yEyCSz_YhZuhH09-6aV_zvYBMrS_IxFFNqn2QzlA,9864
+pip/_internal/operations/install/__init__.py,sha256=mX7hyD2GNBO2mFGokDQ30r_GXv7Y_PLdtxcUv144e-s,51
+pip/_internal/operations/install/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/install/__pycache__/editable_legacy.cpython-312.pyc,,
+pip/_internal/operations/install/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/operations/install/editable_legacy.py,sha256=PoEsNEPGbIZ2yQphPsmYTKLOCMs4gv5OcCdzW124NcA,1283
+pip/_internal/operations/install/wheel.py,sha256=X5Iz9yUg5LlK5VNQ9g2ikc6dcRu8EPi_SUi5iuEDRgo,27615
+pip/_internal/operations/prepare.py,sha256=joWJwPkuqGscQgVNImLK71e9hRapwKvRCM8HclysmvU,28118
+pip/_internal/pyproject.py,sha256=rw4fwlptDp1hZgYoplwbAGwWA32sWQkp7ysf8Ju6iXc,7287
+pip/_internal/req/__init__.py,sha256=HxBFtZy_BbCclLgr26waMtpzYdO5T3vxePvpGAXSt5s,2653
+pip/_internal/req/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/req/__pycache__/constructors.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_file.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_install.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_set.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_uninstall.cpython-312.pyc,,
+pip/_internal/req/constructors.py,sha256=v1qzCN1mIldwx-nCrPc8JO4lxkm3Fv8M5RWvt8LISjc,18430
+pip/_internal/req/req_file.py,sha256=gOOJTzL-mDRPcQhjwqjDrjn4V-3rK9TnEFnU3v8RA4Q,18752
+pip/_internal/req/req_install.py,sha256=yhT98NGDoAEk03jznTJnYCznzhiMEEA2ocgsUG_dcNU,35788
+pip/_internal/req/req_set.py,sha256=j3esG0s6SzoVReX9rWn4rpYNtyET_fwxbwJPRimvRxo,2858
+pip/_internal/req/req_uninstall.py,sha256=qzDIxJo-OETWqGais7tSMCDcWbATYABT-Tid3ityF0s,23853
+pip/_internal/resolution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/__pycache__/base.cpython-312.pyc,,
+pip/_internal/resolution/base.py,sha256=qlmh325SBVfvG6Me9gc5Nsh5sdwHBwzHBq6aEXtKsLA,583
+pip/_internal/resolution/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/legacy/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/legacy/__pycache__/resolver.cpython-312.pyc,,
+pip/_internal/resolution/legacy/resolver.py,sha256=3HZiJBRd1FTN6jQpI4qRO8-TbLYeIbUTS6PFvXnXs2w,24068
+pip/_internal/resolution/resolvelib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/base.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/base.py,sha256=DCf669FsqyQY5uqXeePDHQY1e4QO-pBzWH8O0s9-K94,5023
+pip/_internal/resolution/resolvelib/candidates.py,sha256=5UZ1upNnmqsP-nmEZaDYxaBgCoejw_e2WVGmmAvBxXc,20001
+pip/_internal/resolution/resolvelib/factory.py,sha256=511CaUR41LqjALuFafLVfx15WRvMhxYTdjQCoSvp4gw,32661
+pip/_internal/resolution/resolvelib/found_candidates.py,sha256=9hrTyQqFvl9I7Tji79F1AxHv39Qh1rkJ_7deSHSMfQc,6383
+pip/_internal/resolution/resolvelib/provider.py,sha256=bcsFnYvlmtB80cwVdW1fIwgol8ZNr1f1VHyRTkz47SM,9935
+pip/_internal/resolution/resolvelib/reporter.py,sha256=00JtoXEkTlw0-rl_sl54d71avwOsJHt9GGHcrj5Sza0,3168
+pip/_internal/resolution/resolvelib/requirements.py,sha256=7JG4Z72e5Yk4vU0S5ulGvbqTy4FMQGYhY5zQhX9zTtY,8065
+pip/_internal/resolution/resolvelib/resolver.py,sha256=nLJOsVMEVi2gQUVJoUFKMZAeu2f7GRMjGMvNSWyz0Bc,12592
+pip/_internal/self_outdated_check.py,sha256=pkjQixuWyQ1vrVxZAaYD6SSHgXuFUnHZybXEWTkh0S0,8145
+pip/_internal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/utils/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/_jaraco_text.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/_log.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/appdirs.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/compat.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/compatibility_tags.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/datetime.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/deprecation.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/direct_url_helpers.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/egg_link.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/encoding.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/entrypoints.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/filesystem.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/filetypes.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/glibc.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/hashes.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/logging.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/misc.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/packaging.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/retry.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/setuptools_build.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/subprocess.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/temp_dir.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/unpacking.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/urls.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/virtualenv.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/utils/_jaraco_text.py,sha256=M15uUPIh5NpP1tdUGBxRau6q1ZAEtI8-XyLEETscFfE,3350
+pip/_internal/utils/_log.py,sha256=-jHLOE_THaZz5BFcCnoSL9EYAtJ0nXem49s9of4jvKw,1015
+pip/_internal/utils/appdirs.py,sha256=swgcTKOm3daLeXTW6v5BUS2Ti2RvEnGRQYH_yDXklAo,1665
+pip/_internal/utils/compat.py,sha256=ckkFveBiYQjRWjkNsajt_oWPS57tJvE8XxoC4OIYgCY,2399
+pip/_internal/utils/compatibility_tags.py,sha256=OWq5axHpW-MEEPztGdvgADrgJPAcV9a88Rxm4Z8VBs8,6272
+pip/_internal/utils/datetime.py,sha256=m21Y3wAtQc-ji6Veb6k_M5g6A0ZyFI4egchTdnwh-pQ,242
+pip/_internal/utils/deprecation.py,sha256=k7Qg_UBAaaTdyq82YVARA6D7RmcGTXGv7fnfcgigj4Q,3707
+pip/_internal/utils/direct_url_helpers.py,sha256=r2MRtkVDACv9AGqYODBUC9CjwgtsUU1s68hmgfCJMtA,3196
+pip/_internal/utils/egg_link.py,sha256=0FePZoUYKv4RGQ2t6x7w5Z427wbA_Uo3WZnAkrgsuqo,2463
+pip/_internal/utils/encoding.py,sha256=qqsXDtiwMIjXMEiIVSaOjwH5YmirCaK-dIzb6-XJsL0,1169
+pip/_internal/utils/entrypoints.py,sha256=YlhLTRl2oHBAuqhc-zmL7USS67TPWVHImjeAQHreZTQ,3064
+pip/_internal/utils/filesystem.py,sha256=ajvA-q4ocliW9kPp8Yquh-4vssXbu-UKbo5FV9V4X64,4950
+pip/_internal/utils/filetypes.py,sha256=i8XAQ0eFCog26Fw9yV0Yb1ygAqKYB1w9Cz9n0fj8gZU,716
+pip/_internal/utils/glibc.py,sha256=vUkWq_1pJuzcYNcGKLlQmABoUiisK8noYY1yc8Wq4w4,3734
+pip/_internal/utils/hashes.py,sha256=XGGLL0AG8-RhWnyz87xF6MFZ--BKadHU35D47eApCKI,4972
+pip/_internal/utils/logging.py,sha256=7BFKB1uFjdxD5crM-GtwA5T2qjbQ2LPD-gJDuJeDNTg,11606
+pip/_internal/utils/misc.py,sha256=NRV0_2fFhzy1jhvInSBv4dqCmTwct8PV7Kp0m-BPRGM,23530
+pip/_internal/utils/packaging.py,sha256=iI3LH43lVNR4hWBOqF6lFsZq4aycb2j0UcHlmDmcqUg,2109
+pip/_internal/utils/retry.py,sha256=mhFbykXjhTnZfgzeuy-vl9c8nECnYn_CMtwNJX2tYzQ,1392
+pip/_internal/utils/setuptools_build.py,sha256=ouXpud-jeS8xPyTPsXJ-m34NPvK5os45otAzdSV_IJE,4435
+pip/_internal/utils/subprocess.py,sha256=EsvqSRiSMHF98T8Txmu6NLU3U--MpTTQjtNgKP0P--M,8988
+pip/_internal/utils/temp_dir.py,sha256=5qOXe8M4JeY6vaFQM867d5zkp1bSwMZ-KT5jymmP0Zg,9310
+pip/_internal/utils/unpacking.py,sha256=eyDkSsk4nW8ZfiSjNzJduCznpHyaGHVv3ak_LMGsiEM,11951
+pip/_internal/utils/urls.py,sha256=qceSOZb5lbNDrHNsv7_S4L4Ytszja5NwPKUMnZHbYnM,1599
+pip/_internal/utils/virtualenv.py,sha256=S6f7csYorRpiD6cvn3jISZYc3I8PJC43H5iMFpRAEDU,3456
+pip/_internal/utils/wheel.py,sha256=b442jkydFHjXzDy6cMR7MpzWBJ1Q82hR5F33cmcHV3g,4494
+pip/_internal/vcs/__init__.py,sha256=UAqvzpbi0VbZo3Ub6skEeZAw-ooIZR-zX_WpCbxyCoU,596
+pip/_internal/vcs/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/bazaar.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/git.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/mercurial.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/subversion.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/versioncontrol.cpython-312.pyc,,
+pip/_internal/vcs/bazaar.py,sha256=EKStcQaKpNu0NK4p5Q10Oc4xb3DUxFw024XrJy40bFQ,3528
+pip/_internal/vcs/git.py,sha256=3tpc9LQA_J4IVW5r5NvWaaSeDzcmJOrSFZN0J8vIKfU,18177
+pip/_internal/vcs/mercurial.py,sha256=oULOhzJ2Uie-06d1omkL-_Gc6meGaUkyogvqG9ZCyPs,5249
+pip/_internal/vcs/subversion.py,sha256=ddTugHBqHzV3ebKlU5QXHPN4gUqlyXbOx8q8NgXKvs8,11735
+pip/_internal/vcs/versioncontrol.py,sha256=cvf_-hnTAjQLXJ3d17FMNhQfcO1AcKWUF10tfrYyP-c,22440
+pip/_internal/wheel_builder.py,sha256=DL3A8LKeRj_ACp11WS5wSgASgPFqeyAeXJKdXfmaWXU,11799
+pip/_vendor/__init__.py,sha256=JYuAXvClhInxIrA2FTp5p-uuWVL7WV6-vEpTs46-Qh4,4873
+pip/_vendor/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__init__.py,sha256=GiYoagwPEiJ_xR_lbwWGaoCiPtF_rz4isjfjdDAgHU4,676
+pip/_vendor/cachecontrol/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/adapter.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/controller.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/serialize.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-312.pyc,,
+pip/_vendor/cachecontrol/_cmd.py,sha256=iist2EpzJvDVIhMAxXq8iFnTBsiZAd6iplxfmNboNyk,1737
+pip/_vendor/cachecontrol/adapter.py,sha256=fByO_Pd_EOemjWbuocvBWdN85xT0q_TBm2lxS6vD4fk,6355
+pip/_vendor/cachecontrol/cache.py,sha256=OTQj72tUf8C1uEgczdl3Gc8vkldSzsTITKtDGKMx4z8,1952
+pip/_vendor/cachecontrol/caches/__init__.py,sha256=dtrrroK5BnADR1GWjCZ19aZ0tFsMfvFBtLQQU1sp_ag,303
+pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/file_cache.py,sha256=9AlmmTJc6cslb6k5z_6q0sGPHVrMj8zv-uWy-simmfE,5406
+pip/_vendor/cachecontrol/caches/redis_cache.py,sha256=9rmqwtYu_ljVkW6_oLqbC7EaX_a8YT_yLuna-eS0dgo,1386
+pip/_vendor/cachecontrol/controller.py,sha256=o-ejGJlBmpKK8QQLyTPJj0t7siU8XVHXuV8MCybCxQ8,18575
+pip/_vendor/cachecontrol/filewrapper.py,sha256=STttGmIPBvZzt2b51dUOwoWX5crcMCpKZOisM3f5BNc,4292
+pip/_vendor/cachecontrol/heuristics.py,sha256=IYe4QmHERWsMvtxNrp920WeaIsaTTyqLB14DSheSbtY,4834
+pip/_vendor/cachecontrol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/cachecontrol/serialize.py,sha256=HQd2IllQ05HzPkVLMXTF2uX5mjEQjDBkxCqUJUODpZk,5163
+pip/_vendor/cachecontrol/wrapper.py,sha256=hsGc7g8QGQTT-4f8tgz3AM5qwScg6FO0BSdLSRdEvpU,1417
+pip/_vendor/certifi/__init__.py,sha256=p_GYZrjUwPBUhpLlCZoGb0miKBKSqDAyZC5DvIuqbHQ,94
+pip/_vendor/certifi/__main__.py,sha256=1k3Cr95vCxxGRGDljrW3wMdpZdL3Nhf0u1n-k2qdsCY,255
+pip/_vendor/certifi/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/certifi/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/certifi/__pycache__/core.cpython-312.pyc,,
+pip/_vendor/certifi/cacert.pem,sha256=lO3rZukXdPyuk6BWUJFOKQliWaXH6HGh9l1GGrUgG0c,299427
+pip/_vendor/certifi/core.py,sha256=2SRT5rIcQChFDbe37BQa-kULxAgJ8qN6l1jfqTp4HIs,4486
+pip/_vendor/certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/distlib/__init__.py,sha256=dcwgYGYGQqAEawBXPDtIx80DO_3cOmFv8HTc8JMzknQ,625
+pip/_vendor/distlib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/database.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/index.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/locators.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/manifest.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/markers.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/metadata.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/resources.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/scripts.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/util.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/wheel.cpython-312.pyc,,
+pip/_vendor/distlib/compat.py,sha256=2jRSjRI4o-vlXeTK2BCGIUhkc6e9ZGhSsacRM5oseTw,41467
+pip/_vendor/distlib/database.py,sha256=mHy_LxiXIsIVRb-T0-idBrVLw3Ffij5teHCpbjmJ9YU,51160
+pip/_vendor/distlib/index.py,sha256=lTbw268rRhj8dw1sib3VZ_0EhSGgoJO3FKJzSFMOaeA,20797
+pip/_vendor/distlib/locators.py,sha256=oBeAZpFuPQSY09MgNnLfQGGAXXvVO96BFpZyKMuK4tM,51026
+pip/_vendor/distlib/manifest.py,sha256=3qfmAmVwxRqU1o23AlfXrQGZzh6g_GGzTAP_Hb9C5zQ,14168
+pip/_vendor/distlib/markers.py,sha256=X6sDvkFGcYS8gUW8hfsWuKEKAqhQZAJ7iXOMLxRYjYk,5164
+pip/_vendor/distlib/metadata.py,sha256=zil3sg2EUfLXVigljY2d_03IJt-JSs7nX-73fECMX2s,38724
+pip/_vendor/distlib/resources.py,sha256=LwbPksc0A1JMbi6XnuPdMBUn83X7BPuFNWqPGEKI698,10820
+pip/_vendor/distlib/scripts.py,sha256=BJliaDAZaVB7WAkwokgC3HXwLD2iWiHaVI50H7C6eG8,18608
+pip/_vendor/distlib/t32.exe,sha256=a0GV5kCoWsMutvliiCKmIgV98eRZ33wXoS-XrqvJQVs,97792
+pip/_vendor/distlib/t64-arm.exe,sha256=68TAa32V504xVBnufojh0PcenpR3U4wAqTqf-MZqbPw,182784
+pip/_vendor/distlib/t64.exe,sha256=gaYY8hy4fbkHYTTnA4i26ct8IQZzkBG2pRdy0iyuBrc,108032
+pip/_vendor/distlib/util.py,sha256=vMPGvsS4j9hF6Y9k3Tyom1aaHLb0rFmZAEyzeAdel9w,66682
+pip/_vendor/distlib/version.py,sha256=s5VIs8wBn0fxzGxWM_aA2ZZyx525HcZbMvcTlTyZ3Rg,23727
+pip/_vendor/distlib/w32.exe,sha256=R4csx3-OGM9kL4aPIzQKRo5TfmRSHZo6QWyLhDhNBks,91648
+pip/_vendor/distlib/w64-arm.exe,sha256=xdyYhKj0WDcVUOCb05blQYvzdYIKMbmJn2SZvzkcey4,168448
+pip/_vendor/distlib/w64.exe,sha256=ejGf-rojoBfXseGLpya6bFTFPWRG21X5KvU8J5iU-K0,101888
+pip/_vendor/distlib/wheel.py,sha256=DFIVguEQHCdxnSdAO0dfFsgMcvVZitg7bCOuLwZ7A_s,43979
+pip/_vendor/distro/__init__.py,sha256=2fHjF-SfgPvjyNZ1iHh_wjqWdR_Yo5ODHwZC0jLBPhc,981
+pip/_vendor/distro/__main__.py,sha256=bu9d3TifoKciZFcqRBuygV3GSuThnVD_m2IK4cz96Vs,64
+pip/_vendor/distro/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/distro/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/distro/__pycache__/distro.cpython-312.pyc,,
+pip/_vendor/distro/distro.py,sha256=XqbefacAhDT4zr_trnbA15eY8vdK4GTghgmvUGrEM_4,49430
+pip/_vendor/distro/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/idna/__init__.py,sha256=KJQN1eQBr8iIK5SKrJ47lXvxG0BJ7Lm38W4zT0v_8lk,849
+pip/_vendor/idna/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/codec.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/core.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/idnadata.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/intranges.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/package_data.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc,,
+pip/_vendor/idna/codec.py,sha256=PS6m-XmdST7Wj7J7ulRMakPDt5EBJyYrT3CPtjh-7t4,3426
+pip/_vendor/idna/compat.py,sha256=0_sOEUMT4CVw9doD3vyRhX80X19PwqFoUBs7gWsFME4,321
+pip/_vendor/idna/core.py,sha256=lyhpoe2vulEaB_65xhXmoKgO-xUqFDvcwxu5hpNNO4E,12663
+pip/_vendor/idna/idnadata.py,sha256=dqRwytzkjIHMBa2R1lYvHDwACenZPt8eGVu1Y8UBE-E,78320
+pip/_vendor/idna/intranges.py,sha256=YBr4fRYuWH7kTKS2tXlFjM24ZF1Pdvcir-aywniInqg,1881
+pip/_vendor/idna/package_data.py,sha256=Tkt0KnIeyIlnHddOaz9WSkkislNgokJAuE-p5GorMqo,21
+pip/_vendor/idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/idna/uts46data.py,sha256=1KuksWqLuccPXm2uyRVkhfiFLNIhM_H2m4azCcnOqEU,206503
+pip/_vendor/msgpack/__init__.py,sha256=gsMP7JTECZNUSjvOyIbdhNOkpB9Z8BcGwabVGY2UcdQ,1077
+pip/_vendor/msgpack/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/ext.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/fallback.cpython-312.pyc,,
+pip/_vendor/msgpack/exceptions.py,sha256=dCTWei8dpkrMsQDcjQk74ATl9HsIBH0ybt8zOPNqMYc,1081
+pip/_vendor/msgpack/ext.py,sha256=fKp00BqDLjUtZnPd70Llr138zk8JsCuSpJkkZ5S4dt8,5629
+pip/_vendor/msgpack/fallback.py,sha256=wdUWJkWX2gzfRW9BBCTOuIE1Wvrf5PtBtR8ZtY7G_EE,33175
+pip/_vendor/packaging/__init__.py,sha256=dtw2bNmWCQ9WnMoK3bk_elL1svSlikXtLpZhCFIB9SE,496
+pip/_vendor/packaging/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_parser.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_structures.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/markers.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/metadata.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/requirements.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/tags.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/utils.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/packaging/_elffile.py,sha256=_LcJW4YNKywYsl4169B2ukKRqwxjxst_8H0FRVQKlz8,3282
+pip/_vendor/packaging/_manylinux.py,sha256=Xo4V0PZz8sbuVCbTni0t1CR0AHeir_7ib4lTmV8scD4,9586
+pip/_vendor/packaging/_musllinux.py,sha256=p9ZqNYiOItGee8KcZFeHF_YcdhVwGHdK6r-8lgixvGQ,2694
+pip/_vendor/packaging/_parser.py,sha256=s_TvTvDNK0NrM2QB3VKThdWFM4Nc0P6JnkObkl3MjpM,10236
+pip/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+pip/_vendor/packaging/_tokenizer.py,sha256=J6v5H7Jzvb-g81xp_2QACKwO7LxHQA6ikryMU7zXwN8,5273
+pip/_vendor/packaging/markers.py,sha256=dWKSqn5Sp-jDmOG-W3GfLHKjwhf1IsznbT71VlBoB5M,10671
+pip/_vendor/packaging/metadata.py,sha256=KINuSkJ12u-SyoKNTy_pHNGAfMUtxNvZ53qA1zAKcKI,32349
+pip/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/packaging/requirements.py,sha256=gYyRSAdbrIyKDY66ugIDUQjRMvxkH2ALioTmX3tnL6o,2947
+pip/_vendor/packaging/specifiers.py,sha256=HfGgfNJRvrzC759gnnoojHyiWs_DYmcw5PEh5jHH-YE,39738
+pip/_vendor/packaging/tags.py,sha256=Fo6_cit95-7QfcMb16XtI7AUiSMgdwA_hCO_9lV2pz4,21388
+pip/_vendor/packaging/utils.py,sha256=NAdYUwnlAOpkat_RthavX8a07YuVxgGL_vwrx73GSDM,5287
+pip/_vendor/packaging/version.py,sha256=wE4sSVlF-d1H6HFC1vszEe35CwTig_fh4HHIFg95hFE,16210
+pip/_vendor/pkg_resources/__init__.py,sha256=jrhDRbOubP74QuPXxd7U7Po42PH2l-LZ2XfcO7llpZ4,124463
+pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__init__.py,sha256=FTA6LGNm40GwNZt3gG3uLAacWvf2E_2HTmH0rAALGR8,22285
+pip/_vendor/platformdirs/__main__.py,sha256=jBJ8zb7Mpx5ebcqF83xrpO94MaeCpNGHVf9cvDN2JLg,1505
+pip/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/android.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/api.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc,,
+pip/_vendor/platformdirs/android.py,sha256=xZXY9Jd46WOsxT2U6-5HsNtDZ-IQqxcEUrBLl3hYk4o,9016
+pip/_vendor/platformdirs/api.py,sha256=QBYdUac2eC521ek_y53uD1Dcq-lJX8IgSRVd4InC6uc,8996
+pip/_vendor/platformdirs/macos.py,sha256=wftsbsvq6nZ0WORXSiCrZNkRHz_WKuktl0a6mC7MFkI,5580
+pip/_vendor/platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/platformdirs/unix.py,sha256=Cci9Wqt35dAMsg6HT9nRGHSBW5obb0pR3AE1JJnsCXg,10643
+pip/_vendor/platformdirs/version.py,sha256=r7F76tZRjgQKzrpx_I0_ZMQOMU-PS7eGnHD7zEK3KB0,411
+pip/_vendor/platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125
+pip/_vendor/pygments/__init__.py,sha256=7N1oiaWulw_nCsTY4EEixYLz15pWY5u4uPAFFi-ielU,2983
+pip/_vendor/pygments/__main__.py,sha256=isIhBxLg65nLlXukG4VkMuPfNdd7gFzTZ_R_z3Q8diY,353
+pip/_vendor/pygments/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/cmdline.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/console.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/filter.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/formatter.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/lexer.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/modeline.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/plugin.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/regexopt.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/scanner.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/sphinxext.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/style.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/token.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/unistring.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/util.cpython-312.pyc,,
+pip/_vendor/pygments/cmdline.py,sha256=LIVzmAunlk9sRJJp54O4KRy9GDIN4Wu13v9p9QzfGPM,23656
+pip/_vendor/pygments/console.py,sha256=yhP9UsLAVmWKVQf2446JJewkA7AiXeeTf4Ieg3Oi2fU,1718
+pip/_vendor/pygments/filter.py,sha256=_ADNPCskD8_GmodHi6_LoVgPU3Zh336aBCT5cOeTMs0,1910
+pip/_vendor/pygments/filters/__init__.py,sha256=RdedK2KWKXlKwR7cvkfr3NUj9YiZQgMgilRMFUg2jPA,40392
+pip/_vendor/pygments/filters/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/formatter.py,sha256=jDWBTndlBH2Z5IYZFVDnP0qn1CaTQjTWt7iAGtCnJEg,4390
+pip/_vendor/pygments/formatters/__init__.py,sha256=8No-NUs8rBTSSBJIv4hSEQt2M0cFB4hwAT0snVc2QGE,5385
+pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/groff.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/html.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/img.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/irc.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/latex.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/other.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/svg.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/_mapping.py,sha256=1Cw37FuQlNacnxRKmtlPX4nyLoX9_ttko5ZwscNUZZ4,4176
+pip/_vendor/pygments/formatters/bbcode.py,sha256=3JQLI45tcrQ_kRUMjuab6C7Hb0XUsbVWqqbSn9cMjkI,3320
+pip/_vendor/pygments/formatters/groff.py,sha256=M39k0PaSSZRnxWjqBSVPkF0mu1-Vr7bm6RsFvs-CNN4,5106
+pip/_vendor/pygments/formatters/html.py,sha256=SE2jc3YCqbMS3rZW9EAmDlAUhdVxJ52gA4dileEvCGU,35669
+pip/_vendor/pygments/formatters/img.py,sha256=MwA4xWPLOwh6j7Yc6oHzjuqSPt0M1fh5r-5BTIIUfsU,23287
+pip/_vendor/pygments/formatters/irc.py,sha256=dp1Z0l_ObJ5NFh9MhqLGg5ptG5hgJqedT2Vkutt9v0M,4981
+pip/_vendor/pygments/formatters/latex.py,sha256=XMmhOCqUKDBQtG5mGJNAFYxApqaC5puo5cMmPfK3944,19306
+pip/_vendor/pygments/formatters/other.py,sha256=56PMJOliin-rAUdnRM0i1wsV1GdUPd_dvQq0_UPfF9c,5034
+pip/_vendor/pygments/formatters/pangomarkup.py,sha256=y16U00aVYYEFpeCfGXlYBSMacG425CbfoG8oKbKegIg,2218
+pip/_vendor/pygments/formatters/rtf.py,sha256=ZT90dmcKyJboIB0mArhL7IhE467GXRN0G7QAUgG03To,11957
+pip/_vendor/pygments/formatters/svg.py,sha256=KKsiophPupHuxm0So-MsbQEWOT54IAiSF7hZPmxtKXE,7174
+pip/_vendor/pygments/formatters/terminal.py,sha256=AojNG4MlKq2L6IsC_VnXHu4AbHCBn9Otog6u45XvxeI,4674
+pip/_vendor/pygments/formatters/terminal256.py,sha256=kGkNUVo3FpwjytIDS0if79EuUoroAprcWt3igrcIqT0,11753
+pip/_vendor/pygments/lexer.py,sha256=TYHDt___gNW4axTl2zvPZff-VQi8fPaIh5OKRcVSjUM,35349
+pip/_vendor/pygments/lexers/__init__.py,sha256=pIlxyQJuu_syh9lE080cq8ceVbEVcKp0osAFU5fawJU,12115
+pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/__pycache__/python.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/_mapping.py,sha256=61-h3zr103m01OS5BUq_AfUiL9YI06Ves9ipQ7k4vr4,76097
+pip/_vendor/pygments/lexers/python.py,sha256=2J_YJrPTr_A6fJY_qKiKv0GpgPwHMrlMSeo59qN3fe4,53687
+pip/_vendor/pygments/modeline.py,sha256=gtRYZBS-CKOCDXHhGZqApboHBaZwGH8gznN3O6nuxj4,1005
+pip/_vendor/pygments/plugin.py,sha256=ioeJ3QeoJ-UQhZpY9JL7vbxsTVuwwM7BCu-Jb8nN0AU,1891
+pip/_vendor/pygments/regexopt.py,sha256=Hky4EB13rIXEHQUNkwmCrYqtIlnXDehNR3MztafZ43w,3072
+pip/_vendor/pygments/scanner.py,sha256=NDy3ofK_fHRFK4hIDvxpamG871aewqcsIb6sgTi7Fhk,3092
+pip/_vendor/pygments/sphinxext.py,sha256=iOptJBcqOGPwMEJ2p70PvwpZPIGdvdZ8dxvq6kzxDgA,7981
+pip/_vendor/pygments/style.py,sha256=rSCZWFpg1_DwFMXDU0nEVmAcBHpuQGf9RxvOPPQvKLQ,6420
+pip/_vendor/pygments/styles/__init__.py,sha256=qUk6_1z5KmT8EdJFZYgESmG6P_HJF_2vVrDD7HSCGYY,2042
+pip/_vendor/pygments/styles/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/styles/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/styles/_mapping.py,sha256=6lovFUE29tz6EsV3XYY4hgozJ7q1JL7cfO3UOlgnS8w,3312
+pip/_vendor/pygments/token.py,sha256=qZwT7LSPy5YBY3JgDjut642CCy7JdQzAfmqD9NmT5j0,6226
+pip/_vendor/pygments/unistring.py,sha256=p5c1i-HhoIhWemy9CUsaN9o39oomYHNxXll0Xfw6tEA,63208
+pip/_vendor/pygments/util.py,sha256=2tj2nS1X9_OpcuSjf8dOET2bDVZhs8cEKd_uT6-Fgg8,10031
+pip/_vendor/pyproject_hooks/__init__.py,sha256=kCehmy0UaBa9oVMD7ZIZrnswfnP3LXZ5lvnNJAL5JBM,491
+pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_compat.py,sha256=by6evrYnqkisiM-MQcvOKs5bgDMzlOSgZqRHNqf04zE,138
+pip/_vendor/pyproject_hooks/_impl.py,sha256=61GJxzQip0IInhuO69ZI5GbNQ82XEDUB_1Gg5_KtUoc,11920
+pip/_vendor/pyproject_hooks/_in_process/__init__.py,sha256=9gQATptbFkelkIy0OfWFEACzqxXJMQDWCH9rBOAZVwQ,546
+pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_in_process/_in_process.py,sha256=m2b34c917IW5o-Q_6TYIHlsK9lSUlNiyrITTUH_zwew,10927
+pip/_vendor/requests/__init__.py,sha256=HlB_HzhrzGtfD_aaYUwUh1zWXLZ75_YCLyit75d0Vz8,5057
+pip/_vendor/requests/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/__version__.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/_internal_utils.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/adapters.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/api.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/auth.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/certs.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/cookies.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/help.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/hooks.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/models.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/packages.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/sessions.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/status_codes.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/structures.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/utils.cpython-312.pyc,,
+pip/_vendor/requests/__version__.py,sha256=FVfglgZmNQnmYPXpOohDU58F5EUb_-VnSTaAesS187g,435
+pip/_vendor/requests/_internal_utils.py,sha256=nMQymr4hs32TqVo5AbCrmcJEhvPUh7xXlluyqwslLiQ,1495
+pip/_vendor/requests/adapters.py,sha256=J7VeVxKBvawbtlX2DERVo05J9BXTcWYLMHNd1Baa-bk,27607
+pip/_vendor/requests/api.py,sha256=_Zb9Oa7tzVIizTKwFrPjDEY9ejtm_OnSRERnADxGsQs,6449
+pip/_vendor/requests/auth.py,sha256=kF75tqnLctZ9Mf_hm9TZIj4cQWnN5uxRz8oWsx5wmR0,10186
+pip/_vendor/requests/certs.py,sha256=PVPooB0jP5hkZEULSCwC074532UFbR2Ptgu0I5zwmCs,575
+pip/_vendor/requests/compat.py,sha256=Mo9f9xZpefod8Zm-n9_StJcVTmwSukXR2p3IQyyVXvU,1485
+pip/_vendor/requests/cookies.py,sha256=bNi-iqEj4NPZ00-ob-rHvzkvObzN3lEpgw3g6paS3Xw,18590
+pip/_vendor/requests/exceptions.py,sha256=D1wqzYWne1mS2rU43tP9CeN1G7QAy7eqL9o1god6Ejw,4272
+pip/_vendor/requests/help.py,sha256=hRKaf9u0G7fdwrqMHtF3oG16RKktRf6KiwtSq2Fo1_0,3813
+pip/_vendor/requests/hooks.py,sha256=CiuysiHA39V5UfcCBXFIx83IrDpuwfN9RcTUgv28ftQ,733
+pip/_vendor/requests/models.py,sha256=x4K4CmH-lC0l2Kb-iPfMN4dRXxHEcbOaEWBL_i09AwI,35483
+pip/_vendor/requests/packages.py,sha256=_ZQDCJTJ8SP3kVWunSqBsRZNPzj2c1WFVqbdr08pz3U,1057
+pip/_vendor/requests/sessions.py,sha256=ykTI8UWGSltOfH07HKollH7kTBGw4WhiBVaQGmckTw4,30495
+pip/_vendor/requests/status_codes.py,sha256=iJUAeA25baTdw-6PfD0eF4qhpINDJRJI-yaMqxs4LEI,4322
+pip/_vendor/requests/structures.py,sha256=-IbmhVz06S-5aPSZuUthZ6-6D9XOjRuTXHOabY041XM,2912
+pip/_vendor/requests/utils.py,sha256=L79vnFbzJ3SFLKtJwpoWe41Tozi3RlZv94pY1TFIyow,33631
+pip/_vendor/resolvelib/__init__.py,sha256=h509TdEcpb5-44JonaU3ex2TM15GVBLjM9CNCPwnTTs,537
+pip/_vendor/resolvelib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/providers.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/reporters.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/resolvers.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/structs.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/collections_abc.py,sha256=uy8xUZ-NDEw916tugUXm8HgwCGiMO0f-RcdnpkfXfOs,156
+pip/_vendor/resolvelib/providers.py,sha256=fuuvVrCetu5gsxPB43ERyjfO8aReS3rFQHpDgiItbs4,5871
+pip/_vendor/resolvelib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/reporters.py,sha256=TSbRmWzTc26w0ggsV1bxVpeWDB8QNIre6twYl7GIZBE,1601
+pip/_vendor/resolvelib/resolvers.py,sha256=G8rsLZSq64g5VmIq-lB7UcIJ1gjAxIQJmTF4REZleQ0,20511
+pip/_vendor/resolvelib/structs.py,sha256=0_1_XO8z_CLhegP3Vpf9VJ3zJcfLm0NOHRM-i0Ykz3o,4963
+pip/_vendor/rich/__init__.py,sha256=dRxjIL-SbFVY0q3IjSMrfgBTHrm1LZDgLOygVBwiYZc,6090
+pip/_vendor/rich/__main__.py,sha256=eO7Cq8JnrgG8zVoeImiAs92q3hXNMIfp0w5lMsO7Q2Y,8477
+pip/_vendor/rich/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_cell_widths.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_emoji_codes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_emoji_replace.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_export_format.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_extension.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_fileno.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_inspect.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_log_render.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_loop.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_null_file.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_palettes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_pick.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_ratio.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_spinners.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_stack.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_timer.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_win32_console.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_windows.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_windows_renderer.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_wrap.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/abc.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/align.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/ansi.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/bar.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/box.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/cells.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/color.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/color_triplet.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/columns.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/console.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/constrain.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/containers.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/control.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/default_styles.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/diagnose.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/emoji.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/errors.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/file_proxy.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/filesize.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/highlighter.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/json.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/jupyter.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/layout.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/live.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/live_render.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/logging.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/markup.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/measure.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/padding.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/pager.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/palette.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/panel.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/pretty.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/progress.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/progress_bar.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/prompt.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/protocol.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/region.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/repr.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/rule.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/scope.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/screen.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/segment.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/spinner.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/status.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/style.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/styled.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/syntax.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/table.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/terminal_theme.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/text.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/theme.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/themes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/traceback.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/tree.cpython-312.pyc,,
+pip/_vendor/rich/_cell_widths.py,sha256=fbmeyetEdHjzE_Vx2l1uK7tnPOhMs2X1lJfO3vsKDpA,10209
+pip/_vendor/rich/_emoji_codes.py,sha256=hu1VL9nbVdppJrVoijVshRlcRRe_v3dju3Mmd2sKZdY,140235
+pip/_vendor/rich/_emoji_replace.py,sha256=n-kcetsEUx2ZUmhQrfeMNc-teeGhpuSQ5F8VPBsyvDo,1064
+pip/_vendor/rich/_export_format.py,sha256=RI08pSrm5tBSzPMvnbTqbD9WIalaOoN5d4M1RTmLq1Y,2128
+pip/_vendor/rich/_extension.py,sha256=Xt47QacCKwYruzjDi-gOBq724JReDj9Cm9xUi5fr-34,265
+pip/_vendor/rich/_fileno.py,sha256=HWZxP5C2ajMbHryvAQZseflVfQoGzsKOHzKGsLD8ynQ,799
+pip/_vendor/rich/_inspect.py,sha256=oZJGw31e64dwXSCmrDnvZbwVb1ZKhWfU8wI3VWohjJk,9695
+pip/_vendor/rich/_log_render.py,sha256=1ByI0PA1ZpxZY3CGJOK54hjlq4X-Bz_boIjIqCd8Kns,3225
+pip/_vendor/rich/_loop.py,sha256=hV_6CLdoPm0va22Wpw4zKqM0RYsz3TZxXj0PoS-9eDQ,1236
+pip/_vendor/rich/_null_file.py,sha256=tGSXk_v-IZmbj1GAzHit8A3kYIQMiCpVsCFfsC-_KJ4,1387
+pip/_vendor/rich/_palettes.py,sha256=cdev1JQKZ0JvlguV9ipHgznTdnvlIzUFDBb0It2PzjI,7063
+pip/_vendor/rich/_pick.py,sha256=evDt8QN4lF5CiwrUIXlOJCntitBCOsI3ZLPEIAVRLJU,423
+pip/_vendor/rich/_ratio.py,sha256=Zt58apszI6hAAcXPpgdWKpu3c31UBWebOeR4mbyptvU,5471
+pip/_vendor/rich/_spinners.py,sha256=U2r1_g_1zSjsjiUdAESc2iAMc3i4ri_S8PYP6kQ5z1I,19919
+pip/_vendor/rich/_stack.py,sha256=-C8OK7rxn3sIUdVwxZBBpeHhIzX0eI-VM3MemYfaXm0,351
+pip/_vendor/rich/_timer.py,sha256=zelxbT6oPFZnNrwWPpc1ktUeAT-Vc4fuFcRZLQGLtMI,417
+pip/_vendor/rich/_win32_console.py,sha256=P0vxI2fcndym1UU1S37XAzQzQnkyY7YqAKmxm24_gug,22820
+pip/_vendor/rich/_windows.py,sha256=aBwaD_S56SbgopIvayVmpk0Y28uwY2C5Bab1wl3Bp-I,1925
+pip/_vendor/rich/_windows_renderer.py,sha256=t74ZL3xuDCP3nmTp9pH1L5LiI2cakJuQRQleHCJerlk,2783
+pip/_vendor/rich/_wrap.py,sha256=FlSsom5EX0LVkA3KWy34yHnCfLtqX-ZIepXKh-70rpc,3404
+pip/_vendor/rich/abc.py,sha256=ON-E-ZqSSheZ88VrKX2M3PXpFbGEUUZPMa_Af0l-4f0,890
+pip/_vendor/rich/align.py,sha256=sCUkisXkQfoq-IQPyBELfJ8l7LihZJX3HbH8K7Cie-M,10368
+pip/_vendor/rich/ansi.py,sha256=iD6532QYqnBm6hADulKjrV8l8kFJ-9fEVooHJHH3hMg,6906
+pip/_vendor/rich/bar.py,sha256=ldbVHOzKJOnflVNuv1xS7g6dLX2E3wMnXkdPbpzJTcs,3263
+pip/_vendor/rich/box.py,sha256=nr5fYIUghB_iUCEq6y0Z3LlCT8gFPDrzN9u2kn7tJl4,10831
+pip/_vendor/rich/cells.py,sha256=aMmGK4BjXhgE6_JF1ZEGmW3O7mKkE8g84vUnj4Et4To,4780
+pip/_vendor/rich/color.py,sha256=bCRATVdRe5IClJ6Hl62de2PKQ_U4i2MZ4ugjUEg7Tao,18223
+pip/_vendor/rich/color_triplet.py,sha256=3lhQkdJbvWPoLDO-AnYImAWmJvV5dlgYNCVZ97ORaN4,1054
+pip/_vendor/rich/columns.py,sha256=HUX0KcMm9dsKNi11fTbiM_h2iDtl8ySCaVcxlalEzq8,7131
+pip/_vendor/rich/console.py,sha256=deFZIubq2M9A2MCsKFAsFQlWDvcOMsGuUA07QkOaHIw,99173
+pip/_vendor/rich/constrain.py,sha256=1VIPuC8AgtKWrcncQrjBdYqA3JVWysu6jZo1rrh7c7Q,1288
+pip/_vendor/rich/containers.py,sha256=c_56TxcedGYqDepHBMTuZdUIijitAQgnox-Qde0Z1qo,5502
+pip/_vendor/rich/control.py,sha256=DSkHTUQLorfSERAKE_oTAEUFefZnZp4bQb4q8rHbKws,6630
+pip/_vendor/rich/default_styles.py,sha256=-Fe318kMVI_IwciK5POpThcO0-9DYJ67TZAN6DlmlmM,8082
+pip/_vendor/rich/diagnose.py,sha256=an6uouwhKPAlvQhYpNNpGq9EJysfMIOvvCbO3oSoR24,972
+pip/_vendor/rich/emoji.py,sha256=omTF9asaAnsM4yLY94eR_9dgRRSm1lHUszX20D1yYCQ,2501
+pip/_vendor/rich/errors.py,sha256=5pP3Kc5d4QJ_c0KFsxrfyhjiPVe7J1zOqSFbFAzcV-Y,642
+pip/_vendor/rich/file_proxy.py,sha256=Tl9THMDZ-Pk5Wm8sI1gGg_U5DhusmxD-FZ0fUbcU0W0,1683
+pip/_vendor/rich/filesize.py,sha256=9fTLAPCAwHmBXdRv7KZU194jSgNrRb6Wx7RIoBgqeKY,2508
+pip/_vendor/rich/highlighter.py,sha256=6ZAjUcNhBRajBCo9umFUclyi2xL0-55JL7S0vYGUJu4,9585
+pip/_vendor/rich/json.py,sha256=vVEoKdawoJRjAFayPwXkMBPLy7RSTs-f44wSQDR2nJ0,5031
+pip/_vendor/rich/jupyter.py,sha256=QyoKoE_8IdCbrtiSHp9TsTSNyTHY0FO5whE7jOTd9UE,3252
+pip/_vendor/rich/layout.py,sha256=ajkSFAtEVv9EFTcFs-w4uZfft7nEXhNzL7ZVdgrT5rI,14004
+pip/_vendor/rich/live.py,sha256=vUcnJV2LMSK3sQNaILbm0-_B8BpAeiHfcQMAMLfpRe0,14271
+pip/_vendor/rich/live_render.py,sha256=zJtB471jGziBtEwxc54x12wEQtH4BuQr1SA8v9kU82w,3666
+pip/_vendor/rich/logging.py,sha256=uB-cB-3Q4bmXDLLpbOWkmFviw-Fde39zyMV6tKJ2WHQ,11903
+pip/_vendor/rich/markup.py,sha256=3euGKP5s41NCQwaSjTnJxus5iZMHjxpIM0W6fCxra38,8451
+pip/_vendor/rich/measure.py,sha256=HmrIJX8sWRTHbgh8MxEay_83VkqNW_70s8aKP5ZcYI8,5305
+pip/_vendor/rich/padding.py,sha256=kTFGsdGe0os7tXLnHKpwTI90CXEvrceeZGCshmJy5zw,4970
+pip/_vendor/rich/pager.py,sha256=SO_ETBFKbg3n_AgOzXm41Sv36YxXAyI3_R-KOY2_uSc,828
+pip/_vendor/rich/palette.py,sha256=lInvR1ODDT2f3UZMfL1grq7dY_pDdKHw4bdUgOGaM4Y,3396
+pip/_vendor/rich/panel.py,sha256=2Fd1V7e1kHxlPFIusoHY5T7-Cs0RpkrihgVG9ZVqJ4g,10705
+pip/_vendor/rich/pretty.py,sha256=5oIHP_CGWnHEnD0zMdW5qfGC5kHqIKn7zH_eC4crULE,35848
+pip/_vendor/rich/progress.py,sha256=P02xi7T2Ua3qq17o83bkshe4c0v_45cg8VyTj6US6Vg,59715
+pip/_vendor/rich/progress_bar.py,sha256=L4jw8E6Qb_x-jhOrLVhkuMaPmiAhFIl8jHQbWFrKuR8,8164
+pip/_vendor/rich/prompt.py,sha256=wdOn2X8XTJKnLnlw6PoMY7xG4iUPp3ezt4O5gqvpV-E,11304
+pip/_vendor/rich/protocol.py,sha256=5hHHDDNHckdk8iWH5zEbi-zuIVSF5hbU2jIo47R7lTE,1391
+pip/_vendor/rich/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/rich/region.py,sha256=rNT9xZrVZTYIXZC0NYn41CJQwYNbR-KecPOxTgQvB8Y,166
+pip/_vendor/rich/repr.py,sha256=5MZJZmONgC6kud-QW-_m1okXwL2aR6u6y-pUcUCJz28,4431
+pip/_vendor/rich/rule.py,sha256=0fNaS_aERa3UMRc3T5WMpN_sumtDxfaor2y3of1ftBk,4602
+pip/_vendor/rich/scope.py,sha256=TMUU8qo17thyqQCPqjDLYpg_UU1k5qVd-WwiJvnJVas,2843
+pip/_vendor/rich/screen.py,sha256=YoeReESUhx74grqb0mSSb9lghhysWmFHYhsbMVQjXO8,1591
+pip/_vendor/rich/segment.py,sha256=hU1ueeXqI6YeFa08K9DAjlF2QLxcJY9pwZx7RsXavlk,24246
+pip/_vendor/rich/spinner.py,sha256=15koCmF0DQeD8-k28Lpt6X_zJQUlzEhgo_6A6uy47lc,4339
+pip/_vendor/rich/status.py,sha256=kkPph3YeAZBo-X-4wPp8gTqZyU466NLwZBA4PZTTewo,4424
+pip/_vendor/rich/style.py,sha256=3hiocH_4N8vwRm3-8yFWzM7tSwjjEven69XqWasSQwM,27073
+pip/_vendor/rich/styled.py,sha256=eZNnzGrI4ki_54pgY3Oj0T-x3lxdXTYh4_ryDB24wBU,1258
+pip/_vendor/rich/syntax.py,sha256=TnZDuOD4DeHFbkaVEAji1gf8qgAlMU9Boe_GksMGCkk,35475
+pip/_vendor/rich/table.py,sha256=nGEvAZHF4dy1vT9h9Gj9O5qhSQO3ODAxJv0RY1vnIB8,39680
+pip/_vendor/rich/terminal_theme.py,sha256=1j5-ufJfnvlAo5Qsi_ACZiXDmwMXzqgmFByObT9-yJY,3370
+pip/_vendor/rich/text.py,sha256=5rQ3zvNrg5UZKNLecbh7fiw9v3HeFulNVtRY_CBDjjE,47312
+pip/_vendor/rich/theme.py,sha256=belFJogzA0W0HysQabKaHOc3RWH2ko3fQAJhoN-AFdo,3777
+pip/_vendor/rich/themes.py,sha256=0xgTLozfabebYtcJtDdC5QkX5IVUEaviqDUJJh4YVFk,102
+pip/_vendor/rich/traceback.py,sha256=CUpxYLjQWIb6vQQ6O72X0hvDV6caryGqU6UweHgOyCY,29601
+pip/_vendor/rich/tree.py,sha256=meAOUU6sYnoBEOX2ILrPLY9k5bWrWNQKkaiEFvHinXM,9167
+pip/_vendor/tomli/__init__.py,sha256=JhUwV66DB1g4Hvt1UQCVMdfCu-IgAV8FXmvDU9onxd4,396
+pip/_vendor/tomli/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_parser.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_re.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_types.cpython-312.pyc,,
+pip/_vendor/tomli/_parser.py,sha256=g9-ENaALS-B8dokYpCuzUFalWlog7T-SIYMjLZSWrtM,22633
+pip/_vendor/tomli/_re.py,sha256=dbjg5ChZT23Ka9z9DHOXfdtSpPwUfdgMXnj8NOoly-w,2943
+pip/_vendor/tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254
+pip/_vendor/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+pip/_vendor/truststore/__init__.py,sha256=WIDeyzWm7EVX44g354M25vpRXbeY1lsPH6EmUJUcq4o,1264
+pip/_vendor/truststore/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_api.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_macos.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_openssl.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_windows.cpython-312.pyc,,
+pip/_vendor/truststore/_api.py,sha256=GeXRNTlxPZ3kif4kNoh6JY0oE4QRzTGcgXr6l_X_Gk0,10555
+pip/_vendor/truststore/_macos.py,sha256=nZlLkOmszUE0g6ryRwBVGY5COzPyudcsiJtDWarM5LQ,20503
+pip/_vendor/truststore/_openssl.py,sha256=LLUZ7ZGaio-i5dpKKjKCSeSufmn6T8pi9lDcFnvSyq0,2324
+pip/_vendor/truststore/_ssl_constants.py,sha256=NUD4fVKdSD02ri7-db0tnO0VqLP9aHuzmStcW7tAl08,1130
+pip/_vendor/truststore/_windows.py,sha256=rAHyKYD8M7t-bXfG8VgOVa3TpfhVhbt4rZQlO45YuP8,17993
+pip/_vendor/truststore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/typing_extensions.py,sha256=78hFl0HpDY-ylHUVCnWdU5nTHxUP2-S-3wEZk6CQmLk,134499
+pip/_vendor/urllib3/__init__.py,sha256=iXLcYiJySn0GNbWOOZDDApgBL1JgP44EZ8i1760S8Mc,3333
+pip/_vendor/urllib3/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/_collections.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/_version.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/connection.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/connectionpool.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/fields.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/filepost.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/poolmanager.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/request.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/response.cpython-312.pyc,,
+pip/_vendor/urllib3/_collections.py,sha256=pyASJJhW7wdOpqJj9QJA8FyGRfr8E8uUUhqUvhF0728,11372
+pip/_vendor/urllib3/_version.py,sha256=t9wGB6ooOTXXgiY66K1m6BZS1CJyXHAU8EoWDTe6Shk,64
+pip/_vendor/urllib3/connection.py,sha256=ttIA909BrbTUzwkqEe_TzZVh4JOOj7g61Ysei2mrwGg,20314
+pip/_vendor/urllib3/connectionpool.py,sha256=e2eiAwNbFNCKxj4bwDKNK-w7HIdSz3OmMxU_TIt-evQ,40408
+pip/_vendor/urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_appengine_environ.py,sha256=bDbyOEhW2CKLJcQqAKAyrEHN-aklsyHFKq6vF8ZFsmk,957
+pip/_vendor/urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/bindings.py,sha256=4Xk64qIkPBt09A5q-RIFUuDhNc9mXilVapm7WnYnzRw,17632
+pip/_vendor/urllib3/contrib/_securetransport/low_level.py,sha256=B2JBB2_NRP02xK6DCa1Pa9IuxrPwxzDzZbixQkb7U9M,13922
+pip/_vendor/urllib3/contrib/appengine.py,sha256=VR68eAVE137lxTgjBDwCna5UiBZTOKa01Aj_-5BaCz4,11036
+pip/_vendor/urllib3/contrib/ntlmpool.py,sha256=NlfkW7WMdW8ziqudopjHoW299og1BTWi0IeIibquFwk,4528
+pip/_vendor/urllib3/contrib/pyopenssl.py,sha256=hDJh4MhyY_p-oKlFcYcQaVQRDv6GMmBGuW9yjxyeejM,17081
+pip/_vendor/urllib3/contrib/securetransport.py,sha256=Fef1IIUUFHqpevzXiDPbIGkDKchY2FVKeVeLGR1Qq3g,34446
+pip/_vendor/urllib3/contrib/socks.py,sha256=aRi9eWXo9ZEb95XUxef4Z21CFlnnjbEiAo9HOseoMt4,7097
+pip/_vendor/urllib3/exceptions.py,sha256=0Mnno3KHTNfXRfY7638NufOPkUb6mXOm-Lqj-4x2w8A,8217
+pip/_vendor/urllib3/fields.py,sha256=kvLDCg_JmH1lLjUUEY_FLS8UhY7hBvDPuVETbY8mdrM,8579
+pip/_vendor/urllib3/filepost.py,sha256=5b_qqgRHVlL7uLtdAYBzBh-GHmU5AfJVt_2N0XS3PeY,2440
+pip/_vendor/urllib3/packages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/__pycache__/six.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/makefile.py,sha256=nbzt3i0agPVP07jqqgjhaYjMmuAi_W5E0EywZivVO8E,1417
+pip/_vendor/urllib3/packages/backports/weakref_finalize.py,sha256=tRCal5OAhNSRyb0DhHp-38AtIlCsRP8BxF3NX-6rqIA,5343
+pip/_vendor/urllib3/packages/six.py,sha256=b9LM0wBXv7E7SrbCjAm4wwN-hrH-iNxv18LgWNMMKPo,34665
+pip/_vendor/urllib3/poolmanager.py,sha256=aWyhXRtNO4JUnCSVVqKTKQd8EXTvUm1VN9pgs2bcONo,19990
+pip/_vendor/urllib3/request.py,sha256=YTWFNr7QIwh7E1W9dde9LM77v2VWTJ5V78XuTTw7D1A,6691
+pip/_vendor/urllib3/response.py,sha256=fmDJAFkG71uFTn-sVSTh2Iw0WmcXQYqkbRjihvwBjU8,30641
+pip/_vendor/urllib3/util/__init__.py,sha256=JEmSmmqqLyaw8P51gUImZh8Gwg9i1zSe-DoqAitn2nc,1155
+pip/_vendor/urllib3/util/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/connection.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/proxy.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/queue.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/request.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/response.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/retry.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/timeout.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/url.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/wait.cpython-312.pyc,,
+pip/_vendor/urllib3/util/connection.py,sha256=5Lx2B1PW29KxBn2T0xkN1CBgRBa3gGVJBKoQoRogEVk,4901
+pip/_vendor/urllib3/util/proxy.py,sha256=zUvPPCJrp6dOF0N4GAVbOcl6o-4uXKSrGiTkkr5vUS4,1605
+pip/_vendor/urllib3/util/queue.py,sha256=nRgX8_eX-_VkvxoX096QWoz8Ps0QHUAExILCY_7PncM,498
+pip/_vendor/urllib3/util/request.py,sha256=C0OUt2tcU6LRiQJ7YYNP9GvPrSvl7ziIBekQ-5nlBZk,3997
+pip/_vendor/urllib3/util/response.py,sha256=GJpg3Egi9qaJXRwBh5wv-MNuRWan5BIu40oReoxWP28,3510
+pip/_vendor/urllib3/util/retry.py,sha256=6ENvOZ8PBDzh8kgixpql9lIrb2dxH-k7ZmBanJF2Ng4,22050
+pip/_vendor/urllib3/util/ssl_.py,sha256=QDuuTxPSCj1rYtZ4xpD7Ux-r20TD50aHyqKyhQ7Bq4A,17460
+pip/_vendor/urllib3/util/ssl_match_hostname.py,sha256=Ir4cZVEjmAk8gUAIHWSi7wtOO83UCYABY2xFD1Ql_WA,5758
+pip/_vendor/urllib3/util/ssltransport.py,sha256=NA-u5rMTrDFDFC8QzRKUEKMG0561hOD4qBTr3Z4pv6E,6895
+pip/_vendor/urllib3/util/timeout.py,sha256=cwq4dMk87mJHSBktK1miYJ-85G-3T3RmT20v7SFCpno,10168
+pip/_vendor/urllib3/util/url.py,sha256=lCAE7M5myA8EDdW0sJuyyZhVB9K_j38ljWhHAnFaWoE,14296
+pip/_vendor/urllib3/util/wait.py,sha256=fOX0_faozG2P7iVojQoE1mbydweNyTcm-hXEfFrTtLI,5403
+pip/_vendor/vendor.txt,sha256=43152uDtpsunEE29vmLqqKZUosdrbvzIFkzscLB55Cg,332
+pip/py.typed,sha256=EBVvvPRTn_eIpz5e5QztSCdrMX7Qwd7VP93RSoIlZ2I,286

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/WHEEL

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

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main

venv/lib/python3.12/site-packages/pip-24.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pip

venv/lib/python3.12/site-packages/pip/__init__.py

@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+__version__ = "24.3.1"
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is an internal API only meant for use by pip's own console scripts.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)