mycroftcompute 0.1.0__tar.gz

mycroftcompute-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.db
+.env
+.env.*
+.claude/

mycroftcompute-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya Negi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mycroftcompute-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.5
+Name: mycroftcompute
+Version: 0.1.0
+Summary: Where your Claude Code money went, priced with the prompt cache counted, and which changes would actually pay.
+Project-URL: Homepage, https://www.mycroftcompute.com
+Project-URL: Repository, https://github.com/negi6711/mycroftcompute
+Project-URL: Issues, https://github.com/negi6711/mycroftcompute/issues
+Author: Aditya Negi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,claude-code,cost,datadog,finops,grafana,llm,opentelemetry,prompt-caching
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# mycroftcompute
+
+**Where your Claude Code money went, priced with the prompt cache counted, and which changes would
+actually pay.**
+
+[ccusage](https://github.com/ccusage/ccusage) tells you what Claude Code cost you. mycroftcompute
+tells you what's worth changing, and what that change is worth at most.
+
+```sh
+uvx mycroftcompute            # read your own Claude Code history (~/.claude/projects)
+uvx mycroftcompute --sample   # or see the report for an invented 24-developer team
+```
+
+Python 3.12+, no dependencies. Nothing leaves your machine. `pipx install mycroftcompute` works
+too.
+
+## What a finding looks like
+
+From `--sample`:
+
+```
+FINDING 3 - 23.7% of your bill went on writing the prompt cache
+------------------------------------------------------------------------------------
+
+  What your metrics backend shows
+  - 608,889,600 tokens were written to the prompt cache, costing $3,069.00 at the
+    five-minute write rate - 23.7% of the $12,928.43 priced here. At the one-hour
+    rate the same writes would cost $4,910.40.
+  - 15,713,280,000 tokens were read back from cache, about 25.8 reads for every
+    token written.
+  - Read from cache instead of written, the same tokens would have cost $245.52.
+
+  At most $2,823.48 over this period
+    This is the gap between what these tokens cost and what they would cost under
+    the cheaper option. It is a ceiling, not a saving - see below.
+
+  What your metrics backend cannot tell you
+  - How many of these writes were a warm prefix written again - after a new session,
+    a compaction, a model switch, a change to the tools or system prompt, or a pause
+    longer than the cache lives - and how many were new context that had to be
+    written once. Only the first kind can be avoided ...
+```
+
+Every finding has the same three parts: what the data shows, the most a change could be worth,
+and what the data cannot tell you.
+
+## Why the cache changes the answer
+
+Claude Code already serves most of its input from the prompt cache, typically above 90%. So
+"turn caching on" is not the saving. What costs money is **writing** the cache: each write is
+billed above list price (1.25x for five minutes, 2x for an hour), and a model switch throws the
+warm cache away.
+
+That is why a cheaper model is not always cheaper. On a typical coding-agent step (about 141,000
+cached prompt tokens and 1,000 fresh ones):
+
+| Decision | Input cost per step |
+|---|---|
+| Stay on Sonnet 4.6, cache warm | $0.045 |
+| First request after moving to Haiku 4.5 | $0.177 - **3.9x worse** |
+| Every request after that, Haiku's cache warm | $0.015 - 3x better |
+| Alternating between the two | $0.426 - **9.4x worse** |
+
+The rule that falls out: choose the model when a session starts, then stay. Every router and
+dashboard compares list prices; mycroftcompute counts the cache before it suggests a model change.
+
+## What it finds
+
+| Finding | Fires when |
+|---|---|
+| **Cache writes** | Writing the cache is 20% or more of the bill. Ceiling: those tokens priced as reads instead. |
+| **Model switch, net of cache** | A cheaper model would cost less once its own cache is warm. |
+| **Housekeeping on an expensive model** | The agent's own background calls (`query_source = auxiliary`) run on a flagship model (team data: the label comes from telemetry). |
+| **Uncached input** | Less than half of input comes from cache, which is unusual for Claude Code. |
+| **Developer concentration** | A few people account for most of the spend (team data, 4+ developers). |
+| **Continuous usage** | Spend doesn't drop at weekends, so something automated is driving it (team data). |
+
+Run it again later with `--db history.db` and the report opens with **since last time**: what
+appeared, what stopped firing, and how each ceiling moved, comparing equal windows.
+
+## For a team: Grafana or Datadog
+
+If your team already sends Claude Code's telemetry to Grafana Cloud (or any Prometheus) or
+Datadog, mycroftcompute reads it with one read-only credential:
+
+```sh
+export MYCROFT_METRICS_TOKEN=glc_...            # Cloud Access Policy token, metrics:read
+mycroftcompute --grafana https://prometheus-prod-NN-....grafana.net/api/prom --user 123456 --discover
+mycroftcompute --grafana https://prometheus-prod-NN-....grafana.net/api/prom --user 123456 --days 14
+
+export MYCROFT_METRICS_TOKEN=...                # Datadog API key
+export MYCROFT_DATADOG_APP_KEY=...              # Application key: metrics_read, timeseries_query
+mycroftcompute --datadog us1 --days 14
+```
+
+`--discover` checks the connection and lists what the telemetry can and cannot support before
+reading any usage. Setup, including the two settings that silently lose every number, is in
+[docs/team-backends.md](docs/team-backends.md). For a two-minute check you can run inside Grafana
+or Datadog without installing anything, see [docs/cache-check.md](docs/cache-check.md).
+
+Both backends were verified against live Claude Code telemetry in September 2026.
+
+## How the numbers are made
+
+- **List prices**, checked by hand against each vendor's own pricing page, for 19 models from
+  Anthropic, OpenAI and Google, with cache read and write multipliers and per-model cache minimums.
+  Prices were last checked on **24 September 2026**; when the table is more than 31 days old the
+  report says so. Negotiated or batch rates are lower, so every figure is correspondingly high.
+- **Ceilings, not savings.** Each figure is the most a change could be worth over the period.
+  Ceilings overlap, so they are never added up.
+- **Your own transcripts** record each cache write's lifetime, so local reports price five-minute
+  and one-hour writes exactly. **Metrics backends** don't, so team reports price every write at
+  the cheaper five-minute rate and say so.
+- **Read-only.** It never reads prompts, responses or code from a backend, and never changes
+  anything. Credentials come from the environment and are only used to query.
+
+## Status
+
+A personal project. It started as the engine of a product for platform teams, which I stopped in
+October 2026; the analysis was worth keeping. The price table will age between updates, and the
+report tells you when it has.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff check src tests && uv run mypy
+```
+
+## License
+
+MIT

mycroftcompute-0.1.0/README.md

@@ -0,0 +1,133 @@
+# mycroftcompute
+
+**Where your Claude Code money went, priced with the prompt cache counted, and which changes would
+actually pay.**
+
+[ccusage](https://github.com/ccusage/ccusage) tells you what Claude Code cost you. mycroftcompute
+tells you what's worth changing, and what that change is worth at most.
+
+```sh
+uvx mycroftcompute            # read your own Claude Code history (~/.claude/projects)
+uvx mycroftcompute --sample   # or see the report for an invented 24-developer team
+```
+
+Python 3.12+, no dependencies. Nothing leaves your machine. `pipx install mycroftcompute` works
+too.
+
+## What a finding looks like
+
+From `--sample`:
+
+```
+FINDING 3 - 23.7% of your bill went on writing the prompt cache
+------------------------------------------------------------------------------------
+
+  What your metrics backend shows
+  - 608,889,600 tokens were written to the prompt cache, costing $3,069.00 at the
+    five-minute write rate - 23.7% of the $12,928.43 priced here. At the one-hour
+    rate the same writes would cost $4,910.40.
+  - 15,713,280,000 tokens were read back from cache, about 25.8 reads for every
+    token written.
+  - Read from cache instead of written, the same tokens would have cost $245.52.
+
+  At most $2,823.48 over this period
+    This is the gap between what these tokens cost and what they would cost under
+    the cheaper option. It is a ceiling, not a saving - see below.
+
+  What your metrics backend cannot tell you
+  - How many of these writes were a warm prefix written again - after a new session,
+    a compaction, a model switch, a change to the tools or system prompt, or a pause
+    longer than the cache lives - and how many were new context that had to be
+    written once. Only the first kind can be avoided ...
+```
+
+Every finding has the same three parts: what the data shows, the most a change could be worth,
+and what the data cannot tell you.
+
+## Why the cache changes the answer
+
+Claude Code already serves most of its input from the prompt cache, typically above 90%. So
+"turn caching on" is not the saving. What costs money is **writing** the cache: each write is
+billed above list price (1.25x for five minutes, 2x for an hour), and a model switch throws the
+warm cache away.
+
+That is why a cheaper model is not always cheaper. On a typical coding-agent step (about 141,000
+cached prompt tokens and 1,000 fresh ones):
+
+| Decision | Input cost per step |
+|---|---|
+| Stay on Sonnet 4.6, cache warm | $0.045 |
+| First request after moving to Haiku 4.5 | $0.177 - **3.9x worse** |
+| Every request after that, Haiku's cache warm | $0.015 - 3x better |
+| Alternating between the two | $0.426 - **9.4x worse** |
+
+The rule that falls out: choose the model when a session starts, then stay. Every router and
+dashboard compares list prices; mycroftcompute counts the cache before it suggests a model change.
+
+## What it finds
+
+| Finding | Fires when |
+|---|---|
+| **Cache writes** | Writing the cache is 20% or more of the bill. Ceiling: those tokens priced as reads instead. |
+| **Model switch, net of cache** | A cheaper model would cost less once its own cache is warm. |
+| **Housekeeping on an expensive model** | The agent's own background calls (`query_source = auxiliary`) run on a flagship model (team data: the label comes from telemetry). |
+| **Uncached input** | Less than half of input comes from cache, which is unusual for Claude Code. |
+| **Developer concentration** | A few people account for most of the spend (team data, 4+ developers). |
+| **Continuous usage** | Spend doesn't drop at weekends, so something automated is driving it (team data). |
+
+Run it again later with `--db history.db` and the report opens with **since last time**: what
+appeared, what stopped firing, and how each ceiling moved, comparing equal windows.
+
+## For a team: Grafana or Datadog
+
+If your team already sends Claude Code's telemetry to Grafana Cloud (or any Prometheus) or
+Datadog, mycroftcompute reads it with one read-only credential:
+
+```sh
+export MYCROFT_METRICS_TOKEN=glc_...            # Cloud Access Policy token, metrics:read
+mycroftcompute --grafana https://prometheus-prod-NN-....grafana.net/api/prom --user 123456 --discover
+mycroftcompute --grafana https://prometheus-prod-NN-....grafana.net/api/prom --user 123456 --days 14
+
+export MYCROFT_METRICS_TOKEN=...                # Datadog API key
+export MYCROFT_DATADOG_APP_KEY=...              # Application key: metrics_read, timeseries_query
+mycroftcompute --datadog us1 --days 14
+```
+
+`--discover` checks the connection and lists what the telemetry can and cannot support before
+reading any usage. Setup, including the two settings that silently lose every number, is in
+[docs/team-backends.md](docs/team-backends.md). For a two-minute check you can run inside Grafana
+or Datadog without installing anything, see [docs/cache-check.md](docs/cache-check.md).
+
+Both backends were verified against live Claude Code telemetry in September 2026.
+
+## How the numbers are made
+
+- **List prices**, checked by hand against each vendor's own pricing page, for 19 models from
+  Anthropic, OpenAI and Google, with cache read and write multipliers and per-model cache minimums.
+  Prices were last checked on **24 September 2026**; when the table is more than 31 days old the
+  report says so. Negotiated or batch rates are lower, so every figure is correspondingly high.
+- **Ceilings, not savings.** Each figure is the most a change could be worth over the period.
+  Ceilings overlap, so they are never added up.
+- **Your own transcripts** record each cache write's lifetime, so local reports price five-minute
+  and one-hour writes exactly. **Metrics backends** don't, so team reports price every write at
+  the cheaper five-minute rate and say so.
+- **Read-only.** It never reads prompts, responses or code from a backend, and never changes
+  anything. Credentials come from the environment and are only used to query.
+
+## Status
+
+A personal project. It started as the engine of a product for platform teams, which I stopped in
+October 2026; the analysis was worth keeping. The price table will age between updates, and the
+report tells you when it has.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+uv run ruff check src tests && uv run mypy
+```
+
+## License
+
+MIT

mycroftcompute-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "mycroftcompute"
+version = "0.1.0"
+description = "Where your Claude Code money went, priced with the prompt cache counted, and which changes would actually pay."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Aditya Negi" }]
+requires-python = ">=3.12"
+dependencies = []
+keywords = ["claude-code", "anthropic", "llm", "cost", "prompt-caching", "grafana", "datadog", "opentelemetry", "finops"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+    "Topic :: System :: Monitoring",
+]
+
+[project.urls]
+Homepage = "https://www.mycroftcompute.com"
+Repository = "https://github.com/negi6711/mycroftcompute"
+Issues = "https://github.com/negi6711/mycroftcompute/issues"
+
+[project.scripts]
+mycroftcompute = "mycroftcompute.__main__:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3",
+    "ruff>=0.8",
+    "mypy>=1.13",
+]
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mycroftcompute"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+extend-exclude = ["site-src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "BLE", "SIM", "N", "ASYNC", "S", "RUF"]
+ignore = ["S101", "E501"]
+
+[tool.ruff.lint.per-file-ignores]
+# Fake credentials in tests are the point of the test, not a leak.
+"tests/**" = ["S105", "S106"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+warn_unreachable = true
+mypy_path = "src"
+files = ["src", "tests"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

mycroftcompute-0.1.0/src/mycroftcompute/__main__.py

@@ -0,0 +1,282 @@
+"""Read Claude Code usage, price it with the prompt cache counted, and print what is worth changing.
+
+    mycroftcompute                         your own Claude Code history (~/.claude/projects)
+    mycroftcompute --sample                an invented 24-developer team, to see the report
+    mycroftcompute --grafana <url> --user <instance-id>
+    mycroftcompute --datadog eu1
+
+Credentials are read from the environment by default, never written anywhere, and used only to
+query. Nothing is uploaded, and nothing is stored unless you pass --db.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import tempfile
+from datetime import date, timedelta
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+from mycroftcompute import sample
+from mycroftcompute.analysis.findings import analyse
+from mycroftcompute.economics.prices import StalePriceTableError, verify_prices
+from mycroftcompute.parsers.claude_code import parse_claude_code
+from mycroftcompute.parsers.model import ParsedUsage, ParseError
+from mycroftcompute.report.readiness import render_readiness
+from mycroftcompute.report.text import render
+from mycroftcompute.sources.base import SourceError
+from mycroftcompute.sources.datadog import SITES, DatadogEndpoint, DatadogSource
+from mycroftcompute.sources.grafana import GrafanaSource, PrometheusEndpoint
+from mycroftcompute.store.history import (
+    Comparison,
+    compare,
+    load_pull,
+    open_store,
+    save,
+)
+
+PROG = "mycroftcompute"
+
+
+def _version() -> str:
+    try:
+        return version(PROG)
+    except PackageNotFoundError:
+        return "unknown"
+
+
+def default_transcripts() -> Path:
+    """Where Claude Code keeps its session files on this machine.
+
+    `CLAUDE_CONFIG_DIR` moves the whole ~/.claude directory, so it moves the transcripts too.
+    """
+    config = os.environ.get("CLAUDE_CONFIG_DIR")
+    base = Path(config).expanduser() if config else Path.home() / ".claude"
+    return base / "projects"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog=PROG,
+        description=(
+            "Where your Claude Code money went, priced with the prompt cache counted, and which "
+            "changes would actually pay. With no arguments it reads your own Claude Code history."
+        ),
+    )
+    parser.add_argument(
+        "path",
+        type=Path,
+        nargs="?",
+        help=(
+            "a directory of Claude Code transcripts. Defaults to ~/.claude/projects "
+            "(or $CLAUDE_CONFIG_DIR/projects)."
+        ),
+    )
+    parser.add_argument(
+        "--sample",
+        action="store_true",
+        help="print the report for an invented 24-developer team, to see what the report shows",
+    )
+    parser.add_argument("--version", action="version", version=f"{PROG} {_version()}")
+    metrics = parser.add_argument_group(
+        "reading a team's metrics backend",
+        "For a team that already sends Claude Code telemetry to Grafana or Datadog. Nothing is "
+        "uploaded; the backend is queried read-only.",
+    )
+    metrics.add_argument(
+        "--grafana",
+        metavar="URL",
+        help=(
+            "Prometheus-compatible query endpoint - Grafana Cloud, Grafana OSS or plain "
+            "Prometheus, e.g. https://prometheus-prod-01.grafana.net/api/prom"
+        ),
+    )
+    metrics.add_argument(
+        "--user",
+        metavar="ID",
+        help="Grafana Cloud metrics instance ID. Omit for an unauthenticated local Prometheus.",
+    )
+    metrics.add_argument(
+        "--token",
+        metavar="TOKEN",
+        help=(
+            "Cloud Access Policy token with the metrics:read scope. An ordinary Grafana API key "
+            "or service account token will not work for querying metrics. "
+            "Reads MYCROFT_METRICS_TOKEN if omitted, so it need not appear in shell history."
+        ),
+    )
+    metrics.add_argument(
+        "--datadog",
+        metavar="SITE",
+        nargs="?",
+        const="us1",
+        help=(
+            "read from Datadog instead. Takes the site your org is on ("
+            + ", ".join(sorted(SITES))
+            + "; default us1). If you pick the wrong one we will tell you which it is. "
+            "Needs --token as the API key and --app-key as the Application key."
+        ),
+    )
+    metrics.add_argument(
+        "--app-key",
+        metavar="KEY",
+        help=(
+            "Datadog Application key, scoped to metrics_read and timeseries_query. Reads "
+            "MYCROFT_DATADOG_APP_KEY if omitted. The API key goes in --token."
+        ),
+    )
+    metrics.add_argument(
+        "--days",
+        type=int,
+        default=30,
+        metavar="N",
+        help="how many days back to read (default 30)",
+    )
+    metrics.add_argument(
+        "--discover",
+        action="store_true",
+        help=(
+            "check the connection and stop: what we can see, what we cannot, and what each "
+            "blind spot costs. Run this first on a backend nobody has seen before."
+        ),
+    )
+    parser.add_argument(
+        "--db",
+        type=Path,
+        metavar="PATH",
+        help=(
+            "keep a history at this path and compare this read with the last one. Re-reading "
+            "overlapping days corrects them rather than double-counting."
+        ),
+    )
+    parser.add_argument(
+        "--today",
+        type=date.fromisoformat,
+        default=date.today(),
+        help="override today's date (used to judge how old the price table is)",
+    )
+    args = parser.parse_args(argv)
+
+    if args.grafana and args.datadog:
+        parser.error("read one backend at a time: --grafana or --datadog, not both")
+
+    if args.sample:
+        return _sample()
+
+    if args.grafana or args.datadog:
+        return _from_metrics(args)
+
+    path = args.path or default_transcripts()
+    if not path.exists():
+        print(
+            f"{PROG}: no Claude Code transcripts at {path}. Claude Code keeps them in "
+            "~/.claude/projects once you have used it; to read a team's Grafana or Datadog "
+            "instead, see --help. To see a report without any data, run with --sample.",
+            file=sys.stderr,
+        )
+        return 2
+
+    try:
+        parsed = parse_claude_code(path)
+    except ParseError as error:
+        print(f"{PROG}: {error.message}", file=sys.stderr)
+        return 1
+    return _emit(parsed, args.today, db=args.db)
+
+
+def _sample() -> int:
+    """The invented team's second month, with its comparison against the first."""
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "sample.db"
+        _first, second = sample.write_history(path)
+        connection = open_store(path)
+        try:
+            parsed = load_pull(connection, second)
+            since = compare(connection, second)
+        finally:
+            connection.close()
+    print(render(parsed, analyse(parsed), today=sample.GENERATED_ON, since=since))
+    print("\n(An invented team. The arithmetic is real.)")
+    return 0
+
+
+def _source(args: argparse.Namespace) -> GrafanaSource | DatadogSource:
+    """Whichever backend was asked for.
+
+    Credentials come from the environment by default. A key on the command line ends up in shell
+    history and in `ps` output, where it outlives the session and is readable by other users, so
+    the environment variable is the documented path and the flag is the convenience.
+    """
+    token = args.token or os.environ.get("MYCROFT_METRICS_TOKEN")
+    if args.datadog:
+        app_key = args.app_key or os.environ.get("MYCROFT_DATADOG_APP_KEY")
+        if not token or not app_key:
+            raise SourceError(
+                "missing_credentials",
+                "Datadog needs two keys: an API key (--token or MYCROFT_METRICS_TOKEN) and an "
+                "Application key (--app-key or MYCROFT_DATADOG_APP_KEY). The Application key is "
+                "the one that carries the scopes, and it needs metrics_read and "
+                "timeseries_query.",
+            )
+        return DatadogSource(DatadogEndpoint(api_key=token, app_key=app_key, site=args.datadog))
+    return GrafanaSource(PrometheusEndpoint(args.grafana, args.user, token))
+
+
+def _from_metrics(args: argparse.Namespace) -> int:
+    """Read from a metrics backend rather than local transcripts."""
+    try:
+        source = _source(args)
+
+        if args.discover:
+            where = f"Datadog ({args.datadog})" if args.datadog else args.grafana
+            print(render_readiness(source.discover(), where=where))
+            return 0
+
+        end = args.today
+        parsed = source.fetch(end - timedelta(days=args.days), end)
+    except SourceError as error:
+        print(f"{PROG}: {error.message}", file=sys.stderr)
+        return 1
+
+    return _emit(parsed, args.today, db=args.db, backend="datadog" if args.datadog else "grafana")
+
+
+def _emit(
+    parsed: ParsedUsage,
+    today: date,
+    *,
+    db: Path | None = None,
+    backend: str | None = None,
+) -> int:
+    """Render, warning first if the price table has aged.
+
+    Prices are checked by hand against each vendor's page, and this is a personal project, so the
+    table will age. An old table still gives the right shape and roughly the right money, so the
+    report prints, but with a warning above it that says how old the prices are.
+    """
+    analysis = analyse(parsed)
+    try:
+        verify_prices(today)
+    except StalePriceTableError as error:
+        print(
+            f"{PROG}: warning - the price table may be out of date, so dollar figures may be "
+            f"off.\n{error}\n",
+            file=sys.stderr,
+        )
+
+    since: Comparison | None = None
+    if db is not None:
+        connection = open_store(db)
+        try:
+            since = compare(connection, save(connection, parsed, analysis, backend=backend))
+        finally:
+            connection.close()
+
+    print(render(parsed, analysis, today=today, since=since))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mycroftcompute-0.1.0/src/mycroftcompute/analysis/__init__.py

@@ -0,0 +1 @@
+"""Turning parsed usage into findings a person can act on."""