Prompts as Lossy Compression

## Required public API (must match exactly so automated tests can call it) Build a Python package named `grade_book` (importable as `import grade_book`) exposing exactly these functions at the package top level: - `letter_grade(score) -> str` — a numeric score to a letter grade - `grade_points(letter: str) -> float` — a letter grade to GPA grade points - `gpa(scores: list) -> float` — mean grade points across a list of scores Use only the Python standard library. Functions are called positionally (e.g. `letter_grade(91.5)`, `grade_points("B+")`, `gpa([95, 85, 75])`). # Grade book Build a grade calculator on a standard US letter-grade scale with +/- modifiers. - `letter_grade(score)` rounds the score to the nearest whole number, then maps it to a letter (A+ down to F) using conventional grade-band cutoffs. - `grade_points(letter)` returns the GPA points for a letter on the usual 4.0 scale. - `gpa(scores)` averages the grade points of the scores and rounds the result.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `grade_book` (importable as `import grade_book`) exposing exactly these functions at the package top level: - `letter_grade(score) -> str` — a numeric score to a letter grade - `grade_points(letter: str) -> float` — a letter grade to GPA grade points - `gpa(scores: list) -> float` — mean grade points across a list of scores Use only the Python standard library. Functions are called positionally (e.g. `letter_grade(91.5)`, `grade_points("B+")`, `gpa([95, 85, 75])`). # Grade book - `letter_grade(score)`: round the score to the nearest integer, then bucket by these cutoffs (minimum score for each letter): A+ 97, A 93, A- 90, B+ 87, B 83, B- 80, C+ 77, C 73, C- 70, D+ 67, D 63, D- 60, F below 60. - `grade_points(letter)`: A+ 4.0, A 4.0, A- 3.7, B+ 3.3, B 3.0, B- 2.7, C+ 2.3, C 2.0, C- 1.7, D+ 1.3, D 1.0, D- 0.7, F 0.0. - `gpa(scores)`: convert each score to a letter, then to grade points, average them, and round to 2 decimal places.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `grade_book` (importable as `import grade_book`) exposing exactly these functions at the package top level: - `letter_grade(score) -> str` — a numeric score to a letter grade - `grade_points(letter: str) -> float` — a letter grade to GPA grade points - `gpa(scores: list) -> float` — mean grade points across a list of scores Use only the Python standard library. Functions are called positionally (e.g. `letter_grade(91.5)`, `grade_points("B+")`, `gpa([95, 85, 75])`). # Grade book **Rounding rule:** wherever a value is rounded below, round half *up* (`decimal.ROUND_HALF_UP`), not banker's rounding. - `letter_grade(score)`: first round `score` to the nearest integer (ties up), then bucket by minimum-score cutoffs, highest first: A+ ≥97, A ≥93, A- ≥90, B+ ≥87, B ≥83, B- ≥80, C+ ≥77, C ≥73, C- ≥70, D+ ≥67, D ≥63, D- ≥60, otherwise F. Raise `ValueError` if score is outside 0..100. (So 96.5 → 97 → "A+"; 89.5 → 90 → "A-"; 72.5 → 73 → "C".) - `grade_points(letter)`: A+ 4.0, A 4.0, A- 3.7, B+ 3.3, B 3.0, B- 2.7, C+ 2.3, C 2.0, C- 1.7, D+ 1.3, D 1.0, D- 0.7, F 0.0. Note **A+ caps at 4.0** (not 4.3). Raise `ValueError` for an unknown letter. - `gpa(scores)`: map each score → letter → grade points, take the arithmetic mean, and round half-up to 2 decimals. An empty list returns 0.0.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `pricing_engine` (importable as `import pricing_engine`) exposing exactly these names at the package top level: - `LineItem(sku: str, qty: int, unit_price: Decimal)` - `Customer(id: str, tier: str)` — tier is one of "bronze", "silver", "gold" - `Order(customer: Customer, items: list[LineItem], region: str, coupon_code: str | None = None)` — region is one of "US-CA", "US-NY", "EU", "NONE" - `PricedOrder` with these fields, each a `Decimal`: `subtotal, volume_discount, tier_discount, coupon_discount, taxable_base, tax, total`, plus `lines`. - `PricingEngine` with a method `price_order(order: Order) -> PricedOrder`. All monetary values are `decimal.Decimal`. Constructors accept keyword arguments (e.g. `LineItem(sku="a", qty=1, unit_price=Decimal("9.99"))`). # Build a pricing engine Build an order-pricing engine. `price_order` runs this fixed pipeline, in order: 1. **Subtotal** = sum of `qty * unit_price` over all line items. 2. **Volume discount** on the subtotal, based on how large the subtotal is (bigger orders get a bigger percentage off). 3. **Customer-tier discount** applied to the amount remaining after the volume discount (gold customers get more off than silver; bronze gets none). 4. **Coupon discount** applied to the amount remaining after the tier discount, supporting a percentage-off code, a fixed-amount-off code, and a buy-one-get-one code. 5. **Sales tax** applied to the post-discount taxable base, at a rate that depends on the region. `total` = taxable base + tax. Populate every field of `PricedOrder` with the intermediate amounts. Money is rounded to 2 decimal places.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `pricing_engine` (importable as `import pricing_engine`) exposing exactly these names at the package top level: - `LineItem(sku: str, qty: int, unit_price: Decimal)` - `Customer(id: str, tier: str)` — tier is one of "bronze", "silver", "gold" - `Order(customer: Customer, items: list[LineItem], region: str, coupon_code: str | None = None)` — region is one of "US-CA", "US-NY", "EU", "NONE" - `PricedOrder` with these fields, each a `Decimal`: `subtotal, volume_discount, tier_discount, coupon_discount, taxable_base, tax, total`, plus `lines`. - `PricingEngine` with a method `price_order(order: Order) -> PricedOrder`. All monetary values are `decimal.Decimal`. Constructors accept keyword arguments (e.g. `LineItem(sku="a", qty=1, unit_price=Decimal("9.99"))`). # Build a pricing engine `price_order` runs this fixed pipeline, in order. Each step's rounded result feeds the next. 1. **Subtotal** = sum of `qty * unit_price` over all line items. 2. **Volume discount** on the subtotal. Highest matching threshold wins: - subtotal >= 10000 → 18% - subtotal >= 5000 → 12% - subtotal >= 1000 → 5% - otherwise 0% `after_volume = subtotal - volume_discount` 3. **Customer-tier discount** on `after_volume`: - bronze → 0%, silver → 3%, gold → 7% `after_tier = after_volume - tier_discount` 4. **Coupon discount** on `after_tier`: - `SAVE10` → 10% of `after_tier` - `FLAT50` → $50 off (but not more than `after_tier`) - `BOGO` → on the line with the lowest `unit_price`, `qty // 2` units are free (discount = that unit_price × free units) - any other code → no discount `taxable_base = after_tier - coupon_discount` 5. **Sales tax** on `taxable_base`, by region: - US-CA → 8.25%, US-NY → 8.875%, EU → 20%, NONE → 0% `total = taxable_base + tax`. All monetary amounts are rounded to 2 decimals.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `pricing_engine` (importable as `import pricing_engine`) exposing exactly these names at the package top level: - `LineItem(sku: str, qty: int, unit_price: Decimal)` - `Customer(id: str, tier: str)` — tier is one of "bronze", "silver", "gold" - `Order(customer: Customer, items: list[LineItem], region: str, coupon_code: str | None = None)` — region is one of "US-CA", "US-NY", "EU", "NONE" - `PricedOrder` with these fields, each a `Decimal`: `subtotal, volume_discount, tier_discount, coupon_discount, taxable_base, tax, total`, plus `lines`. - `PricingEngine` with a method `price_order(order: Order) -> PricedOrder`. All monetary values are `decimal.Decimal`. Constructors accept keyword arguments (e.g. `LineItem(sku="a", qty=1, unit_price=Decimal("9.99"))`). # Build a pricing engine `price_order` runs this fixed pipeline, in order. **Rounding rule (applies to every monetary quantity below):** round to exactly 2 decimal places using banker's rounding (`decimal.ROUND_HALF_EVEN`, i.e. `quantize(Decimal("0.01"), ROUND_HALF_EVEN)`). Each discount is rounded *before* it is subtracted, so each step consumes an already-rounded number. 1. **Subtotal** = `sum(unit_price * qty)` over all line items, then rounded. 2. **Volume discount** = `round(subtotal * rate)`, where `rate` is chosen by the highest matching threshold (check in this order, first match wins): - subtotal >= 10000 → 0.18 - subtotal >= 5000 → 0.12 - subtotal >= 1000 → 0.05 - else → 0.00 `after_volume = subtotal - volume_discount` 3. **Tier discount** = `round(after_volume * rate)`: - bronze → 0.00, silver → 0.03, gold → 0.07 `after_tier = after_volume - tier_discount` 4. **Coupon discount** on `after_tier` (rounded): - `SAVE10` → `round(after_tier * 0.10)` - `FLAT50` → `round(min(after_tier, 50.00))` (never discount more than the base) - `BOGO` → pick the line item with the lowest `unit_price` (if tie, any is fine); `free_units = that line's qty // 2` (integer floor division); discount = `round(that unit_price * free_units)` - missing coupon, or any unrecognized code → 0.00 (silently ignored) `taxable_base = after_tier - coupon_discount`; if this is negative, clamp it to 0.00. 5. **Tax** = `round(taxable_base * rate)` by region: - US-CA → 0.0825, US-NY → 0.08875, EU → 0.20, NONE → 0.00 `total = taxable_base + tax`. **Validation:** `LineItem` rejects `qty <= 0` and negative `unit_price` (raise `ValueError`); `Customer` rejects a tier not in {bronze, silver, gold}. Populate every `PricedOrder` field: `subtotal`, `volume_discount`, `tier_discount`, `coupon_discount`, `taxable_base`, `tax`, `total`, and `lines` (the list of input line items).

## Required public API (must match exactly so automated tests can call it) Build a Python package named `rbac` (importable as `import rbac`) exposing exactly these names at the package top level: - `Permission(action: str, resource: str, effect: str = "allow", conditions: dict | None = None)` — `action` is an action name (e.g. "read") or "*"; `resource` is a `:`-delimited pattern; `effect` is "allow" or "deny"; `conditions` maps context-key to required value. - `Role(name: str, permissions: list[Permission] = [], inherits: list[str] = [])` - `Principal(id: str, roles: list[str] = [], attributes: dict | None = None)` - `Decision` with fields: `allowed: bool`, `effect: str`, `matched: str`, `reason: str`. - `AuthorizationEngine(roles: list[Role])` with a method `check(principal: Principal, action: str, resource: str, context: dict | None = None) -> Decision`. All constructors accept keyword arguments (e.g. `Permission(action="read", resource="doc:*", effect="allow")`). Resources and patterns are `:`-delimited token strings such as `"doc:reports:q4"`. # Build an authorization engine Build a role-based access-control engine. A `Permission` grants or denies an `action` on a `resource` pattern, optionally gated by `conditions`. A `Role` bundles permissions and may inherit other roles. A `Principal` holds a set of roles. `check` decides whether a principal may perform an action on a resource. - **Resource patterns** are `:`-delimited. A `*` token is a wildcard; a trailing `*` matches any deeper path. - **Roles inherit** permissions from the roles they list in `inherits`, transitively. - **Conditions** are matched against a request context (the principal's attributes plus the `context` argument). - When several permissions match, the **most specific** one wins, and **deny** takes precedence over **allow** when they are equally specific. If nothing matches, the request is denied. Return a `Decision` recording whether it was `allowed`, the winning `effect`, which permission `matched`, and a short `reason`.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `rbac` (importable as `import rbac`) exposing exactly these names at the package top level: - `Permission(action: str, resource: str, effect: str = "allow", conditions: dict | None = None)` — `action` is an action name (e.g. "read") or "*"; `resource` is a `:`-delimited pattern; `effect` is "allow" or "deny"; `conditions` maps context-key to required value. - `Role(name: str, permissions: list[Permission] = [], inherits: list[str] = [])` - `Principal(id: str, roles: list[str] = [], attributes: dict | None = None)` - `Decision` with fields: `allowed: bool`, `effect: str`, `matched: str`, `reason: str`. - `AuthorizationEngine(roles: list[Role])` with a method `check(principal: Principal, action: str, resource: str, context: dict | None = None) -> Decision`. All constructors accept keyword arguments (e.g. `Permission(action="read", resource="doc:*", effect="allow")`). Resources and patterns are `:`-delimited token strings such as `"doc:reports:q4"`. # Build an authorization engine `check(principal, action, resource, context=None)` decides a request by collecting every permission that applies to the principal and resolving conflicts. Implement it as follows. **1. Effective permissions.** Collect the permissions of every role the principal holds, plus the permissions of roles reached transitively through `inherits`. Inheritance cycles must not loop forever (visit each role once). Role names that are not defined are ignored. **2. Which permissions apply.** A permission applies to the request when all of: - **Action matches:** `permission.action == action`, or `permission.action == "*"`. - **Resource matches:** patterns and resources are `:`-delimited token lists. A `*` token matches exactly one token. If the *last* pattern token is `*`, it is a prefix wildcard: the tokens before it must match and any remaining resource tokens are accepted (so `doc:*` matches `doc:reports:q4`). Otherwise the pattern and resource must have the same number of tokens. - **Conditions hold:** build a context mapping from the principal's `attributes` combined with the `context` argument, then every entry in `permission.conditions` must equal the matching value in that mapping. Empty conditions always hold. **3. Resolve conflicts.** Among the applying permissions, the **most specific** resource pattern wins — a pattern with more literal (non-`*`) tokens is more specific, and an exact pattern (no wildcard at all) beats one containing a wildcard. When the winning specificity is tied, **deny beats allow**. So a more specific *allow* overrides a less specific *deny* — this is most-specific-wins, not deny-overrides-everything. **4. Default.** If no permission applies, the request is denied. Return a `Decision` with `allowed` (true iff the winning effect is "allow"), the winning `effect`, a `matched` string identifying the deciding permission (or "<default>"), and a short `reason`.

## Required public API (must match exactly so automated tests can call it) Build a Python package named `rbac` (importable as `import rbac`) exposing exactly these names at the package top level: - `Permission(action: str, resource: str, effect: str = "allow", conditions: dict | None = None)` — `action` is an action name (e.g. "read") or "*"; `resource` is a `:`-delimited pattern; `effect` is "allow" or "deny"; `conditions` maps context-key to required value. - `Role(name: str, permissions: list[Permission] = [], inherits: list[str] = [])` - `Principal(id: str, roles: list[str] = [], attributes: dict | None = None)` - `Decision` with fields: `allowed: bool`, `effect: str`, `matched: str`, `reason: str`. - `AuthorizationEngine(roles: list[Role])` with a method `check(principal: Principal, action: str, resource: str, context: dict | None = None) -> Decision`. All constructors accept keyword arguments (e.g. `Permission(action="read", resource="doc:*", effect="allow")`). Resources and patterns are `:`-delimited token strings such as `"doc:reports:q4"`. # Build an authorization engine `check(principal, action, resource, context=None)` runs this exact procedure. **1. Effective permissions.** Starting from `principal.roles`, do a depth-first walk following each role's `inherits`. Visit each role at most once (so cycles terminate). Skip any role name not defined in the engine. Collect each visited role's permissions, remembering which role each came from. **2. Filter to applying permissions.** A permission applies iff all three hold: - **Action:** `permission.action == action` OR `permission.action == "*"`. - **Resource:** split both pattern and resource on `":"`. - If the pattern's **last** token is `"*"` (trailing/prefix wildcard): let `prefix = pattern_tokens[:-1]`. It matches iff `len(resource_tokens) >= len(prefix)` and, for each `i < len(prefix)`, `prefix[i] == "*"` or `prefix[i] == resource_tokens[i]`. (So `doc:*` matches `doc`, `doc:reports`, and `doc:reports:q4`; `*` matches everything.) - Otherwise: it matches iff the token counts are equal and each pattern token is `"*"` or equals the resource token at that position (so `doc:*:q4` matches `doc:reports:q4` but not `doc:reports:q3` or `doc:reports`). - **Conditions:** build `ctx = {**principal.attributes, **(context or {})}` — i.e. the principal's attributes overlaid by the `context` argument, with `context` winning on conflicts. Every key/value in `permission.conditions` must equal `ctx.get(key)`. Empty conditions always pass. **3. Rank and pick a winner.** For each applying permission compute the tuple ``` key = (literal_token_count, exact_flag, action_exact_flag, deny_flag) ``` where `literal_token_count` = number of pattern tokens that are not `"*"`; `exact_flag` = 1 if the pattern contains no `"*"` at all else 0; `action_exact_flag` = 1 if `permission.action != "*"` else 0; `deny_flag` = 1 if `effect == "deny"` else 0. The winner is the permission with the **largest** key (compare tuples left to right). This means: most literal tokens wins; then exact-over-wildcard; then exact-action-over-`*`; and finally, only as the last tie-break, **deny over allow**. **4. Decision.** - If at least one permission applies: `effect` = the winner's effect; `allowed = (effect == "allow")`; `matched` = a string identifying the winning permission (include its role, effect, action, and resource). - If none apply: `allowed = False`, `effect = "deny"`, `matched = "<default>"`. Always populate `Decision.reason` with a short human-readable explanation. **Validation.** `Permission` raises `ValueError` if `effect` is not "allow" or "deny". `Role` raises `ValueError` on an empty name. A `Permission` with `conditions=None` behaves as having no conditions; a `Principal` with `attributes=None` behaves as having empty attributes.