mostlyright-data 0.13.0__tar.gz → 0.14.0__tar.gz

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.13.0
+Version: 0.14.0
 Summary: Mostly Right CLI for reproducible, reviewed Parquet datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.13.0"
+version = "0.14.0"
 description = "Mostly Right CLI for reproducible, reviewed Parquet datasets"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/skills/mr-data-build/SKILL.md

@@ -525,6 +525,53 @@ which Studio fixes. Do it once per dataset, silently, and do not repeat it for a
 subject changed. A dataset presented without a cover is a defect, the same as a one-line
 description.
 
+### Say what each column shows
+
+Decide, per column, what a reader should see, and write it on the column as `presentation`. This is
+your judgement about the data and nobody else can make it: the Builder can see the values but not
+the question they were gathered to answer.
+
+    {
+      "name": "observed_on",
+      "type": "date",
+      "description": "The day the readings were taken.",
+      "presentation": {
+        "chart": "timeline",
+        "story": "The archive runs unbroken across three summer months.",
+        "bucket": "month"
+      }
+    }
+
+`chart` says what to draw and is one of `histogram`, `timeline`, `top_values`, `share` and `none`.
+Rules of thumb, and they hold most of the time:
+
+- Identifiers, free text, notes, anything one row carries its own copy of — `none`. Counting the
+  twelve commonest case numbers says only that the sample is a sample.
+- Measurements — `histogram`. Temperatures, prices, durations, counts of things.
+- Event times — `timeline`, with `bucket` matched to the grain the rows arrive at: hourly readings
+  get `hour` or `day`, a decade of annual filings gets `year`.
+- Categories — `top_values`. Cities, statuses, publishers, anything a reader would group by.
+- Flags — `share`. One split bar, the true part against the false part.
+
+`story` is the sentence a reader should be able to say after looking. Write it about the DATA —
+"rain is concentrated in a handful of days and most days record almost none" — and never about the
+chart, because the reader can see that it is a chart. Leave it out rather than write a caption.
+
+Every member is optional, including `presentation` itself. A column that says nothing still gets a
+chart: the Builder picks one from the type you declared and the dataset page says the choice was
+its own rather than yours. Say something anyway wherever you have an opinion — a column you
+thought about reads differently from one nobody did.
+
+Three things can make the Builder replace the chart you asked for, and each of them drops your
+`story` with it: a column that turns out to be entirely missing, an event time spanning more than
+twelve years (no grain draws that in twelve buckets), and a build whose sealed output type
+contradicts what the column declared. A `bucket` the span outgrew is not one of them — the grain
+is widened and the chart stays yours. So `none` is the right answer to write for a column you
+already know has no shape, and a wide date range is worth a thought before you promise a timeline.
+
+[The recipe document](../../docs/RECIPE-DOCUMENT.md) carries which types each chart admits, what
+the defaults are, and the two members only some charts take.
+
 ### What the statement must actually return
 
 Every acquired source is bound as all-text CSV — `read_csv(header = true, auto_detect = false,

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/src/mostlyright/data_harness/hosted_run_worker.py

@@ -1162,6 +1162,9 @@ def v4_artifact_payloads(
             workspace_id=job.workspace_id,
             run_id=job.run_id,
             candidate_digest=candidate_digest,
+            # The parsed document, not a second read of the bytes: the recipe is already in hand
+            # here, and a profile that re-read it could disagree with the run that produced it.
+            declared_columns={column.name: column for column in job.recipe.table.columns},
         ),
         "preview": _table_preview(snapshot["data/table.parquet"], candidate_digest),
         "receipt": _receipt_document(job, verified, coverage, raw_members, snapshot),

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/src/mostlyright/data_harness/hosted_worker.py

@@ -32,11 +32,11 @@ from collections.abc import Callable, Iterator, Mapping, Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass, replace
-from datetime import UTC, date, datetime
+from datetime import UTC, date, datetime, timedelta
 from decimal import Decimal
 from pathlib import Path, PurePosixPath
 from types import MappingProxyType
-from typing import Any, BinaryIO, ClassVar, NoReturn, Protocol
+from typing import TYPE_CHECKING, Any, BinaryIO, ClassVar, NoReturn, Protocol
 from urllib.parse import parse_qsl, urlsplit
 from uuid import UUID, uuid5
 
@@ -173,6 +173,11 @@ from mostlyright.data_harness.studio_boundary import (
     studio_wire_dict,
 )
 
+if TYPE_CHECKING:
+    # Type-only, and it has to be: ``v4_recipe`` reaches ``run_execution_v4``, which reaches this
+    # module, so a runtime import would close a cycle. The v4 caller passes the parsed objects in.
+    from mostlyright.data_harness.v4_recipe import V4Column
+
 JOB_SCHEMA = "mostlyright-hosted-worker-job.v3"
 AUTHENTICATED_JOB_SCHEMA = "mostlyright-hosted-worker-job.v4"
 GENERIC_AUTHENTICATED_JOB_SCHEMA = "mostlyright-hosted-worker-job.v5"
@@ -481,6 +486,87 @@ RELEASED_COLUMN_PROFILE_SCHEMA = "mostlyright.released-column-profile.v1"
 RELEASED_COLUMN_PROFILE_MEDIA_TYPE = "application/vnd.mostlyright.released-column-profile+json"
 MAX_RELEASED_COLUMN_PROFILE_BYTES = 4 * 1024 * 1024
 MAX_RELEASED_DISTRIBUTION_ITEMS = 12
+
+#: The grain one timeline bin covers, FINEST FIRST rather than sorted, because a default reads the
+#: sequence in this direction and picks the first grain the observed span fits inside.
+#:
+#: RESTATED HERE RATHER THAN IMPORTED, and held equal to the recipe's by test -- the same
+#: arrangement ``local_contracts`` already has for the source bindings, and for the same reason: a
+#: module-scope import of ``v4_recipe`` would close a cycle, since it reaches ``run_execution_v4``
+#: which reaches this module.
+TIMELINE_BUCKETS = ("hour", "day", "week", "month", "quarter", "year")
+
+#: How many bins a chart gets when the document asked for no particular number.  The ceiling is
+#: the item ceiling above, so a chart can never carry more marks than a distribution may hold.
+DEFAULT_DISTRIBUTION_BINS = 8
+
+#: Which chart each DECLARED column type is drawn as when the recipe named no chart for it.
+#:
+#: The declared type is the one to read wherever there is one: it is what the agent meant, and the
+#: engine narrows several declarations onto one sealed type.  ``json`` is the case that makes the
+#: difference visible -- it seals as text, and counting documents as if they were category labels
+#: is the mistake the recipe parser refuses to let anyone ask for explicitly.
+#:
+#: ``string`` is absent from both maps on purpose: it is the one type whose honest default depends
+#: on the values rather than on the type, because a country name repeated across a million rows is
+#: a category and a case identifier is not, and nothing but the observed spread separates them.
+_DEFAULT_CHART_BY_DECLARED_TYPE = {
+    "boolean": "share",
+    "date": "timeline",
+    "decimal": "histogram",
+    "float": "histogram",
+    "integer": "histogram",
+    "json": "none",
+    "timestamp": "timeline",
+}
+
+#: The same table against the type the ENGINE sealed, which is what the v3 producer path has: it
+#: carries no recipe, so there is no declaration to read and the sealed type is the whole of what
+#: is known about the column.
+_DEFAULT_CHART_BY_ENGINE_TYPE = {
+    "boolean": "share",
+    "date": "timeline",
+    "decimal": "histogram",
+    "float64": "histogram",
+    "int64": "histogram",
+    "null": "none",
+    "timestamp_utc": "timeline",
+}
+
+#: The widest a string column's values may spread before counting them stops meaning anything.
+#: Either bound admits the count: at most twelve distinct values is a category list whatever the
+#: row count, and at most half the rows being distinct is a category list however many there are.
+MAX_TOP_VALUES_DISTINCT_COUNT = MAX_RELEASED_DISTRIBUTION_ITEMS
+MAX_TOP_VALUES_DISTINCT_RATE_PPM = 500_000
+
+#: Which distribution each chart is drawn from.  ``share`` is a PRESENTATION of two counted values
+#: rather than a shape of its own: the frame draws one split bar, and what it draws from is the
+#: same value counts a category list is drawn from.
+_DISTRIBUTION_KIND_BY_CHART = {
+    "histogram": "histogram",
+    "none": "none",
+    "share": "value_counts",
+    "timeline": "timeline",
+    "top_values": "value_counts",
+}
+
+#: Every engine type this profile can describe.  ``string`` is missing from the default map above
+#: because its default is decided by the values rather than by its type; it belongs here because
+#: every chart that admits any type at all admits it.
+_PROFILE_ENGINE_TYPES = (*_DEFAULT_CHART_BY_ENGINE_TYPE, "string")
+
+#: Which engine types each chart can be drawn from at all.  The recipe parser already refuses a
+#: chart the DECLARED type cannot carry; this is the same rule stated against the type the engine
+#: actually sealed, so a declaration that outlived a plan whose output type moved falls back to the
+#: default rather than crashing inside a binning loop.
+_CHART_ENGINE_TYPES = {
+    "histogram": ("decimal", "float64", "int64"),
+    "none": _PROFILE_ENGINE_TYPES,
+    "share": ("boolean",),
+    "timeline": ("date", "timestamp_utc"),
+    "top_values": _PROFILE_ENGINE_TYPES,
+}
+
 MAX_HOSTED_DOWNLOAD_BYTES = (
     pipeline.MAX_CANDIDATE_BYTES + MAX_CANDIDATE_ENVELOPE_BYTES + MAX_TABLE_PREVIEW_BYTES
 )
@@ -4948,7 +5034,9 @@ def _nearest_rank_summary(values: list[int | float | Decimal]) -> dict[str, str]
     }
 
 
-def _histogram_distribution(values: list[int | float], distinct_count: int) -> dict[str, Any]:
+def _histogram_distribution(
+    values: list[int | float | Decimal], distinct_count: int, *, bins: int | None = None
+) -> dict[str, Any]:
     if not values:
         return {
             "kind": "histogram",
@@ -4962,7 +5050,7 @@ def _histogram_distribution(values: list[int | float], distinct_count: int) -> d
     if minimum == maximum:
         items = [{"label": _profile_value_text(minimum), "count": len(values)}]
     else:
-        bins = min(8, max(4, math.isqrt(len(values))))
+        bins = DEFAULT_DISTRIBUTION_BINS if bins is None else bins
         counts = [0] * bins
         items: list[dict[str, Any]] = []
         if all(isinstance(value, int) for value in values):
@@ -5050,6 +5138,203 @@ def _value_count_distribution(values: list[Any]) -> tuple[int, dict[str, Any]]:
     }
 
 
+def _none_distribution(distinct_count: int, observed_count: int) -> dict[str, Any]:
+    """The distribution of a column that is drawn as nothing, and says so.
+
+    An identifier or a paragraph of free text has a shape, and every shape a chart could draw over
+    it would be an artefact of which rows arrived rather than a fact about the data.  So the frame
+    carries no marks at all and the counts say why: everything distinct is hidden, and nothing is
+    shown.
+    """
+
+    return {
+        "kind": "none",
+        "status": "exact_all_rows",
+        "items": [],
+        "shown_distinct_count": 0,
+        "hidden_distinct_count": distinct_count,
+        "hidden_value_count": observed_count,
+    }
+
+
+_EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
+_ONE_HOUR = timedelta(hours=1)
+
+
+def _as_utc(value: date | datetime) -> datetime:
+    """One instant for a value that may be a day or a moment.
+
+    A ``date`` column and a ``timestamp_utc`` column reach this lane as different Python types and
+    are bucketed by the same arithmetic, so a day becomes the instant it starts.  A moment that
+    arrives with a zone is converted rather than stripped: dropping a ``+02:00`` would move an
+    event across a bucket boundary twice a year.
+    """
+
+    if isinstance(value, datetime):
+        return value.astimezone(UTC) if value.tzinfo is not None else value.replace(tzinfo=UTC)
+    return datetime(value.year, value.month, value.day, tzinfo=UTC)
+
+
+def _bucket_ordinal(moment: datetime, bucket: str) -> int:
+    """Which bucket one instant falls in, counted so that consecutive buckets are consecutive.
+
+    An ordinal rather than a start time, because what the timeline needs is the ability to walk
+    from the first observed bucket to the last WITHOUT skipping the empty ones -- and calendar
+    months and quarters are not a fixed number of seconds apart, so stepping by a duration would
+    drift.
+    """
+
+    if bucket == "hour":
+        # Floor division on the timedelta, never `int(total_seconds())`: truncation toward zero
+        # would put the last fractional second before the epoch in the hour after it.
+        return (moment - _EPOCH) // _ONE_HOUR
+    if bucket == "day":
+        return moment.date().toordinal()
+    if bucket == "week":
+        day = moment.date().toordinal()
+        return (day - moment.weekday() - 1) // 7
+    if bucket == "month":
+        return moment.year * 12 + moment.month - 1
+    if bucket == "quarter":
+        return moment.year * 4 + (moment.month - 1) // 3
+    return moment.year
+
+
+def _bucket_label(ordinal: int, bucket: str) -> str:
+    """The bucket's START, in ISO-8601, and never a range.
+
+    A label naming only where a bucket begins is what lets a reader put two timelines beside each
+    other: ranges would have to agree about whether the end is inclusive, and one that disagreed
+    would look like a different bucket rather than a different convention.
+    """
+
+    if bucket == "hour":
+        return (_EPOCH + timedelta(hours=ordinal)).strftime("%Y-%m-%dT%H:00Z")
+    if bucket == "day":
+        return date.fromordinal(ordinal).isoformat()
+    if bucket == "week":
+        return date.fromordinal(ordinal * 7 + 1).isoformat()
+    if bucket == "month":
+        return date(ordinal // 12, ordinal % 12 + 1, 1).isoformat()
+    if bucket == "quarter":
+        return date(ordinal // 4, (ordinal % 4) * 3 + 1, 1).isoformat()
+    return date(ordinal, 1, 1).isoformat()
+
+
+def _timeline_bucket(
+    earliest: datetime, latest: datetime, declared: str | None, bins: int | None
+) -> str | None:
+    """The grain this column is drawn at, or ``None`` when no grain in the vocabulary fits.
+
+    THE DEFAULT IS THE FINEST GRAIN THAT FITS, not the one that reads most naturally: a week of
+    readings drawn per year is one bar, and a bar is not a timeline.  A DECLARED grain is used when
+    the observed span fits inside it and widened when it does not -- a document written before the
+    data arrived cannot know how far the values would spread, and a chart with two hundred marks is
+    not the chart it asked for either.
+
+    ``bins`` LOWERS THE CEILING AND CANNOT TURN THE CHART OFF.  It is a preference for a coarser
+    reading, so a span that fits under it is drawn under it; a span that fits under no grain at
+    that ceiling is drawn at the finest grain that fits under the profile's own twelve.  Letting a
+    stated four make a five-year series undrawable would turn a request to read a chart differently
+    into a request not to have one.
+
+    ``None`` is therefore reached only by a span twelve buckets of the coarsest grain cannot cover
+    -- more than twelve years -- and the caller draws nothing rather than a timeline whose buckets
+    are a lie about their own width.
+
+    THE TWO ENDS DECIDE, not every value.  ``_bucket_ordinal`` rises with the moment, so the
+    earliest and latest values bound the bucket count at every grain; trying six grains over ten
+    million rows would otherwise walk the column six times to learn what two values already say.
+    """
+
+    start = TIMELINE_BUCKETS.index(declared) if declared else 0
+    ceilings = (
+        (MAX_RELEASED_DISTRIBUTION_ITEMS,)
+        if bins is None
+        else (bins, MAX_RELEASED_DISTRIBUTION_ITEMS)
+    )
+    for ceiling in ceilings:
+        for bucket in TIMELINE_BUCKETS[start:]:
+            width = _bucket_ordinal(latest, bucket) - _bucket_ordinal(earliest, bucket) + 1
+            if width <= ceiling:
+                return bucket
+    return None
+
+
+def _timeline_distribution(
+    values: list[date | datetime], distinct_count: int, bucket: str
+) -> dict[str, Any]:
+    """Contiguous buckets from the first observed one to the last, empty ones included.
+
+    THE EMPTY BUCKETS ARE THE POINT.  A distribution that listed only the buckets something landed
+    in would draw a gap as if it were not there, and "nothing arrived for three days" is usually
+    the most interesting thing a timeline has to say.
+
+    The counter is fed from a generator rather than from a list of converted moments: a column may
+    carry ten million rows, and a second full-length list of freshly allocated instants beside the
+    one already in memory is peak memory this lane has no use for.
+    """
+
+    counts = Counter(_bucket_ordinal(_as_utc(value), bucket) for value in values)
+    items = [
+        {"label": _bucket_label(ordinal, bucket), "count": counts[ordinal]}
+        for ordinal in (range(min(counts), max(counts) + 1) if counts else ())
+    ]
+    return {
+        "kind": "timeline",
+        "status": "exact_all_rows",
+        "bucket": bucket,
+        "items": items,
+        "shown_distinct_count": distinct_count,
+        "hidden_distinct_count": 0,
+        "hidden_value_count": 0,
+    }
+
+
+def _default_chart(
+    engine_type: str, declared_type: str | None, distinct_count: int, distinct_rate_ppm: int
+) -> str:
+    """What a column is drawn as when the recipe named no chart for it.
+
+    THE DECLARED TYPE IS READ WHEREVER THERE IS ONE.  It is what the agent meant, and the engine
+    narrows several declarations onto one sealed type -- ``json`` most visibly, which seals as text
+    and would otherwise be counted as if its documents were category labels.  The v3 producer path
+    carries no recipe, passes ``None``, and reads the sealed type alone.
+
+    A DECLARATION THE SEALED TYPE CONTRADICTS IS NOT FOLLOWED.  The engine holds a build to its
+    declared output types, so the two agreeing is the ordinary case; where they do not, what
+    arrived is what can honestly be drawn, and binning text would be a crash rather than a chart.
+    """
+
+    if declared_type is not None:
+        wanted = _from_type(
+            _DEFAULT_CHART_BY_DECLARED_TYPE, declared_type, distinct_count, distinct_rate_ppm
+        )
+        if engine_type in _CHART_ENGINE_TYPES[wanted]:
+            return wanted
+    return _from_type(_DEFAULT_CHART_BY_ENGINE_TYPE, engine_type, distinct_count, distinct_rate_ppm)
+
+
+def _from_type(
+    charts: Mapping[str, str], name: str, distinct_count: int, distinct_rate_ppm: int
+) -> str:
+    """One type's default, with the one rule that is a measurement rather than a lookup.
+
+    Text is the only type whose honest default depends on the values: a count of the twelve
+    commonest case identifiers says only that the sample is a sample, and a count of the twelve
+    commonest countries is the whole column.
+    """
+
+    if name != "string":
+        return charts.get(name, "none")
+    if (
+        distinct_count <= MAX_TOP_VALUES_DISTINCT_COUNT
+        or distinct_rate_ppm <= MAX_TOP_VALUES_DISTINCT_RATE_PPM
+    ):
+        return "top_values"
+    return "none"
+
+
 def _column_lineage(lineage: Any, name: str) -> tuple[list[dict[str, str]], list[str]]:
     if not isinstance(lineage, dict):
         raise HostedWorkerError("COLUMN_PROFILE_INVALID", "sealed lineage is not an object")
@@ -5103,6 +5388,92 @@ def _column_lineage(lineage: Any, name: str) -> tuple[list[dict[str, str]], list
     return source_inputs, list(operations)
 
 
+def _column_presentation(
+    engine_type: str,
+    declared: V4Column | None,
+    *,
+    values: list[Any],
+    distinct_count: int,
+    distinct_rate_ppm: int,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """Decide what one column is drawn as, and draw it.
+
+    **THE DOCUMENT DECIDES AND THE PRODUCER FALLS BACK.**  An agent that wrote the recipe knows
+    what the column is for and says so; nothing here is inferred where a declaration exists.  Where
+    none exists, the producer picks the honest chart for the type rather than leaving the column
+    blank, and the echo records which of the two happened -- a reader who cannot tell a decision
+    from a default cannot tell how much the chart is worth.
+
+    A declaration is followed as far as the values allow and no further.  A declared grain the
+    observed span outgrew is widened to the finest grain that fits, which leaves the chart the
+    document asked for intact.  A chart the sealed type cannot carry, a timeline over a span no
+    grain in the vocabulary covers, and a column where nothing at all was observed are the three
+    ways a declared chart is DISCARDED rather than adjusted.
+
+    ``source`` SAYS WHETHER THE CHART THAT WAS DRAWN IS THE ONE THE DOCUMENT ASKED FOR, and it is
+    derived from exactly that comparison rather than assigned by whichever branch got there.  A
+    discarded declaration takes its story with it: the sentence was written about a chart nobody
+    is looking at, and a caption under the wrong picture is worse than no caption.  What grain a
+    timeline was drawn at is on the DISTRIBUTION, which is the only place a reader reads it from
+    and is why the echo carries no second copy of it.
+
+    **NOTHING OBSERVED IS DRAWN AS NOTHING, WHATEVER THE TYPE.**  An all-null column has no shape,
+    and an empty histogram or a timeline of no buckets invites a reader to look for one.
+    """
+
+    presented = declared.presentation if declared is not None else None
+    # ``wanted`` is the declaration where the drawing can honour it and ``None`` everywhere else,
+    # so the chart, the bins and the grain read one answer rather than three conditions.
+    wanted = (
+        presented
+        if presented is not None and engine_type in _CHART_ENGINE_TYPES[presented.chart]
+        else None
+    )
+    chart = (
+        wanted.chart
+        if wanted is not None
+        else _default_chart(
+            engine_type,
+            declared.type if declared is not None else None,
+            distinct_count,
+            distinct_rate_ppm,
+        )
+    )
+    bins = wanted.bins if wanted is not None else None
+    bucket: str | None = None
+    if not values:
+        chart = "none"
+    elif chart == "timeline":
+        # The two ends, converted, and nothing else held: the grain is a function of the span.
+        bucket = _timeline_bucket(
+            _as_utc(min(values)),
+            _as_utc(max(values)),
+            wanted.bucket if wanted is not None else None,
+            bins,
+        )
+        if bucket is None:
+            chart = "none"
+
+    kind = _DISTRIBUTION_KIND_BY_CHART[chart]
+    if kind == "timeline" and bucket is not None:
+        distribution = _timeline_distribution(values, distinct_count, bucket)
+    elif kind == "histogram":
+        distribution = _histogram_distribution(values, distinct_count, bins=bins)
+    elif kind == "none":
+        distribution = _none_distribution(distinct_count, len(values))
+    else:
+        distribution = _value_count_distribution(values)[1]
+
+    asked_for = presented is not None and presented.chart == chart
+    presentation: dict[str, Any] = {
+        "chart": chart,
+        "source": "declared" if asked_for else "default",
+    }
+    if asked_for and presented is not None and presented.story is not None:
+        presentation["story"] = presented.story
+    return presentation, distribution
+
+
 def _released_column_profile(
     profile_raw: bytes,
     lineage_raw: bytes,
@@ -5111,9 +5482,18 @@ def _released_column_profile(
     workspace_id: UUID,
     run_id: UUID,
     candidate_digest: str,
+    declared_columns: Mapping[str, V4Column] = MappingProxyType({}),
 ) -> bytes:
     """Build the bounded, all-row notebook-equivalent analytical projection.
 
+    ``declared_columns`` is the recipe's own table plan keyed by column name, passed in by the v4
+    caller that already holds the parsed document rather than read back out of the job here: a
+    second reader of the same document is a second chance for the two to disagree.  The parsed
+    column carries both halves the chart needs -- what the agent asked to be shown, and the type it
+    declared, which is the only thing that separates a table of documents from a list of
+    categories once both have been sealed as text.  The v3 producer path declares nothing and every
+    column takes the default for the type the engine sealed.
+
     **THE ROW CEILING IS THE RELEASE PATH'S OWN, READ BY REFERENCE.** Both bounds below are
     :data:`MAX_SEALED_CANDIDATE_ROWS` -- ``plan_graph.HARD_MAX_OUTPUT_ROWS``, the widest table the
     graph engine may lawfully seal -- and not the v1 parse ceiling they used to restate. The two
@@ -5196,7 +5576,29 @@ def _released_column_profile(
             if value is not None and not (isinstance(value, float) and math.isnan(value))
         ]
         missing_count = declared_nulls + nan_count
-        distinct_count, distribution = _value_count_distribution(observed)
+        # The distinct key is what refuses a non-finite value, so it is computed for every column
+        # rather than only for the ones whose chart happens to count values.
+        distinct_count = len({_profile_distinct_key(value) for value in observed})
+        distinct_rate_ppm = _rate_ppm(distinct_count, len(observed))
+        numeric_summary = None
+        if engine_type in {"int64", "float64", "decimal"} and observed:
+            numeric = [
+                value
+                for value in observed
+                if isinstance(value, (int, float, Decimal)) and not isinstance(value, bool)
+            ]
+            if len(numeric) != len(observed):
+                raise HostedWorkerError(
+                    "COLUMN_PROFILE_INVALID", f"numeric values for {name!r} are inconsistent"
+                )
+            numeric_summary = _nearest_rank_summary(numeric)
+        presentation, distribution = _column_presentation(
+            str(engine_type),
+            declared_columns.get(name),
+            values=observed,
+            distinct_count=distinct_count,
+            distinct_rate_ppm=distinct_rate_ppm,
+        )
         column: dict[str, Any] = {
             "name": name,
             "logical_type": logical_type,
@@ -5208,23 +5610,13 @@ def _released_column_profile(
             "missing_rate_ppm": _rate_ppm(missing_count, row_count),
             "missing_policy": "null_or_nan",
             "distinct_count": distinct_count,
-            "distinct_rate_ppm": _rate_ppm(distinct_count, len(observed)),
+            "distinct_rate_ppm": distinct_rate_ppm,
             "distinct_policy": "typed_exact; null_and_nan_excluded; signed_zero_collapsed",
             "distribution": distribution,
+            "presentation": presentation,
         }
-        if engine_type in {"int64", "float64", "decimal"} and observed:
-            numeric = [
-                value
-                for value in observed
-                if isinstance(value, (int, float, Decimal)) and not isinstance(value, bool)
-            ]
-            if len(numeric) != len(observed):
-                raise HostedWorkerError(
-                    "COLUMN_PROFILE_INVALID", f"numeric values for {name!r} are inconsistent"
-                )
-            column["numeric_summary"] = _nearest_rank_summary(numeric)
-            if engine_type in {"int64", "float64"}:
-                column["distribution"] = _histogram_distribution(numeric, distinct_count)
+        if numeric_summary is not None:
+            column["numeric_summary"] = numeric_summary
         source_inputs, transformations = _column_lineage(lineage, name)
         column["source_inputs"] = source_inputs
         column["transformations"] = transformations

{mostlyright_data-0.13.0 → mostlyright_data-0.14.0}/src/mostlyright/data_harness/run_execution_v4.py

@@ -174,6 +174,7 @@ V4_FAILURE_CODES: tuple[str, ...] = (
     "CLAIM_KIND_UNKNOWN",
     "CLAMP_EXCEEDED",
     "CLAMP_UNSUPPORTED_FORMAT",
+    "COLUMN_PRESENTATION_INCOMPATIBLE",
     "DECLARED_CHECKS_INVALID",
     "DECLARED_CHECK_COLUMN_UNKNOWN",
     "DECLARED_CHECK_DUPLICATE",