turnloop 0.1.0__py3-none-any.whl

turnloop/experiments/suite/fixtures/circular_import/models.py

@@ -0,0 +1,11 @@
+"""The Order model."""
+
+
+class Order:
+    def __init__(self, order_id, total):
+        self.order_id = order_id
+        self.total = total
+        self.cancelled = False
+
+    def __repr__(self):
+        return f"Order({self.order_id!r}, total={self.total})"

turnloop/experiments/suite/fixtures/circular_import/services.py

@@ -0,0 +1,15 @@
+"""Order-processing services, built on top of the model in models.py."""
+
+from models import Order
+
+_ORDERS = {}
+
+
+def create_order(order_id, total):
+    order = Order(order_id, total)
+    _ORDERS[order_id] = order
+    return order
+
+
+def get_order(order_id):
+    return _ORDERS.get(order_id)

turnloop/experiments/suite/fixtures/circular_import/test_cancel.py

@@ -0,0 +1,12 @@
+from services import cancel_order, create_order, get_order
+
+
+def test_cancel_marks_order():
+    create_order("o1", 42)
+    cancel_order("o1")
+    assert get_order("o1").cancelled is True
+
+
+def test_create_leaves_order_active():
+    create_order("o2", 10)
+    assert get_order("o2").cancelled is False

turnloop/experiments/suite/fixtures/cli_flag/app.py

@@ -0,0 +1,16 @@
+import argparse
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(prog="app")
+    parser.add_argument("--name", default="world")
+    return parser
+
+
+def main():
+    args = build_parser().parse_args()
+    print(f"hello {args.name}")
+
+
+if __name__ == "__main__":
+    main()

turnloop/experiments/suite/fixtures/cross_file_contract/decode.py

@@ -0,0 +1,7 @@
+"""Decodes the wire format written by encode.py. See encode.py for the escaping rule."""
+
+
+def decode_tags(line):
+    if not line:
+        return []
+    return line.split(",")

turnloop/experiments/suite/fixtures/cross_file_contract/encode.py

@@ -0,0 +1,10 @@
+"""Encodes a list of tags into the wire format shared with decode.py.
+
+Tags are joined with `,`. A literal comma inside a tag must be escaped so
+decode.py can tell a separator from data — this module and decode.py have to
+change together if the escaping rule ever changes.
+"""
+
+
+def encode_tags(tags):
+    return ",".join(tags)

turnloop/experiments/suite/fixtures/cross_file_contract/test_roundtrip.py

@@ -0,0 +1,11 @@
+from decode import decode_tags
+from encode import encode_tags
+
+
+def test_round_trip_simple_tags():
+    assert decode_tags(encode_tags(["prod", "web"])) == ["prod", "web"]
+
+
+def test_round_trip_tag_with_comma():
+    tags = ["client,vip", "renewal"]
+    assert decode_tags(encode_tags(tags)) == tags

turnloop/experiments/suite/fixtures/cross_file_contract/test_wire_format.py

@@ -0,0 +1,7 @@
+from encode import encode_tags
+
+
+def test_plain_tags_encode_unescaped():
+    # No commas in the tags means no escaping is needed on the wire, and
+    # downstream consumers (a log shipper) parse this exact shape.
+    assert encode_tags(["prod", "web", "east"]) == "prod,web,east"

turnloop/experiments/suite/fixtures/empty/.keep

@@ -0,0 +1 @@
+

turnloop/experiments/suite/fixtures/failing_test/calc.py

@@ -0,0 +1,14 @@
+"""A small calculator with one genuine bug."""
+
+
+def add(a, b):
+    return a + b
+
+
+def average(values):
+    # The bug: an empty list should return 0.0, not raise.
+    return sum(values) / len(values)
+
+
+def percent_change(old, new):
+    return (new - old) / old * 100

turnloop/experiments/suite/fixtures/failing_test/test_calc.py

@@ -0,0 +1,17 @@
+from calc import add, average, percent_change
+
+
+def test_add():
+    assert add(2, 3) == 5
+
+
+def test_average():
+    assert average([1, 2, 3]) == 2
+
+
+def test_average_of_nothing_is_zero():
+    assert average([]) == 0.0
+
+
+def test_percent_change():
+    assert percent_change(100, 150) == 50

turnloop/experiments/suite/fixtures/generate_bulky.py

@@ -0,0 +1,80 @@
+"""Regenerates the `bulky` fixture used by the `forces_compaction` task.
+
+Why generated rather than hand-written: the fixture has to clear tier-3's
+threshold (see `turnloop/context/compaction.py`) by a comfortable margin, and
+hand-editing eight ~60KB files to hit a token target is exactly the kind of
+job a machine should do deterministically instead.
+
+Sizing arithmetic (verified against the real budget/compaction code, not
+guessed): on GLM-5.2's 65,536-token window, `available` (see
+`turnloop/context/budget.py`) works out to roughly 57k tokens, so tier 3
+fires at 0.75 * 57k =~ 43k tokens of history. Tier-1 micro-compaction (see
+`Compactor._micro_compact`) keeps the last `keep_recent_turns` (3) tool
+results in full and truncates everything older to `tool_result_cap` (800
+tokens on this small a window). That means the three most recent file reads
+alone have to clear ~43k tokens for compaction to ever trigger, regardless of
+how many older files get truncated away. At ~60,000 chars/file and the
+estimator's 3.6 chars/token (`turnloop/core/tokens.py`), one file is ~16,667
+tokens, so three of them are ~50,000 — comfortably past the threshold with
+room for estimator error.
+
+Run directly to regenerate: `python generate_bulky.py`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+OUT_DIR = Path(__file__).parent / "bulky"
+NUM_FILES = 8
+TARGET_CHARS = 60_000  # see module docstring for why this number
+TARGET_CONSTANT_FILE = 6  # 1-indexed; matches the existing `answer_contains` grader
+TARGET_CONSTANT_VALUE = 8675309
+
+# Plausible-sounding filler describing a fictional pipeline stage, so the file
+# is real parseable Python rather than lorem ipsum an agent could tell at a
+# glance is meaningless.
+PADDING = (
+    "In a real deployment this stage would validate the incoming record "
+    "against the upstream schema, apply any pending backfill corrections, "
+    "annotate it with a processing timestamp, and forward it to the next "
+    "stage's queue; here it only exists to give the fixture realistic bulk."
+)
+
+
+def _module_source(index: int) -> str:
+    lines = [f"# generated module {index}", ""]
+    n = 0
+    body = "\n".join(lines) + "\n"
+    while len(body) < TARGET_CHARS:
+        n += 1
+        lines.append(f"def helper_{index}_{n}(value):")
+        lines.append(
+            f'    """Helper {n} in module {index}. {PADDING}"""'
+        )
+        lines.append(f"    return value * {n} + {index}")
+        lines.append("")
+        body = "\n".join(lines) + "\n"
+
+    if index == TARGET_CONSTANT_FILE:
+        lines.append(f"TARGET_CONSTANT = {TARGET_CONSTANT_VALUE}")
+        lines.append("")
+        body = "\n".join(lines) + "\n"
+
+    return body
+
+
+def main() -> None:
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    for i in range(1, NUM_FILES + 1):
+        source = _module_source(i)
+        path = OUT_DIR / f"module_{i}.py"
+        # utf-8 without a BOM: a BOM here previously broke ast.parse with
+        # "invalid non-printable character U+FEFF" and looked like a real
+        # experiment failure.
+        path.write_bytes(source.encode("utf-8"))
+        assert len(source.splitlines()) < 2000, f"{path} exceeds the Read truncation limit"
+
+
+if __name__ == "__main__":
+    main()

turnloop/experiments/suite/fixtures/grep_edit/ingest.py

@@ -0,0 +1,5 @@
+def run_ingest(payload):
+    print("starting ingest")
+    result = {"stage": "ingest", "size": len(payload)}
+    print("finished ingest")
+    return result

turnloop/experiments/suite/fixtures/grep_edit/load.py

@@ -0,0 +1,5 @@
+def run_load(payload):
+    print("starting load")
+    result = {"stage": "load", "size": len(payload)}
+    print("finished load")
+    return result

turnloop/experiments/suite/fixtures/grep_edit/transform.py

@@ -0,0 +1,5 @@
+def run_transform(payload):
+    print("starting transform")
+    result = {"stage": "transform", "size": len(payload)}
+    print("finished transform")
+    return result

turnloop/experiments/suite/fixtures/misleading_traceback/checkout.py

@@ -0,0 +1,21 @@
+"""Checkout totals.
+
+`test_checkout.py::test_total_with_shipping_is_not_taxed` fails with a total
+that's too high. The traceback points at `total_with_tax` below, and the tax
+rate and rounding there are both correct. The defect is that `checkout_total`
+taxes the combined pretax figure from `pricing.py`, which includes shipping,
+instead of taxing the goods portion alone.
+"""
+
+from pricing import order_total_before_tax
+
+SALES_TAX_RATE = 8.5  # percentage points
+
+
+def total_with_tax(amount):
+    return round(amount * (1 + SALES_TAX_RATE / 100), 2)
+
+
+def checkout_total(subtotal, shipping=0):
+    pretax = order_total_before_tax(subtotal, shipping)
+    return total_with_tax(pretax)

turnloop/experiments/suite/fixtures/misleading_traceback/invoice.py

@@ -0,0 +1,8 @@
+"""Customer-facing invoice line, built on the same pricing helper as checkout."""
+
+from pricing import order_total_before_tax
+
+
+def invoice_pretax_line(subtotal, shipping=0):
+    """What the invoice shows as owed before tax: goods plus shipping."""
+    return order_total_before_tax(subtotal, shipping)

turnloop/experiments/suite/fixtures/misleading_traceback/pricing.py

@@ -0,0 +1,11 @@
+"""Order composition, shared by checkout and invoicing.
+
+`order_total_before_tax` is the combined amount a customer owes before tax:
+subtotal plus any shipping fee. Invoicing needs that combined figure to show
+what's due. Tax is a separate matter, though -- it is owed on the goods
+only, since shipping is a pass-through fee in this jurisdiction.
+"""
+
+
+def order_total_before_tax(subtotal, shipping=0):
+    return subtotal + shipping

turnloop/experiments/suite/fixtures/misleading_traceback/test_checkout.py

@@ -0,0 +1,12 @@
+from checkout import checkout_total
+
+
+def test_total_without_shipping():
+    # $100 of goods at 8.5% tax, no shipping.
+    assert checkout_total(100) == 108.50
+
+
+def test_total_with_shipping_is_not_taxed():
+    # $100 of goods plus a $10 pass-through shipping fee: tax applies to
+    # the $100 of goods only.
+    assert checkout_total(100, shipping=10) == 118.50

turnloop/experiments/suite/fixtures/misleading_traceback/test_invoice.py

@@ -0,0 +1,6 @@
+from invoice import invoice_pretax_line
+
+
+def test_invoice_pretax_includes_shipping():
+    # The invoice line shows what's owed before tax: goods plus shipping.
+    assert invoice_pretax_line(100, shipping=10) == 110

turnloop/experiments/suite/fixtures/needle/inventory.py

@@ -0,0 +1,18 @@
+"""Stock tracking. Correct."""
+
+WAREHOUSES = ["north", "south", "east", "west"]
+
+
+def total_stock(counts):
+    total = 0
+    for i in range(len(counts)):
+        total += counts[i]
+    return total
+
+
+def busiest(counts):
+    best = 0
+    for i in range(1, len(counts)):
+        if counts[i] > counts[best]:
+            best = i
+    return WAREHOUSES[best]

turnloop/experiments/suite/fixtures/needle/pricing.py

@@ -0,0 +1,17 @@
+"""Price bands. Contains the off-by-one error."""
+
+BANDS = [(0, 10, 1.0), (10, 50, 0.9), (50, 200, 0.8), (200, 10_000, 0.7)]
+
+
+def band_for(quantity):
+    # Off-by-one: the final band is never reachable because the loop stops one
+    # short of the end of BANDS.
+    for i in range(len(BANDS) - 1):
+        low, high, multiplier = BANDS[i]
+        if low <= quantity < high:
+            return multiplier
+    return 1.0
+
+
+def price(unit_cost, quantity):
+    return unit_cost * quantity * band_for(quantity)

turnloop/experiments/suite/fixtures/needle/shipping.py

@@ -0,0 +1,13 @@
+"""Shipping estimates. Correct."""
+
+ZONES = {"north": 4.5, "south": 5.0, "east": 6.25, "west": 7.0}
+
+
+def cost(zone, weight_kg):
+    base = ZONES.get(zone, 8.0)
+    return base + max(0.0, weight_kg - 1.0) * 1.25
+
+
+def cheapest_zones(limit):
+    ordered = sorted(ZONES.items(), key=lambda item: item[1])
+    return [name for name, _ in ordered[:limit]]

turnloop/experiments/suite/fixtures/regression_trap/test_validators.py

@@ -0,0 +1,14 @@
+from validators import is_valid_email, is_valid_username
+
+
+def test_username_rejects_dot():
+    assert not is_valid_username("bad.name")
+
+
+def test_username_rejects_at_sign():
+    assert not is_valid_username("bad@name")
+
+
+def test_email_local_part_allows_dot():
+    # "first.last@example.com" is a completely ordinary email address.
+    assert is_valid_email("first.last@example.com")

turnloop/experiments/suite/fixtures/regression_trap/validators.py

@@ -0,0 +1,23 @@
+"""Shared form-field validators.
+
+Usernames and the local part of an email address both get checked against a
+"token" shape, so they share one pattern.
+"""
+
+import re
+
+# Both usernames and email local-parts are checked against this pattern.
+_TOKEN_RE = re.compile(r"^[A-Za-z0-9_]+$")
+
+
+def is_valid_username(name):
+    """A username is 3-20 characters of letters, digits, or underscore only."""
+    return bool(_TOKEN_RE.match(name)) and 3 <= len(name) <= 20
+
+
+def is_valid_email(address):
+    """An email address is local@domain, where local reuses the username token rule."""
+    if "@" not in address:
+        return False
+    local, _, domain = address.partition("@")
+    return bool(_TOKEN_RE.match(local)) and "." in domain

turnloop/experiments/suite/fixtures/rename/billing.py

@@ -0,0 +1,7 @@
+def compute_total(items):
+    return sum(item["price"] * item["qty"] for item in items)
+
+
+def invoice(items, tax_rate=0.2):
+    subtotal = compute_total(items)
+    return subtotal * (1 + tax_rate)

turnloop/experiments/suite/fixtures/rename/report.py

@@ -0,0 +1,5 @@
+from billing import compute_total
+
+
+def summary(items):
+    return f"{len(items)} items, total {compute_total(items):.2f}"

turnloop/experiments/suite/fixtures/rename/test_billing.py

@@ -0,0 +1,11 @@
+from billing import compute_total, invoice
+
+ITEMS = [{"price": 2.0, "qty": 3}, {"price": 1.5, "qty": 2}]
+
+
+def test_compute_total():
+    assert compute_total(ITEMS) == 9.0
+
+
+def test_invoice():
+    assert invoice(ITEMS, 0.0) == 9.0

turnloop/experiments/suite/fixtures/spec/parser.py

@@ -0,0 +1,19 @@
+def parse_duration(text):
+    """Parse a duration string into seconds.
+
+    Accepts a number followed by a unit suffix: `s` for seconds, `m` for minutes,
+    `h` for hours, `d` for days. The number may be an integer or a decimal.
+    Whitespace around the value is ignored, and the suffix is case-insensitive.
+
+    A bare number with no suffix is interpreted as seconds.
+
+    Examples:
+        parse_duration("30s")   -> 30.0
+        parse_duration("1.5m")  -> 90.0
+        parse_duration(" 2H ")  -> 7200.0
+        parse_duration("45")    -> 45.0
+
+    Raises ValueError for an empty string, a non-numeric value, or an unknown
+    suffix.
+    """
+    raise NotImplementedError

turnloop/experiments/suite/fixtures/spec/test_parser.py

@@ -0,0 +1,28 @@
+import pytest
+from parser import parse_duration
+
+
+def test_seconds():
+    assert parse_duration("30s") == 30.0
+
+
+def test_decimal_minutes():
+    assert parse_duration("1.5m") == 90.0
+
+
+def test_uppercase_and_whitespace():
+    assert parse_duration(" 2H ") == 7200.0
+
+
+def test_days():
+    assert parse_duration("1d") == 86400.0
+
+
+def test_bare_number_is_seconds():
+    assert parse_duration("45") == 45.0
+
+
+@pytest.mark.parametrize("bad", ["", "abc", "10y", "s"])
+def test_invalid_raises(bad):
+    with pytest.raises(ValueError):
+        parse_duration(bad)

turnloop/experiments/suite/fixtures/subtle_spec_edge/leaderboard.py

@@ -0,0 +1,12 @@
+def best_scores(submissions):
+    """Reduce a stream of (player, score) submissions to one entry per player.
+
+    Each player's entry keeps their highest score across all of their
+    submissions. The result is ordered by each player's most recent
+    submission -- so a player who submitted early but submits again later
+    moves to that later position, even if the later submission didn't beat
+    their personal best.
+
+    Raises ValueError on an empty list.
+    """
+    raise NotImplementedError

turnloop/experiments/suite/fixtures/subtle_spec_edge/test_leaderboard.py

@@ -0,0 +1,28 @@
+import pytest
+from leaderboard import best_scores
+
+
+def test_single_submission():
+    assert best_scores([("ana", 10)]) == [("ana", 10)]
+
+
+def test_keeps_the_higher_score():
+    assert best_scores([("ana", 10), ("ana", 25)]) == [("ana", 25)]
+
+
+def test_orders_by_most_recent_submission():
+    # "ana" submits first, then "bo", then "ana" again -- "ana" moves to
+    # the position of her second (most recent) submission.
+    assert best_scores([("ana", 10), ("bo", 25), ("ana", 15)]) == [("bo", 25), ("ana", 15)]
+
+
+def test_a_later_lower_submission_still_moves_the_player():
+    # "ana"'s second submission is *worse* than her first, so her kept
+    # score is still 30 -- but her position still follows the later
+    # submission, independent of which one actually won.
+    assert best_scores([("ana", 30), ("bo", 5), ("ana", 2)]) == [("bo", 5), ("ana", 30)]
+
+
+def test_empty_raises():
+    with pytest.raises(ValueError):
+        best_scores([])

turnloop/experiments/suite/fixtures/util/util.py

@@ -0,0 +1,9 @@
+"""Small helpers."""
+
+
+def chunk(items, size):
+    return [items[i : i + size] for i in range(0, len(items), size)]
+
+
+def flatten(nested):
+    return [item for group in nested for item in group]