rulesmith 0.1.0__py3-none-any.whl

rulesmith/calibrate.py

@@ -0,0 +1,457 @@
+"""Fitting how sure a judge should read, and measuring how often each rule is right. A model
+that says 0.97 and is right three times in five is overconfident, and a rule testing
+`confidence >= 0.9` on it means nothing. One temperature per question, fitted on labeled examples,
+makes its probabilities say what they claim. A rule claims nothing at all until it is measured:
+counted on labeled examples, its decisions are as sure as it was right, and inputs that reach it
+far more or less often than those did are no longer the inputs it was measured on. Where a rule
+draws its line on a judgment, `scam >= 0.5`, is a number the proposer guessed; fitted here, it is
+the line between the judge's answers that gets the most labeled examples right and holds up on
+examples held out of the fit."""
+
+import math
+from collections import Counter
+from dataclasses import dataclass
+
+from rulesmith.graph import (
+    All,
+    Any,
+    Call,
+    Choice,
+    Coalesce,
+    Compare,
+    Condition,
+    Confidence,
+    Measured,
+    NodeInput,
+    Not,
+    Noul,
+    Plan,
+    Score,
+    Task,
+    Threshold,
+    Value,
+)
+from rulesmith.runtime import (
+    DecisionProgram,
+    Models,
+    Prices,
+    calibrated,
+    sureness,
+)
+
+# Temperatures tried, evenly spaced in log from a fifth to five: calibration corrects a judge's
+# confidence, it does not invert it.
+TEMPERATURES = [math.exp(math.log(0.2) + index * (math.log(25) / 80)) for index in range(81)]
+
+
+def fit_temperature(pairs: list[tuple[dict[str, float], str]]) -> float:
+    """The temperature under which these answers give the right labels the most probability,
+    judged by log loss. `pairs` holds each answer's probabilities and the label that was right."""
+
+    def loss(temperature: float) -> float:
+        total = 0.0
+        for probabilities, right in pairs:
+            tempered = calibrated(
+                {"type": "choice", "value": right, "probabilities": probabilities}, temperature
+            )
+            total -= math.log(max(tempered["probabilities"][right], 1e-12))
+        return total
+
+    return round(min(TEMPERATURES, key=loss), 3)
+
+
+def calibrate(
+    plan: Plan, task: Task, client, model: str, models: Models | None = None
+) -> tuple[Plan, dict[str, float]]:
+    """The plan with a temperature fitted for every choice question over the task's labels, from
+    how its answers on the examples it is fitted on compare with their labels. Other questions
+    have no labels to be right about and keep theirs."""
+    fitted_nodes = {
+        name: node
+        for name, node in plan.nodes.items()
+        if isinstance(node, Call)
+        and isinstance(node.question, Choice)
+        and set(node.question.criteria) <= set(task.labels)
+    }
+    raw = plan.model_copy(
+        update={
+            "nodes": plan.nodes
+            | {
+                name: node.model_copy(update={"temperature": 1})
+                for name, node in fitted_nodes.items()
+            }
+        }
+    )
+    program = DecisionProgram(raw, client, model, models=models)
+    pairs: dict[str, list] = {name: [] for name in fitted_nodes}
+    for example in task.fitting():
+        answers = program(state=example.state).answers
+        for name, node in fitted_nodes.items():
+            if name in answers and example.label in node.question.criteria:
+                pairs[name].append((answers[name]["probabilities"], example.label))
+    temperatures = {name: fit_temperature(found) for name, found in pairs.items() if found}
+    nodes = plan.nodes | {
+        name: plan.nodes[name].model_copy(update={"temperature": temperature})
+        for name, temperature in temperatures.items()
+    }
+    return Plan.model_validate(plan.model_copy(update={"nodes": nodes}).model_dump()), temperatures
+
+
+@dataclass(frozen=True)
+class Cut:
+    """One numeric line a rule draws on a judgment: a `>=` or `<` in a rule's condition, reached
+    by `path` through its and/or/not groups, or a threshold node's cutoff (`path` None). `tests`
+    is the judgment or confidence the line is drawn on."""
+
+    node: str
+    path: tuple[int, ...] | None
+    tests: str
+
+    def value(self, plan: Plan) -> float:
+        if self.path is None:
+            return plan.nodes[self.node].cutoff
+        return descend(plan.nodes[self.node].when, self.path).value
+
+    def moved(self, plan: Plan, value: float) -> Plan:
+        """The plan with this line drawn at `value` and nothing else changed."""
+        data = plan.model_dump()
+        node = data["nodes"][self.node]
+        if self.path is None:
+            node["cutoff"] = value
+        else:
+            condition = node["when"]
+            for index in self.path:
+                condition = (
+                    condition["conditions"][index]
+                    if "conditions" in condition
+                    else condition["condition"]
+                )
+            condition["value"] = value
+        return Plan.model_validate(data)
+
+
+def descend(condition: Condition, path: tuple[int, ...]) -> Compare:
+    for index in path:
+        condition = (
+            condition.conditions[index]
+            if isinstance(condition, (All, Any))
+            else condition.condition
+        )
+    return condition
+
+
+def cuts(plan: Plan) -> list[Cut]:
+    """Every line a rule draws on a number the judge produced: a probability, a score's expected
+    level, or how sure a judgment was. Lines drawn on readings are what the rule says about the
+    input, not about the judge, and stay where they were written."""
+    judged = {
+        name
+        for name, node in plan.nodes.items()
+        if (isinstance(node, Call) and isinstance(node.question, (Noul, Score)))
+        or isinstance(node, Confidence)
+    }
+
+    def compares(condition: Condition, path: tuple[int, ...]):
+        if isinstance(condition, Compare):
+            if condition.op != "eq" and condition.node in judged:
+                yield path, condition.node
+        elif isinstance(condition, Not):
+            yield from compares(condition.condition, (*path, 0))
+        elif isinstance(condition, (All, Any)):
+            for index, child in enumerate(condition.conditions):
+                yield from compares(child, (*path, index))
+
+    found = []
+    for name, node in plan.nodes.items():
+        if isinstance(node, Threshold) and node.source in judged:
+            found.append(Cut(name, None, node.source))
+        if getattr(node, "when", None) is not None:
+            found += [Cut(name, path, tests) for path, tests in compares(node.when, ())]
+    return found
+
+
+FOLDS = 5
+
+
+def fit_cutoffs(
+    plan: Plan,
+    task: Task,
+    client,
+    model: str,
+    models: Models | None = None,
+    prices: Prices | None = None,
+) -> tuple[Plan, list[dict]]:
+    """The plan with every cut moved to where it gets the most fitting examples right, one cut
+    at a time, holding the questions and the rules' words still. A move is kept only when it
+    also wins held out: the fitting examples are dealt into folds, the best line is chosen
+    without each fold in turn and scored on it, and those scores together must beat the line as
+    it stands. One example on the far side of a line is not evidence to move it; a few are.
+    The report has a row per line: where it was and where it ended, how many places were tried,
+    the training accuracy just before and after its move, and whether it moved. A task with a
+    prevalence counts each example as the real traffic it stands for, so the line is placed for
+    the rate the graph will meet, not the rate the examples were sampled at. With `prices`, each
+    example also pays for the calls it made, so a line on how sure a small judge was is placed
+    where escalating to a dearer one pays, not wherever escalating is never worse."""
+    examples = task.fitting()
+    lines = cuts(plan)
+    if not examples or not lines:
+        return plan, []
+    weights = task.weights()
+    weight = [weights[e.label] for e in examples]
+    total = sum(weight)
+
+    prices = prices or Prices()
+
+    def right(candidate: Plan) -> list[float]:
+        decided = outcomes(candidate, examples, client, model, models)
+        return [
+            w * (record["correct"] - prices.charge(record["calls"]))
+            for w, record in zip(weight, decided, strict=True)
+        ]
+
+    seen = observed(plan, examples, client, model, models)
+    started = {cut: cut.value(plan) for cut in lines}
+    tried = dict.fromkeys(lines, 0)
+    after = right(plan)
+    change: dict[Cut, tuple[list[float], list[float]]] = {}
+    for _ in range(3):
+        moved = False
+        for cut in lines:
+            current = cut.value(plan)
+            candidates = midpoints(seen.get(cut.tests, []))
+            if not candidates:
+                continue
+            tried[cut] += len(candidates)
+            scores = {value: right(cut.moved(plan, value)) for value in candidates}
+            scores[current] = after
+            best = choose(scores, current)
+            if best != current and held_out_wins(scores, current, len(examples)):
+                change[cut] = (after, scores[best])
+                plan, after, moved = cut.moved(plan, best), scores[best], True
+        if not moved:
+            break
+    report = [
+        {
+            "rule": cut.node,
+            "tests": cut.tests,
+            "from": started[cut],
+            "to": cut.value(plan),
+            "tried": tried[cut],
+            "train_before": sum(change.get(cut, (after, after))[0]) / total,
+            "train_after": sum(change.get(cut, (after, after))[1]) / total,
+            "kept": cut.value(plan) != started[cut],
+        }
+        for cut in lines
+        if tried[cut]
+    ]
+    return plan, report
+
+
+def observed(
+    plan: Plan, examples: list, client, model: str, models: Models | None = None
+) -> dict[str, list[float]]:
+    """The numbers each judgment and confidence took on the examples, the values a line can be
+    drawn between."""
+    program = DecisionProgram(plan, client, model, models=models)
+    seen: dict[str, list[float]] = {}
+    for example in examples:
+        answers = program(state=example.state).answers
+        for name, node in plan.nodes.items():
+            if (
+                isinstance(node, Call)
+                and name in answers
+                and isinstance(node.question, (Noul, Score))
+            ):
+                seen.setdefault(name, []).append(answers[name]["value"])
+            if isinstance(node, Confidence) and node.source in answers:
+                seen.setdefault(name, []).append(sureness(answers[node.source]))
+    return seen
+
+
+def midpoints(values: list[float]) -> list[float]:
+    """A line between each pair of neighboring values, rounded where rounding still separates
+    them: any line between the same two answers decides the same examples, and a short number
+    reads as a choice rather than an accident."""
+    distinct = sorted(set(values))
+    found = []
+    for low, high in zip(distinct, distinct[1:], strict=False):
+        exact = (low + high) / 2
+        short = round(exact, 4)
+        found.append(short if low < short < high else exact)
+    return found
+
+
+def correct(
+    plan: Plan, examples: list, client, model: str, models: Models | None = None
+) -> list[bool]:
+    return [record["correct"] for record in outcomes(plan, examples, client, model, models)]
+
+
+def choose(scores: dict[float, list[float]], current: float, fold: int | None = None) -> float:
+    """The line with the most right answers, outside `fold` if one is named; among equals, the
+    one nearest to where the line stands, so a tie never moves it."""
+
+    def total(value: float) -> int:
+        return sum(right for index, right in enumerate(scores[value]) if index % FOLDS != fold)
+
+    return max(scores, key=lambda value: (total(value), -abs(value - current)))
+
+
+def held_out_wins(scores: dict[float, list[float]], current: float, count: int) -> bool:
+    """Whether choosing the line without each fold and scoring it on that fold beats, over all the
+    folds, the line as it stands."""
+    folds = min(FOLDS, count)
+    held_out = 0
+    for fold in range(folds):
+        chosen = choose(scores, current, fold)
+        held_out += sum(
+            right for index, right in enumerate(scores[chosen]) if index % FOLDS == fold
+        )
+    return held_out > sum(scores[current])
+
+
+def outcomes(
+    plan: Plan, examples: list, client, model: str, models: Models | None = None
+) -> list[dict]:
+    """Each labeled example as the plan decided it: the node that decided, the judgments asked,
+    and whether the answer was one the example accepts."""
+    program = DecisionProgram(plan, client, model, models=models)
+    found = []
+    for example in examples:
+        prediction = dict(program(state=example.state))
+        found.append(
+            {
+                "label": prediction.get("label"),
+                "decided_by": prediction.get("decided_by"),
+                "calls": prediction["calls"],
+                "correct": prediction.get("label") in (example.label, *example.accepted),
+            }
+        )
+    return found
+
+
+def tally(records: list[dict]) -> dict[str | None, tuple[int, int]]:
+    """For each node that decided an answer, how many of its answers were right and how many it
+    gave. A constant graph decides with no node, under None."""
+    counts: dict[str | None, tuple[int, int]] = {}
+    for record in records:
+        if record.get("label") is None:
+            continue
+        right, decided = counts.get(record["decided_by"], (0, 0))
+        counts[record["decided_by"]] = (right + bool(record["correct"]), decided + 1)
+    return counts
+
+
+def rules(plan: Plan) -> list[str]:
+    """The rules the label is decided by: every value or threshold in its list of fallbacks."""
+    source = plan.outputs["label"]
+    pending, found = [source.node] if isinstance(source, NodeInput) else [], []
+    while pending:
+        name = pending.pop(0)
+        node = plan.nodes[name]
+        if isinstance(node, Coalesce):
+            pending = list(node.sources) + pending
+        elif isinstance(node, (Value, Threshold)):
+            found.append(name)
+    return found
+
+
+def measure(plan: Plan, task: Task, client, model: str, models: Models | None = None) -> Plan:
+    """The plan with every rule that decides its label counted on the task's calibration
+    examples, or without those on its labeled training and validation examples. A rule decides
+    only some of them, so it is counted on all it can be; the training and validation examples
+    are ones search has seen, so those counts flatter a searched graph."""
+    examples = task.fitting()
+    if not task.calibration:
+        examples += [e for e in task.validation if e.label is not None]
+    if not examples or not rules(plan):
+        return plan
+    counts = tally(outcomes(plan, examples, client, model, models))
+    nodes = plan.nodes | {
+        name: plan.nodes[name].model_copy(
+            update={
+                "measured": Measured(
+                    right=counts.get(name, (0, 0))[0],
+                    decided=counts.get(name, (0, 0))[1],
+                    examples=len(examples),
+                )
+            }
+        )
+        for name in rules(plan)
+    }
+    return Plan.model_validate(plan.model_copy(update={"nodes": nodes}).model_dump())
+
+
+def unmeasured(plan: Plan) -> Plan:
+    """The plan without its rules' counts, which describe this graph and no rewrite of it."""
+    nodes = {
+        name: node.model_copy(update={"measured": None})
+        if isinstance(node, (Value, Threshold))
+        else node
+        for name, node in plan.nodes.items()
+    }
+    return plan.model_copy(update={"nodes": nodes})
+
+
+def binomial_p(count: int, trials: int, share: float) -> float:
+    """Exact two-sided binomial test: the chance, over `trials` examples each reaching a rule
+    with probability `share`, of a count no likelier than `count`."""
+    if share in (0, 1):
+        return float(count == trials * share)
+
+    def log_chance(k: int) -> float:
+        ways = math.lgamma(trials + 1) - math.lgamma(k + 1) - math.lgamma(trials - k + 1)
+        return ways + k * math.log(share) + (trials - k) * math.log1p(-share)
+
+    # A relative tolerance, as exact tests use, so a tie with the observed count is not lost
+    # to rounding.
+    observed = log_chance(count) + 1e-7
+    return min(1.0, sum(math.exp(c) for k in range(trials + 1) if (c := log_chance(k)) <= observed))
+
+
+def drift(plan: Plan, records: list[dict], alpha: float) -> list[dict]:
+    """Every measured rule these examples reach at a rate its measurement makes unlikely, below
+    `alpha`: the inputs have moved from the ones it was counted on, and so may how often it is
+    right."""
+    reached = Counter(record.get("decided_by") for record in records)
+    flagged = []
+    for name, node in plan.nodes.items():
+        measured = getattr(node, "measured", None)
+        if measured is None:
+            continue
+        p = binomial_p(reached[name], len(records), measured.share)
+        if p < alpha:
+            flagged.append(
+                {
+                    "rule": name,
+                    "measured_share": measured.share,
+                    "share": reached[name] / len(records),
+                    "p": p,
+                }
+            )
+    return flagged
+
+
+def at_prevalence(task: Task, records: list[dict]) -> dict | None:
+    """Accuracy, and each label's precision and recall, as they would be on real traffic: each
+    scored example counted as the share of it that its label stands for. None for a task with no
+    prevalence, whose examples are taken to be sampled as they come."""
+    if task.prevalence is None:
+        return None
+    weights = task.weights()
+    scored = [(r["expected"], r.get("label"), weights[r["expected"]]) for r in records]
+    total = sum(w for _, _, w in scored)
+    labels = {}
+    for label in task.labels:
+        hit = sum(w for e, a, w in scored if e == label and a == label)
+        answered = sum(w for _, a, w in scored if a == label)
+        present = sum(w for e, _, w in scored if e == label)
+        labels[label] = {
+            "precision": hit / answered if answered else None,
+            "recall": hit / present if present else None,
+        }
+    return {
+        "prevalence": task.prevalence,
+        "accuracy": sum(w for e, a, w in scored if e == a) / total,
+        "labels": labels,
+    }

rulesmith/chat_judge.py

@@ -0,0 +1,205 @@
+"""A judge reached through any OpenAI-compatible chat API, read from its log-probabilities.
+
+Each question is asked on its own, with its options lettered A, B, C and so on, for a single
+token. The probability of each option is the softmax of its letter's log-probability among the
+first token's most likely candidates, so an answer carries the same distribution a TypeSafe
+judge returns, and the runtime reads it the same way.
+"""
+
+import json
+import math
+import string
+import time
+from types import TracebackType
+from typing import Self
+
+import httpx
+from typesafe_sdk import (
+    ChoiceAnswer,
+    NoulAnswer,
+    RetryPolicy,
+    ScoreAnswer,
+    SystemOneResponse,
+    Usage,
+)
+
+LETTERS = string.ascii_uppercase
+# How many first-token candidates to ask for. OpenAI and vLLM allow 20, but mlx_lm.server
+# refuses more than 11 by dropping the connection; ten covers every score rubric and most
+# choices, and a letter beyond them is bounded by ABSENT_MARGIN.
+TOP_LOGPROBS = 10
+# A letter missing from the top candidates is less likely than every listed one by an unknown
+# amount. It is taken to sit this many nats below the least likely listed token: low enough to
+# rank under all of them, while still keeping a little probability, as the model would.
+ABSENT_MARGIN = 1.0
+SYSTEM = "You are a careful judge. Answer with exactly one letter, and nothing else."
+
+
+class ChatJudgeError(Exception):
+    """The chat API failed, or answered in a form a judgment cannot be read from."""
+
+
+def letter_probabilities(candidates: list[dict], count: int) -> list[float]:
+    """The probabilities of the first `count` letters, from the first token's top candidates."""
+    letters = LETTERS[:count]
+    found: dict[str, list[float]] = {}
+    for candidate in candidates:
+        # Some servers return raw tokenizer pieces, with the leading space spelled as byte-level
+        # BPE's "Ġ" or SentencePiece's "▁".
+        letter = candidate["token"].strip().lstrip("Ġ▁")
+        if letter in letters:
+            found.setdefault(letter, []).append(candidate["logprob"])
+    if not found:
+        likeliest = max(candidates, key=lambda candidate: candidate["logprob"])["token"]
+        raise ChatJudgeError(
+            "none of the option letters is among the model's most likely first tokens; it "
+            f"began with {likeliest!r}, as a model that thinks before answering does"
+        )
+    floor = min(candidate["logprob"] for candidate in candidates) - ABSENT_MARGIN
+    logits = [logsumexp(found[letter]) if letter in found else floor for letter in letters]
+    peak = max(logits)
+    weights = [math.exp(logit - peak) for logit in logits]
+    total = sum(weights)
+    return [weight / total for weight in weights]
+
+
+def logsumexp(values: list[float]) -> float:
+    peak = max(values)
+    return peak + math.log(sum(math.exp(value - peak) for value in values))
+
+
+# Confidence follows the formulas TypeSafe publishes in its MIT-licensed system-one-adapter (as
+# Ruling's calibration.py reimplements them), so it reads the same as a hosted judge's.
+def choice_confidence(probabilities: list[float]) -> float:
+    """How far the leading option stands above a uniform distribution, from 0 to 1."""
+    uniform = 1 / len(probabilities)
+    return (max(probabilities) - uniform) / (1 - uniform)
+
+
+def score_confidence(probabilities: list[float]) -> float:
+    """How tightly a score's mass sits around its modal level, from 0 to 1."""
+    mode = probabilities.index(max(probabilities))
+    spread = sum(p * abs(level - mode) for level, p in enumerate(probabilities))
+    middle = (len(probabilities) - 1) / 2
+    uniform_spread = sum(abs(level - middle) for level in range(len(probabilities)))
+    return max(0.0, 1 - spread * len(probabilities) / uniform_spread)
+
+
+def options(question: dict) -> list[str]:
+    """The options a question offers, in the order they are lettered."""
+    if question["type"] == "noul":
+        return ["True", "False"]
+    if question["type"] == "choice":
+        return [f"{label}: {meaning}" for label, meaning in question["criteria"].items()]
+    return list(question["criteria"])
+
+
+def prompt(state, question: dict) -> str:
+    shown = state if isinstance(state, str) else json.dumps(state, indent=2)
+    lettered = "\n".join(f"{LETTERS[i]}. {text}" for i, text in enumerate(options(question)))
+    heading = {
+        "noul": "Is the statement true of the input?",
+        "choice": "Options:",
+        "score": "Levels, from lowest to highest:",
+    }[question["type"]]
+    return (
+        f"Input:\n{shown}\n\n{question['instructions']}\n\n{heading}\n{lettered}\n\n"
+        "Answer with exactly one letter."
+    )
+
+
+def answer(question: dict, probabilities: list[float]):
+    if question["type"] == "noul":
+        return NoulAnswer(noul=probabilities[0])
+    if question["type"] == "choice":
+        labels = list(question["criteria"])
+        return ChoiceAnswer(
+            choice=labels[probabilities.index(max(probabilities))],
+            confidence=choice_confidence(probabilities),
+            probabilities=dict(zip(labels, probabilities, strict=True)),
+        )
+    return ScoreAnswer(
+        score=sum(level * p for level, p in enumerate(probabilities)),
+        confidence=score_confidence(probabilities),
+        legend=dict(enumerate(question["criteria"])),
+        probabilities=dict(enumerate(probabilities)),
+    )
+
+
+class ChatClient:
+    """Answers TypeSafe's System One questions through an OpenAI-compatible chat API."""
+
+    def __init__(self, *, base_url: str, api_key: str | None, timeout: float, retry: RetryPolicy):
+        # A local server needs no key, and an absent one is better than a made-up one.
+        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+        self.http = httpx.Client(base_url=base_url.rstrip("/"), headers=headers, timeout=timeout)
+        self.retry = retry
+
+    def system_one(self, *, state, questions: dict[str, dict], model: str) -> SystemOneResponse:
+        answers, served, input_tokens, output_tokens = {}, model, 0, 0
+        for key, question in questions.items():
+            count = len(options(question))
+            if count > len(LETTERS):
+                raise ChatJudgeError(
+                    f"question {key!r} has {count} options, and the chat judge letters at most "
+                    f"{len(LETTERS)}"
+                )
+            body = self.complete(model, prompt(state, question))
+            choice = body["choices"][0]
+            content = (choice.get("logprobs") or {}).get("content")
+            if not content or not content[0].get("top_logprobs"):
+                raise ChatJudgeError(
+                    f"{model} returned no log-probabilities; the openai backend needs a model "
+                    "that returns them, which reasoning models and some providers do not"
+                )
+            answers[key] = answer(question, letter_probabilities(content[0]["top_logprobs"], count))
+            served = body.get("model", served)
+            usage = body.get("usage") or {}
+            input_tokens += usage.get("prompt_tokens", 0)
+            output_tokens += usage.get("completion_tokens", 0)
+        return SystemOneResponse(
+            model=served,
+            usage=Usage(input_tokens=input_tokens, output_tokens=output_tokens),
+            answers=answers,
+        )
+
+    def complete(self, model: str, text: str) -> dict:
+        request = {
+            "model": model,
+            "messages": [{"role": "system", "content": SYSTEM}, {"role": "user", "content": text}],
+            "max_tokens": 1,
+            "temperature": 0,
+            "logprobs": True,
+            "top_logprobs": TOP_LOGPROBS,
+        }
+        attempt = 0
+        while True:
+            last = attempt == self.retry.max_retries
+            try:
+                response = self.http.post("/chat/completions", json=request)
+            except httpx.TransportError as error:
+                if last:
+                    raise ChatJudgeError(f"{self.http.base_url} is unreachable: {error}") from error
+            else:
+                if response.is_success:
+                    return response.json()
+                if last or response.status_code not in self.retry.http_statuses:
+                    raise ChatJudgeError(
+                        f"{self.http.base_url} answered {response.status_code}: {response.text}"
+                    )
+            time.sleep(min(self.retry.backoff_initial * 2**attempt, self.retry.backoff_max))
+            attempt += 1
+
+    def close(self) -> None:
+        self.http.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()