# uv is a fast Python package manager
# install: https://docs.astral.sh/uv/

# run Langflow without a manual venv
uvx langflow run

# or install into a project
uv pip install langflow
langflow run

# no Python setup needed - just Docker
docker run -it -p 7860:7860 langflowai/langflow:latest

# then open http://127.0.0.1:7860

def build_comparison(self):
    r1 = self._index(self.run1)   # {test_title: {status, retries}}
    r2 = self._index(self.run2)
    all_tests = sorted(set(r1) | set(r2))

    flaky, consistent_fail, retry_flaky, stable = [], [], [], []
    for t in all_tests:
        a  = r1.get(t, {}).get("status", "absent")
        b  = r2.get(t, {}).get("status", "absent")
        ra = r1.get(t, {}).get("retries", 0)
        rb = r2.get(t, {}).get("retries", 0)

        if {a, b} == {"passed", "failed"}:           # mixed across runs
            flaky.append(t)                          # -> FLAKY
        elif a == "failed" and b == "failed":        # failed in both
            consistent_fail.append(t)                # -> REAL BUG
        elif a == b == "passed" and (ra or rb):      # passed, but retried
            retry_flaky.append(t)                    # -> FLAKY
        elif a == b == "passed":
            stable.append(t)                         # -> STABLE
    return report(flaky, retry_flaky, consistent_fail, stable)

You are a senior test reliability engineer. You are given a comparison of two Playwright runs (Build 1 and Build 2) of the same suite.

COMPARISON REPORT:
{comparison}

Definitions you MUST follow:
- FLAKY = non-deterministic result: passed in one build and failed in the other, OR passed only after a retry. Flaky tests need a rerun / quarantine, not a code fix.
- CONSISTENT FAILURE = failed in BOTH builds. A real, reproducible bug, NOT flaky. Needs a fix.

Produce:
1. FLAKY_TESTS - names + one-line hypothesis of flake cause (timing, data, parallelism, network...).
2. CONSISTENT_FAILURES - tests failing in both builds, each with a probable root cause.
3. RERUN_RECOMMENDATION - which to rerun (flaky) vs send to engineering (bugs).
4. SUMMARY - counts + one sentence on suite health.

Base everything only on the comparison data. Do not invent test names.

def run_validation(self) -> Data:
    session = requests.Session()
    results, token = [], None

    # 1) AUTH FIRST - get the token. Restful Booker returns 200 even on
    #    bad credentials, so assert the token EXISTS, not just the status.
    auth = session.post(f"{self.base_url}/auth",
                        json={"username": self.username, "password": self.password},
                        timeout=self.timeout)
    token = auth.json().get("token")
    results.append({"name": "AUTH POST /auth", "actual_status": auth.status_code,
                    "passed": auth.status_code == 200 and token is not None})

    # 2) Run the rest of the plan IN ORDER, threading the token through.
    for req in self._plan():
        method, url = req["method"].upper(), req["url"]
        headers = dict(req.get("headers") or {})
        headers.setdefault("Accept", "application/json")
        # cookie auth ONLY on the mutating calls - exactly Restful Booker's contract
        if method in ("PUT", "PATCH", "DELETE") and token:
            headers["Cookie"] = f"token={token}"

        resp = session.request(method, url, headers=headers,
                               json=req.get("body"), timeout=self.timeout)
        expects = req.get("expects", {})
        status_ok = resp.status_code == expects.get("status", 200)
        # REAL schema validation - jsonschema, not the LLM guessing
        schema_ok, errors = self._validate(resp.json(), expects.get("schema_kind", "none"))
        results.append({"name": req["name"], "expected_status": expects.get("status"),
                        "actual_status": resp.status_code, "status_ok": status_ok,
                        "schema_ok": schema_ok, "errors": errors,
                        "passed": status_ok and schema_ok})
    return Data(data={"results": results})

firstname        string   (required)
lastname         string   (required)
totalprice       integer  (required)
depositpaid      boolean  (required)
bookingdates     object   (required)
  checkin        string  YYYY-MM-DD
  checkout       string  YYYY-MM-DD
additionalneeds  string   (optional)

You convert raw cURL commands into a clean JSON request plan for an API contract test runner.

CURL COMMANDS:
{curls}

For EACH cURL, extract: name, method, url, headers, body, and expects (status = expected HTTP code, schema_kind = auth | booking | create | none).

Rules:
- /auth -> status 200, schema_kind 'auth'.
- POST /booking -> status 200, schema_kind 'create' (response is wrapped: bookingid + booking).
- GET/PUT/PATCH /booking/{id} -> status 200, schema_kind 'booking'.
- DELETE /booking/{id} -> status 201, schema_kind 'none'.
- Do NOT add a Cookie/token header yourself - the runner injects the auth token automatically.
Return ONLY the structured plan. Do not execute anything.