digline-bedrock 0.1.0__tar.gz

digline_bedrock-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python bytecode and build output
+__pycache__/
+*.py[cod]
+build/
+dist/
+*.egg-info/
+
+# Environment. Recreated by `uv sync`; it pins absolute paths, so it must
+# never be committed.
+.venv/
+.env
+
+# Tool caches. Each already drops its own `.gitignore`; listed here so a
+# fresh clone is clean before the tools have run once.
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# IDE. Excluded because the project files carry machine-specific SDK paths
+# (`digline.iml` names the interpreter by absolute path). Drop these two lines
+# to version the shared part, and keep ignoring `.idea/workspace.xml`.
+.idea/
+*.iml
+
+# Local Claude Code settings. `.claude/settings.json`, if it appears, is shared
+# and stays versioned. `CLAUDE.local.md` is the personal working agreement —
+# how I want to be worked with — as against `CLAUDE.md`, which is the project.
+.claude/settings.local.json
+CLAUDE.local.md
+
+# macOS
+.DS_Store
+
+# Working material that stays local and is not part of the package.
+private/
+
+# NOT ignored: `.digline/`. Decision 2 — baselines are versioned, run
+# artifacts are not — and the split is enforced one level down, by the
+# `.gitignore` the store itself writes into `.digline/` (`*/runs/`).
+# Ignoring `.digline/` here would take the baselines out of git with it.
+to-publish/

digline_bedrock-0.1.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.5
+Name: digline-bedrock
+Version: 0.1.0
+Summary: Amazon Bedrock target and judges for digline, on the Converse API.
+Author-email: Alessandro Prandini <alessandro.prandini@ict-group.it>
+License-Expression: Apache-2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: boto3>=1.35
+Requires-Dist: digline>=0.1.3
+Description-Content-Type: text/markdown
+
+# digline-bedrock
+
+An [Amazon Bedrock](https://aws.amazon.com/bedrock/) target **and judges** for
+[digline](https://pypi.org/project/digline/), on the Converse API: a prompt file
+goes in, a priced `Response` comes out.
+
+```sh
+pip install digline-bedrock
+```
+
+**Requires Python 3.12+**, like digline itself.
+
+## Quickstart
+
+No credential argument exists: the AWS chain — environment, profile, IAM role,
+instance metadata — is boto3's job, and this package never reads it.
+
+```python
+from digline_bedrock import BedrockTarget
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="eu.anthropic.claude-sonnet-4-20250514-v1:0",
+    max_tokens=1024,
+)
+```
+
+`model` takes a model id or an inference profile id. The **region** is resolved
+when the target is built — from `region=` if you pass one, otherwise from the
+client the chain produced — and the price list follows from it:
+
+```python
+from digline_bedrock import BedrockTarget
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    max_tokens=1024,
+    region="us-east-1",
+)
+```
+
+`target.region` is read-only, and that is the point: what was priced is what was
+called. A missing region fails **there**, when the target is built, not on case
+thirty-seven with thirty-six paid calls behind it.
+
+## The judges run in the same account
+
+A plugin is a target **and** a judge ([ADR
+0004](https://github.com/digline/digline/blob/main/docs/adr/0004-every-plugin-is-a-target-and-a-judge.md)),
+which on Bedrock is usually the whole reason the model is there: what a judge is
+sent is the model's *output*, and it stays inside the same account, the same
+region and the same IAM role.
+
+```python
+from digline.core import LlmRubric
+from digline_bedrock import BedrockJudge
+
+judge = BedrockJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0")
+rubric = LlmRubric(
+    rubric="The answer is one sentence and cites the passage it came from.",
+    judge=judge,
+    threshold=0.8,
+    tolerance=0.05,
+)
+```
+
+```python
+from digline.core import Faithfulness
+from digline_bedrock import BedrockClaimJudge
+
+faithful = Faithfulness(
+    judge=BedrockClaimJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0"),
+    threshold=0.9,
+    tolerance=0.05,
+)
+```
+
+Converse has no structured-output mode, so the reply shape is asked for in the
+system prompt and read back leniently — a fenced block or a sentence in front of
+the object both parse. What judging cost is counted on the judge and never
+reset:
+
+```python
+from digline_bedrock import BedrockJudge
+
+judge = BedrockJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0")
+print(f"{judge.calls} judgements, {judge.spent_usd:.4f} USD, {judge.latency_ms:.0f} ms")
+```
+
+## Prices, and what is not priced
+
+`bedrock_pricing(region)` is seeded for **us-east-1, us-west-2, eu-west-1,
+eu-central-1 and eu-west-3**, with the Anthropic models. Bedrock prices by model
+*and* by region, and a figure invented for a region nobody checked would be
+wrong in the direction nobody notices — so everything else raises at `preflight`
+and is served with one argument:
+
+```python
+from digline.targets import ModelPrice
+from digline_bedrock import BedrockTarget, bedrock_pricing
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="amazon.nova-pro-v1:0",
+    max_tokens=1024,
+    region="us-east-1",
+    pricing=bedrock_pricing("us-east-1").override(
+        "amazon.nova-pro-v1:0", ModelPrice(input_per_mtok=0.80, output_per_mtok=3.20)
+    ),
+)
+```
+
+An **application inference profile** is an ARN and is opaque: it is never in the
+list, fails `preflight`, and is served the same way. That is intended, not a
+gap — a run that cannot say what it cost must not run.
+
+A model you brought in through **Custom Model Import**, or one behind
+**Provisioned Throughput**, has no per-token bill at all: it is billed by
+model-copy-hour and model-unit-hour. Say so out loud rather than leaving it
+unpriced:
+
+```python
+from digline_bedrock import BedrockTarget, free
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="my-imported-model",
+    max_tokens=1024,
+    region="eu-west-1",
+    pricing=free("my-imported-model"),
+)
+```
+
+## The details that bite
+
+**Your account never leaves the machine.** A botocore failure names the assumed
+role — `arn:aws:sts::<account>:assumed-role/…` — and digline quotes a target's
+exception into the `reason` of every verdict of that case, which lands in a
+committed run file. So every AWS error is re-raised as `BedrockCallFailed` with
+ARNs and account ids removed; the original stays on `__cause__`, in memory, for
+a debugger.
+
+**Cached tokens.** Converse counts cached reads **beside** `inputTokens`, not
+inside them — measured against the API on 2026-08-28, not inferred from the
+field names: a warm call reported `inputTokens=10`, `cacheReadInputTokens=12002`
+and `totalTokens=12016`. So they are added rather than subtracted, which is the
+opposite of OpenAI's convention. It is one constant in `digline_bedrock.client`,
+re-measured by a live test, because getting it wrong is invisible in the
+direction of good news.
+
+**`additional_request_fields`** reaches Converse's
+`additionalModelRequestFields` and changes what the model does. It is **not**
+part of `config_hash` — no more than `temperature`, `model` or `max_tokens` are:
+the fingerprint covers the rules that judge a run, not the system being judged.
+Two runs differing only in these fields will read as "same configuration as the
+reference". If you need the difference to show, keep the fields in a file and
+declare it in `Suite.artifacts`, and the report carries the diff.
+
+Apache-2.0. Docs: [digline/digline](https://github.com/digline/digline).

digline_bedrock-0.1.0/README.md

@@ -0,0 +1,160 @@
+# digline-bedrock
+
+An [Amazon Bedrock](https://aws.amazon.com/bedrock/) target **and judges** for
+[digline](https://pypi.org/project/digline/), on the Converse API: a prompt file
+goes in, a priced `Response` comes out.
+
+```sh
+pip install digline-bedrock
+```
+
+**Requires Python 3.12+**, like digline itself.
+
+## Quickstart
+
+No credential argument exists: the AWS chain — environment, profile, IAM role,
+instance metadata — is boto3's job, and this package never reads it.
+
+```python
+from digline_bedrock import BedrockTarget
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="eu.anthropic.claude-sonnet-4-20250514-v1:0",
+    max_tokens=1024,
+)
+```
+
+`model` takes a model id or an inference profile id. The **region** is resolved
+when the target is built — from `region=` if you pass one, otherwise from the
+client the chain produced — and the price list follows from it:
+
+```python
+from digline_bedrock import BedrockTarget
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="us.anthropic.claude-haiku-4-5-20251001-v1:0",
+    max_tokens=1024,
+    region="us-east-1",
+)
+```
+
+`target.region` is read-only, and that is the point: what was priced is what was
+called. A missing region fails **there**, when the target is built, not on case
+thirty-seven with thirty-six paid calls behind it.
+
+## The judges run in the same account
+
+A plugin is a target **and** a judge ([ADR
+0004](https://github.com/digline/digline/blob/main/docs/adr/0004-every-plugin-is-a-target-and-a-judge.md)),
+which on Bedrock is usually the whole reason the model is there: what a judge is
+sent is the model's *output*, and it stays inside the same account, the same
+region and the same IAM role.
+
+```python
+from digline.core import LlmRubric
+from digline_bedrock import BedrockJudge
+
+judge = BedrockJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0")
+rubric = LlmRubric(
+    rubric="The answer is one sentence and cites the passage it came from.",
+    judge=judge,
+    threshold=0.8,
+    tolerance=0.05,
+)
+```
+
+```python
+from digline.core import Faithfulness
+from digline_bedrock import BedrockClaimJudge
+
+faithful = Faithfulness(
+    judge=BedrockClaimJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0"),
+    threshold=0.9,
+    tolerance=0.05,
+)
+```
+
+Converse has no structured-output mode, so the reply shape is asked for in the
+system prompt and read back leniently — a fenced block or a sentence in front of
+the object both parse. What judging cost is counted on the judge and never
+reset:
+
+```python
+from digline_bedrock import BedrockJudge
+
+judge = BedrockJudge(model="eu.anthropic.claude-haiku-4-5-20251001-v1:0")
+print(f"{judge.calls} judgements, {judge.spent_usd:.4f} USD, {judge.latency_ms:.0f} ms")
+```
+
+## Prices, and what is not priced
+
+`bedrock_pricing(region)` is seeded for **us-east-1, us-west-2, eu-west-1,
+eu-central-1 and eu-west-3**, with the Anthropic models. Bedrock prices by model
+*and* by region, and a figure invented for a region nobody checked would be
+wrong in the direction nobody notices — so everything else raises at `preflight`
+and is served with one argument:
+
+```python
+from digline.targets import ModelPrice
+from digline_bedrock import BedrockTarget, bedrock_pricing
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="amazon.nova-pro-v1:0",
+    max_tokens=1024,
+    region="us-east-1",
+    pricing=bedrock_pricing("us-east-1").override(
+        "amazon.nova-pro-v1:0", ModelPrice(input_per_mtok=0.80, output_per_mtok=3.20)
+    ),
+)
+```
+
+An **application inference profile** is an ARN and is opaque: it is never in the
+list, fails `preflight`, and is served the same way. That is intended, not a
+gap — a run that cannot say what it cost must not run.
+
+A model you brought in through **Custom Model Import**, or one behind
+**Provisioned Throughput**, has no per-token bill at all: it is billed by
+model-copy-hour and model-unit-hour. Say so out loud rather than leaving it
+unpriced:
+
+```python
+from digline_bedrock import BedrockTarget, free
+
+target = BedrockTarget(
+    "prompts/answer.md",
+    model="my-imported-model",
+    max_tokens=1024,
+    region="eu-west-1",
+    pricing=free("my-imported-model"),
+)
+```
+
+## The details that bite
+
+**Your account never leaves the machine.** A botocore failure names the assumed
+role — `arn:aws:sts::<account>:assumed-role/…` — and digline quotes a target's
+exception into the `reason` of every verdict of that case, which lands in a
+committed run file. So every AWS error is re-raised as `BedrockCallFailed` with
+ARNs and account ids removed; the original stays on `__cause__`, in memory, for
+a debugger.
+
+**Cached tokens.** Converse counts cached reads **beside** `inputTokens`, not
+inside them — measured against the API on 2026-08-28, not inferred from the
+field names: a warm call reported `inputTokens=10`, `cacheReadInputTokens=12002`
+and `totalTokens=12016`. So they are added rather than subtracted, which is the
+opposite of OpenAI's convention. It is one constant in `digline_bedrock.client`,
+re-measured by a live test, because getting it wrong is invisible in the
+direction of good news.
+
+**`additional_request_fields`** reaches Converse's
+`additionalModelRequestFields` and changes what the model does. It is **not**
+part of `config_hash` — no more than `temperature`, `model` or `max_tokens` are:
+the fingerprint covers the rules that judge a run, not the system being judged.
+Two runs differing only in these fields will read as "same configuration as the
+reference". If you need the difference to show, keep the fields in a file and
+declare it in `Suite.artifacts`, and the report carries the diff.
+
+Apache-2.0. Docs: [digline/digline](https://github.com/digline/digline).

digline_bedrock-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "digline-bedrock"
+version = "0.1.0"
+description = "Amazon Bedrock target and judges for digline, on the Converse API."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "Apache-2.0"
+authors = [
+    { name = "Alessandro Prandini", email = "alessandro.prandini@ict-group.it" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+dependencies = [
+    # Pinned to a version that exists, like the other two plugins: published,
+    # an unpinned `digline` would let a resolver pick something older than the
+    # API this plugin is written against — `JudgeBase` and its two subclasses
+    # are 0.1.3.
+    "digline>=0.1.3",
+    # boto3 and nothing else. No wrapper, no gateway: the Converse API is one
+    # call, and a layer on top would only add a second thing to be wrong.
+    "boto3>=1.35",
+]
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/digline_bedrock"]
+
+[tool.uv.sources]
+digline = { workspace = true }

digline_bedrock-0.1.0/src/digline_bedrock/__init__.py

@@ -0,0 +1,36 @@
+"""Amazon Bedrock target and judges for digline, on the Converse API.
+
+Installed beside digline, never inside it: `pip install digline` must not pull
+somebody's HTTP client along with it.
+
+A plugin is a target **and** a judge (ADR 0004), so a suite generates and judges
+inside one AWS account, in one region, under one IAM role — which for Bedrock is
+usually the whole reason the model is there.
+
+No credential ever reaches this package: the chain is boto3's job.
+"""
+
+from digline_bedrock.client import BedrockCallFailed, BedrockChat, scrub
+from digline_bedrock.judge import BedrockClaimJudge, BedrockJudge
+from digline_bedrock.pricing import (
+    BASE_PRICES,
+    PRICES_READ_ON,
+    SEEDED_REGIONS,
+    bedrock_pricing,
+    free,
+)
+from digline_bedrock.target import BedrockTarget
+
+__all__ = [
+    "BASE_PRICES",
+    "PRICES_READ_ON",
+    "SEEDED_REGIONS",
+    "BedrockCallFailed",
+    "BedrockChat",
+    "BedrockClaimJudge",
+    "BedrockJudge",
+    "BedrockTarget",
+    "bedrock_pricing",
+    "free",
+    "scrub",
+]