requests 2.34.2: Session

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify requests.Session in pkg:pypi/requests@2.34.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:pypi/requests@2.34.2
Demonstrate these symbols/APIs:
  - requests.Session

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:a3b4f21f87ab4591aca73d70610eb1c5f1c08539c1a26a41429075ed7f04823c","contract":["assert Session merges default session headers and query params with request-specific overrides","assert Session persists cookies received from server responses across subsequent requests","assert Session.prepare_request binds session auth headers and prepares request payload","assert Session mounts custom BaseAdapter instances and routes requests by URL prefix","assert Session executes registered response hook callbacks upon receiving responses","assert Session context manager closes mounted adapters upon exit"],"goal":"verify requests.Session in pkg:pypi/requests@2.34.2","kind":"HOW","packages":["pkg:pypi/requests@2.34.2"],"schemaVersion":1,"symbols":["requests.Session"]},"contractCommand":["python3","test/contract.py"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"pypi","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"pip","schemaVersion":1},"license":"MIT-0","packages":["pkg:pypi/requests@2.34.2"],"schemaVersion":1,"subject":"pkg:pypi/requests@2.34.2","symbols":["requests.Session"],"verifierAdapter":"python@1"}

[project]
name = "verify-requests-session"
version = "0.1.0"
dependencies = [
    "requests==2.34.2",
]

requests==2.34.2

{
  "schemaVersion": 1,
  "goal": "verify requests.Session in pkg:pypi/requests@2.34.2",
  "kind": "HOW",
  "packages": [
    "pkg:pypi/requests@2.34.2"
  ],
  "symbols": [
    "requests.Session"
  ]
}

import io
from http.client import HTTPMessage
import requests
from requests import Request, Session
from requests.adapters import BaseAdapter
from requests.models import Response


class MockRaw(io.BytesIO):
    def __init__(self, data, headers_dict=None):
        super().__init__(data)
        msg = HTTPMessage()
        if headers_dict:
            for k, v in headers_dict.items():
                msg[k] = v
        class Orig:
            pass
        self._original_response = Orig()
        self._original_response.msg = msg


class MockAdapter(BaseAdapter):
    def __init__(self):
        super().__init__()
        self.call_count = 0
        self.last_request = None
        self.closed = False

    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
        self.call_count += 1
        self.last_request = request

        resp = Response()
        resp.status_code = 200
        resp.url = request.url
        resp.request = request
        resp.headers = requests.structures.CaseInsensitiveDict({"Content-Type": "application/json"})

        if request.url.endswith("/login"):
            resp.headers["Set-Cookie"] = "session_token=secret123; Path=/"
            resp.raw = MockRaw(b'{"authenticated": true}', {"Set-Cookie": "session_token=secret123; Path=/"})
        elif request.url.endswith("/profile"):
            resp.raw = MockRaw(b'{"user": "alice"}')
        else:
            resp.raw = MockRaw(b'{"status": "ok"}')

        return resp

    def close(self):
        self.closed = True


def test_session_headers_and_params_merging():
    adapter = MockAdapter()
    with Session() as s:
        s.mount("http://example.com", adapter)
        s.headers.update({"X-Session-Header": "session-val", "X-Override": "initial"})
        s.params = {"session_key": "val1"}

        resp = s.get("http://example.com/api", headers={"X-Override": "custom"}, params={"req_key": "val2"})
        assert resp.status_code == 200
        assert resp.request.headers["X-Session-Header"] == "session-val"
        assert resp.request.headers["X-Override"] == "custom"
        assert "session_key=val1" in resp.request.url
        assert "req_key=val2" in resp.request.url


def test_session_cookie_persistence():
    adapter = MockAdapter()
    with Session() as s:
        s.mount("http://example.com", adapter)
        resp1 = s.get("http://example.com/login")
        assert resp1.status_code == 200
        assert s.cookies.get("session_token") == "secret123"

        resp2 = s.get("http://example.com/profile")
        assert resp2.status_code == 200
        assert "session_token=secret123" in resp2.request.headers.get("Cookie", "")


def test_session_prepare_request_and_auth():
    s = Session()
    s.auth = ("user1", "pass1")
    s.headers["X-App"] = "TestApp"
    req = Request("POST", "http://example.com/submit", data={"k": "v"})
    prep = s.prepare_request(req)

    assert prep.method == "POST"
    assert prep.url == "http://example.com/submit"
    assert prep.headers["X-App"] == "TestApp"
    assert "Authorization" in prep.headers
    assert prep.headers["Authorization"].startswith("Basic ")
    assert prep.body == "k=v"
    s.close()


def test_session_custom_adapter_mounting():
    adapter_a = MockAdapter()
    adapter_b = MockAdapter()
    with Session() as s:
        s.mount("http://service-a.example.com", adapter_a)
        s.mount("http://service-b.example.com", adapter_b)

        s.get("http://service-a.example.com/data")
        s.get("http://service-b.example.com/info")

        assert adapter_a.call_count == 1
        assert adapter_b.call_count == 1


def test_session_response_hooks():
    adapter = MockAdapter()
    hook_called = []

    def on_response(response, *args, **kwargs):
        hook_called.append(response.status_code)
        response.hook_executed = True
        return response

    with Session() as s:
        s.mount("http://example.com", adapter)
        s.hooks["response"].append(on_response)

        resp = s.get("http://example.com/test")
        assert resp.status_code == 200
        assert hook_called == [200]
        assert getattr(resp, "hook_executed", False) is True


def test_session_context_manager_close():
    adapter = MockAdapter()
    with Session() as s:
        s.mount("http://example.com", adapter)
        assert adapter.closed is False
    assert adapter.closed is True


def main():
    test_session_headers_and_params_merging()
    test_session_cookie_persistence()
    test_session_prepare_request_and_auth()
    test_session_custom_adapter_mounting()
    test_session_response_hooks()
    test_session_context_manager_close()
    print("ALL TESTS PASSED")


if __name__ == "__main__":
    main()