sable-sphynx 0.7.0.dev0__py3-none-any.whl

sphynx/workflow_contracts.py

@@ -0,0 +1,594 @@
+"""Domain-neutral contracts for suite backends and their validated payloads.
+
+These contracts describe extension boundaries, not an execution engine. A
+backend owns native records, payload validation, reference authorization, and
+comparison policy. Immutable metadata and implementation labels do not verify
+source bytes, authenticate evidence, or provide process isolation.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Iterable, Mapping, Protocol, Sequence, TYPE_CHECKING, runtime_checkable
+
+from .assessment_contracts import (
+    Assessment, AssessmentContractError, CaseView, _freeze_json, _thaw,
+)
+
+if TYPE_CHECKING:
+    from .diagnostics import Diagnostic
+
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z")
+
+
+class WorkflowContractError(ValueError):
+    """An extension descriptor or workflow binding is malformed."""
+
+    @property
+    def diagnostic(self) -> Diagnostic:
+        from .diagnostics import explain_error
+        return explain_error(self)
+
+
+def _text(value: Any, name: str) -> str:
+    if type(value) is not str or not value.strip() or "\x00" in value:
+        raise WorkflowContractError(f"{name} must be nonempty text without NUL bytes")
+    try:
+        value.encode("utf-8", errors="strict")
+    except UnicodeEncodeError:
+        raise WorkflowContractError(f"{name} must contain valid Unicode") from None
+    return value
+
+
+def _optional_text(value: Any, name: str) -> None:
+    if value is not None:
+        _text(value, name)
+
+
+def _object(value: Any, name: str) -> Mapping[str, Any]:
+    if not isinstance(value, Mapping):
+        raise WorkflowContractError(f"{name} must be a JSON object")
+    try:
+        return _freeze_json(value, name)
+    except AssessmentContractError as exc:
+        raise WorkflowContractError(str(exc)) from None
+
+
+def _texts(value: Sequence[str], name: str, *, namespaced: bool = False) -> tuple[str, ...]:
+    if isinstance(value, (str, bytes)) or not isinstance(value, Sequence):
+        raise WorkflowContractError(f"{name} must be a sequence of identifiers")
+    items = tuple(_text(item, name) for item in value)
+    if len(set(items)) != len(items):
+        raise WorkflowContractError(f"{name} must not contain duplicates")
+    if namespaced and any("." not in item and ":" not in item for item in items):
+        raise WorkflowContractError(f"{name} must use namespaced identifiers")
+    return items
+
+
+def _canonical_json(value: Any) -> str:
+    try:
+        return json.dumps(_thaw(value), sort_keys=True, separators=(",", ":"),
+                          ensure_ascii=False, allow_nan=False)
+    except (TypeError, ValueError) as exc:
+        raise WorkflowContractError(f"value cannot be serialized as canonical JSON: {exc}") from None
+
+
+def contract_digest(value: Mapping[str, Any]) -> str:
+    """Hash canonical JSON metadata; this is identity, not authentication."""
+    raw = _canonical_json(_object(value, "digest input")).encode("utf-8")
+    return "sha256:" + hashlib.sha256(raw).hexdigest()
+
+
+@dataclass(frozen=True)
+class PayloadSchema:
+    """An exact payload contract backed by an operator-supplied validator.
+
+    The validator receives a detached JSON value, returns None on success, and
+    raises on invalid content. It must not mutate the value. Adapters wrap typed
+    validators that return parsed objects. The implementation label is an exact
+    operator declaration, not a derived source digest. Registration does not run
+    this callback; explicit payload validation does.
+    """
+
+    schema_id: str
+    version: str
+    implementation_id: str
+    validator: Callable[[Any], None] = field(repr=False, compare=False)
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("schema_id", "version", "implementation_id"):
+            _text(getattr(self, name), name)
+        if not callable(self.validator):
+            raise WorkflowContractError("payload validator must be callable")
+        object.__setattr__(self, "metadata", _object(self.metadata, "metadata"))
+
+    def validate(self, value: Any) -> Any:
+        """Validate content and return a detached immutable JSON snapshot."""
+        try:
+            frozen = _freeze_json(value, "payload")
+        except AssessmentContractError as exc:
+            raise WorkflowContractError(str(exc)) from None
+        original_json = _canonical_json(frozen)
+        detached = _thaw(frozen)
+        result = self.validator(detached)
+        if result is not None:
+            raise WorkflowContractError("payload validator must return None on success")
+        try:
+            unchanged = _canonical_json(_freeze_json(detached, "validated payload")) == original_json
+        except (AssessmentContractError, WorkflowContractError):
+            unchanged = False
+        if not unchanged:
+            raise WorkflowContractError("payload validator must not mutate content")
+        return frozen
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"schema_id": self.schema_id, "version": self.version,
+                "implementation_id": self.implementation_id, "metadata": _thaw(self.metadata)}
+
+
+@dataclass(frozen=True)
+class DatasetDefinition:
+    """Case-provider metadata without reading or materializing its cases.
+
+    Selection, split, ordering, cohort, and grouping rules are provider-owned.
+    Input and reference schema identities stay separate. Providers may iterate
+    lazily. None of this metadata grants access to references or external assets.
+    """
+
+    dataset_id: str
+    version: str
+    provider_id: str
+    input_schema_id: str
+    reference_schema_id: str | None = None
+    selection: Mapping[str, Any] = field(default_factory=dict)
+    identity: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("dataset_id", "version", "provider_id", "input_schema_id"):
+            _text(getattr(self, name), name)
+        _optional_text(self.reference_schema_id, "reference_schema_id")
+        for name in ("selection", "identity"):
+            object.__setattr__(self, name, _object(getattr(self, name), name))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"dataset_id": self.dataset_id, "version": self.version,
+                "provider_id": self.provider_id, "input_schema_id": self.input_schema_id,
+                "reference_schema_id": self.reference_schema_id,
+                "selection": _thaw(self.selection), "identity": _thaw(self.identity)}
+
+
+@runtime_checkable
+class CaseProvider(Protocol):
+    """Input iteration and grader-only reference lookup are different calls.
+
+    ``access`` has backend-defined authorization semantics. The provider must
+    validate it; possession of a Python object is not a grant. A candidate must
+    receive only its allowlisted CaseView, not the provider or its references.
+    """
+
+    @property
+    def definition(self) -> DatasetDefinition: ...
+
+    def cases(self, selection: Mapping[str, Any] | None = None) -> Iterable[CaseView]: ...
+
+    def reference_for(self, case_id: str, *, access: Any) -> Mapping[str, Any]: ...
+
+
+@dataclass(frozen=True)
+class Dataset:
+    """A schema-bound case provider with lazy, candidate-permitted inputs.
+
+    ``case_source`` is an iterable or a callable receiving the selected immutable
+    selection mapping. Use a callable to obtain a fresh iterator for each pass.
+    Construction and descriptor inspection do not load cases or references.
+
+    An optional selection schema validates nondefault selections. Without it,
+    only the definition's exact selection is accepted. A backend must bind the
+    selected cohort's native identity before execution and comparison.
+
+    References have a separate schema and loader. The explicit authorization
+    callback must return True before that loader is accessed. The callback and
+    backend own principal, case membership, and access-policy validation. No
+    default object, token shape, or Python type constitutes a reference grant.
+    Do not pass this provider to candidate execution; pass its CaseViews only.
+    """
+
+    definition: DatasetDefinition
+    input_schema: PayloadSchema
+    case_source: Iterable[CaseView] | Callable[[Mapping[str, Any]], Iterable[CaseView]] = field(
+        repr=False, compare=False)
+    reference_schema: PayloadSchema | None = field(default=None, repr=False)
+    reference_loader: Callable[[str], Mapping[str, Any]] | None = field(
+        default=None, repr=False, compare=False)
+    authorize_references: Callable[[str, Any], bool] | None = field(
+        default=None, repr=False, compare=False)
+    selection_schema: PayloadSchema | None = field(default=None, repr=False)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.definition, DatasetDefinition):
+            raise WorkflowContractError("dataset definition must be DatasetDefinition")
+        if not isinstance(self.input_schema, PayloadSchema):
+            raise WorkflowContractError("dataset input schema must be PayloadSchema")
+        if self.input_schema.schema_id != self.definition.input_schema_id:
+            raise WorkflowContractError("input schema differs from the dataset definition")
+        if not callable(self.case_source) and not isinstance(self.case_source, Iterable):
+            raise WorkflowContractError("case source must be an iterable or callable")
+        if self.reference_schema is not None:
+            if not isinstance(self.reference_schema, PayloadSchema):
+                raise WorkflowContractError("reference schema must be PayloadSchema")
+            if self.reference_schema.schema_id != self.definition.reference_schema_id:
+                raise WorkflowContractError("reference schema differs from the dataset definition")
+        if self.reference_loader is not None:
+            if not callable(self.reference_loader) or self.reference_schema is None:
+                raise WorkflowContractError("reference loader requires a matching payload schema")
+        if self.authorize_references is not None and not callable(self.authorize_references):
+            raise WorkflowContractError("reference authorization must be callable")
+        if self.selection_schema is not None and not isinstance(self.selection_schema, PayloadSchema):
+            raise WorkflowContractError("selection schema must be PayloadSchema")
+
+    def cases(self, selection: Mapping[str, Any] | None = None) -> Iterable[CaseView]:
+        """Validate and yield cases only when the returned iterator is consumed."""
+        selected = _object(self.definition.selection if selection is None else selection, "selection")
+        if self.selection_schema is not None:
+            selected = self.selection_schema.validate(selected)
+            if not isinstance(selected, Mapping):
+                raise WorkflowContractError("selection schema must validate an object")
+        elif _canonical_json(selected) != _canonical_json(self.definition.selection):
+            raise WorkflowContractError("nondefault selection requires a selection schema")
+        source = self.case_source(selected) if callable(self.case_source) else self.case_source
+        try:
+            iterator = iter(source)
+        except TypeError:
+            raise WorkflowContractError("case source must produce an iterable") from None
+        seen: set[str] = set()
+        for case in iterator:
+            if not isinstance(case, CaseView):
+                raise WorkflowContractError("case source must yield CaseView values")
+            if case.schema_version != self.definition.input_schema_id:
+                raise WorkflowContractError("case input schema differs from the dataset definition")
+            if case.case_id in seen:
+                raise WorkflowContractError("case source contains duplicate case identities")
+            seen.add(case.case_id)
+            yield CaseView.validated(case.case_id, case.inputs, schema=self.input_schema,
+                                     metadata=case.metadata)
+
+    def reference_for(self, case_id: str, *, access: Any) -> Mapping[str, Any]:
+        """Authorize first, then load and validate one grader-only reference."""
+        _text(case_id, "case_id")
+        if self.authorize_references is None:
+            raise PermissionError("reference access is not authorized")
+        try:
+            allowed = self.authorize_references(case_id, access)
+        except Exception:
+            raise PermissionError("reference access is not authorized") from None
+        if allowed is not True:
+            raise PermissionError("reference access is not authorized")
+        if self.reference_loader is None or self.reference_schema is None:
+            raise WorkflowContractError("dataset does not provide reference loading")
+        value = self.reference_schema.validate(self.reference_loader(case_id))
+        if not isinstance(value, Mapping):
+            raise WorkflowContractError("reference schema must validate an object")
+        return value
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return metadata only; omit loaders, authorization, and reference data."""
+        return self.definition.to_dict()
+
+
+@dataclass(frozen=True)
+class Criterion:
+    """A versioned requirement or dimension, independent of numeric metrics."""
+
+    criterion_id: str
+    version: str
+    title: str
+    configuration: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("criterion_id", "version", "title"):
+            _text(getattr(self, name), name)
+        object.__setattr__(self, "configuration", _object(self.configuration, "configuration"))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"criterion_id": self.criterion_id, "version": self.version,
+                "title": self.title, "configuration": _thaw(self.configuration)}
+
+
+@dataclass(frozen=True)
+class EvaluatorDefinition:
+    """An evaluator may address several criteria and emit several outputs."""
+
+    evaluator_id: str
+    version: str
+    implementation_id: str
+    criterion_ids: tuple[str, ...] = ()
+    assessment_schema_ids: tuple[str, ...] = ()
+    metric_ids: tuple[str, ...] = ()
+    required_capabilities: tuple[str, ...] = ()
+    configuration: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("evaluator_id", "version", "implementation_id"):
+            _text(getattr(self, name), name)
+        for name in ("criterion_ids", "assessment_schema_ids", "metric_ids", "required_capabilities"):
+            object.__setattr__(self, name, _texts(getattr(self, name), name,
+                                                namespaced=name == "required_capabilities"))
+        object.__setattr__(self, "configuration", _object(self.configuration, "configuration"))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"evaluator_id": self.evaluator_id, "version": self.version,
+                "implementation_id": self.implementation_id, "criterion_ids": list(self.criterion_ids),
+                "assessment_schema_ids": list(self.assessment_schema_ids), "metric_ids": list(self.metric_ids),
+                "required_capabilities": list(self.required_capabilities),
+                "configuration": _thaw(self.configuration)}
+
+
+@dataclass(frozen=True)
+class MetricSpec:
+    """Numeric meaning and optional domain policies, without a default reducer.
+
+    Direction and population semantics belong to the registered domain. Policy
+    IDs identify declared implementations; no policy is executed by this type.
+    A measurement need not be an assessment of a quality criterion.
+    """
+
+    metric_id: str
+    version: str
+    unit: str
+    direction: str
+    aggregation_policy: str | None = None
+    comparison_policy: str | None = None
+    population: Mapping[str, Any] = field(default_factory=dict)
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("metric_id", "version", "unit", "direction"):
+            _text(getattr(self, name), name)
+        for name in ("aggregation_policy", "comparison_policy"):
+            _optional_text(getattr(self, name), name)
+        for name in ("population", "metadata"):
+            object.__setattr__(self, name, _object(getattr(self, name), name))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"metric_id": self.metric_id, "version": self.version, "unit": self.unit,
+                "direction": self.direction, "aggregation_policy": self.aggregation_policy,
+                "comparison_policy": self.comparison_policy,
+                "population": _thaw(self.population), "metadata": _thaw(self.metadata)}
+
+
+@dataclass(frozen=True)
+class BackendDescriptor:
+    """Exact backend identity and open, namespaced capability declarations."""
+
+    backend_id: str
+    version: str
+    implementation_id: str
+    capabilities: tuple[str, ...]
+    supported_scopes: tuple[str, ...]
+    supported_modes: tuple[str, ...]
+    suite_ids: tuple[str, ...] = ()
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("backend_id", "version", "implementation_id"):
+            _text(getattr(self, name), name)
+        for name in ("capabilities", "supported_scopes", "supported_modes", "suite_ids"):
+            object.__setattr__(self, name, _texts(getattr(self, name), name,
+                                                namespaced=name == "capabilities"))
+        if not self.supported_scopes or not self.supported_modes:
+            raise WorkflowContractError("backend must declare supported scopes and modes")
+        object.__setattr__(self, "metadata", _object(self.metadata, "metadata"))
+
+    @property
+    def descriptor_digest(self) -> str:
+        return contract_digest(self.to_dict())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"backend_id": self.backend_id, "version": self.version,
+                "implementation_id": self.implementation_id, "capabilities": list(self.capabilities),
+                "supported_scopes": list(self.supported_scopes), "supported_modes": list(self.supported_modes),
+                "suite_ids": list(self.suite_ids), "metadata": _thaw(self.metadata)}
+
+
+@dataclass(frozen=True)
+class SuiteDefinition:
+    """Reusable suite metadata; native assets and records remain backend-owned."""
+
+    suite_id: str
+    version: str
+    backend_id: str
+    title: str
+    configuration: Mapping[str, Any] = field(default_factory=dict)
+    criterion_ids: tuple[str, ...] = ()
+    evaluator_ids: tuple[str, ...] = ()
+    metric_ids: tuple[str, ...] = ()
+    required_capabilities: tuple[str, ...] = ()
+    datasets: tuple[DatasetDefinition, ...] = ()
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("suite_id", "version", "backend_id", "title"):
+            _text(getattr(self, name), name)
+        for name in ("criterion_ids", "evaluator_ids", "metric_ids", "required_capabilities"):
+            object.__setattr__(self, name, _texts(getattr(self, name), name,
+                                                namespaced=name == "required_capabilities"))
+        if isinstance(self.datasets, (str, bytes)) or not isinstance(self.datasets, Sequence):
+            raise WorkflowContractError("datasets must be a sequence of DatasetDefinition values")
+        datasets = tuple(self.datasets)
+        if any(not isinstance(item, DatasetDefinition) for item in datasets):
+            raise WorkflowContractError("datasets must contain DatasetDefinition values")
+        if len({(item.dataset_id, item.version) for item in datasets}) != len(datasets):
+            raise WorkflowContractError("suite dataset identities must be unique")
+        object.__setattr__(self, "datasets", datasets)
+        for name in ("configuration", "metadata"):
+            object.__setattr__(self, name, _object(getattr(self, name), name))
+
+    @property
+    def definition_digest(self) -> str:
+        return contract_digest(self.to_dict())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"suite_id": self.suite_id, "version": self.version, "backend_id": self.backend_id,
+                "title": self.title, "configuration": _thaw(self.configuration),
+                "criterion_ids": list(self.criterion_ids), "evaluator_ids": list(self.evaluator_ids),
+                "metric_ids": list(self.metric_ids), "required_capabilities": list(self.required_capabilities),
+                "datasets": [item.to_dict() for item in self.datasets], "metadata": _thaw(self.metadata)}
+
+
+@dataclass(frozen=True)
+class PlanBinding:
+    """Selected settings plus a backend-owned candidate object.
+
+    The backend must validate and bind the candidate's implementation identity
+    during resolution and recheck required facts at admission/launch. Freezing
+    this envelope cannot freeze an arbitrary service, function, or native object.
+    """
+
+    suite: SuiteDefinition
+    candidate: Any = field(repr=False, compare=False)
+    scope: str = "component"
+    mode: str = "local"
+    parameters: Mapping[str, Any] = field(default_factory=dict)
+    runtime: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.suite, SuiteDefinition):
+            raise WorkflowContractError("plan suite must be SuiteDefinition")
+        for name in ("scope", "mode"):
+            _text(getattr(self, name), name)
+        for name in ("parameters", "runtime"):
+            object.__setattr__(self, name, _object(getattr(self, name), name))
+
+
+@dataclass(frozen=True)
+class ResolvedBinding:
+    """Metadata selected by a backend; resolution does not verify asset bytes."""
+
+    identity: Mapping[str, Any]
+    native_ref: Any = field(default=None, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "identity", _object(self.identity, "identity"))
+        if not self.identity:
+            raise WorkflowContractError("resolution requires explicit identity metadata")
+
+    @property
+    def status(self) -> str:
+        return "resolved"
+
+    @property
+    def artifact_bytes_verified(self) -> bool:
+        return False
+
+    @property
+    def resolution_digest(self) -> str:
+        return contract_digest(self.to_dict())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"status": self.status, "identity": _thaw(self.identity), "artifact_bytes_verified": False}
+
+
+@dataclass(frozen=True)
+class AdmissionBinding:
+    """Backend-verified admission facts without upgrading native authority."""
+
+    resolution_digest: str
+    facts: Mapping[str, Any]
+    trust_tier: str
+    artifact_bytes_verified: bool
+    candidate_source_bytes_verified: bool = False
+    native_ref: Any = field(default=None, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        if type(self.resolution_digest) is not str or not _DIGEST.fullmatch(self.resolution_digest):
+            raise WorkflowContractError("admission requires a canonical resolution digest")
+        _text(self.trust_tier, "trust_tier")
+        for name in ("artifact_bytes_verified", "candidate_source_bytes_verified"):
+            if type(getattr(self, name)) is not bool:
+                raise WorkflowContractError(f"{name} must be boolean")
+        object.__setattr__(self, "facts", _object(self.facts, "facts"))
+
+    @property
+    def status(self) -> str:
+        return "admitted"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"status": self.status, "resolution_digest": self.resolution_digest,
+                "facts": _thaw(self.facts), "trust_tier": self.trust_tier,
+                "artifact_bytes_verified": self.artifact_bytes_verified,
+                "candidate_source_bytes_verified": self.candidate_source_bytes_verified}
+
+
+@dataclass(frozen=True)
+class ReferenceBinding:
+    """Native record status and identity, separate from evidence verification."""
+
+    record_id: str | None
+    status: str
+    trust_tier: str
+    run_id: str | None = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        for name in ("record_id", "run_id"):
+            _optional_text(getattr(self, name), name)
+        for name in ("status", "trust_tier"):
+            _text(getattr(self, name), name)
+        object.__setattr__(self, "metadata", _object(self.metadata, "metadata"))
+
+
+@runtime_checkable
+class ReportProjection(Protocol):
+    """Backend-verified permitted presentation; no universal metric layout."""
+
+    def to_dict(self) -> dict[str, Any]: ...
+
+    def to_json(self) -> str: ...
+
+    def to_markdown(self) -> str: ...
+
+
+@runtime_checkable
+class WorkflowBackend(Protocol):
+    """Domain adapter for the shared flow, including native record readers.
+
+    describe/resolve operate on metadata without candidate execution or asset
+    reads. cases may load assets. admit verifies access, bytes and capabilities;
+    recheck runs before execute. assess must reuse saved evidence, not execute a
+    candidate. report/assessments/compare verify native evidence and permissions.
+    Comparison population, aggregation, projection and source authority stay in
+    the backend. Recognizing a reference type does not validate its evidence.
+    """
+
+    @property
+    def descriptor(self) -> BackendDescriptor: ...
+
+    def describe(self, suite_id: str) -> SuiteDefinition: ...
+
+    def cases(self, suite: SuiteDefinition) -> Iterable[CaseView]: ...
+
+    def resolve(self, plan: PlanBinding) -> ResolvedBinding: ...
+
+    def admit(self, plan: PlanBinding, resolved: ResolvedBinding) -> AdmissionBinding: ...
+
+    def recheck(self, plan: PlanBinding, resolved: ResolvedBinding, admission: AdmissionBinding) -> None: ...
+
+    def execute(self, plan: PlanBinding, resolved: ResolvedBinding, admission: AdmissionBinding,
+                output_dir: str | Path | None) -> Any: ...
+
+    def accepts_reference(self, native_ref: Any, kind: str) -> bool: ...
+
+    def reference(self, native_ref: Any, kind: str) -> ReferenceBinding: ...
+
+    def assess(self, native_run: Any) -> Any: ...
+
+    def report(self, native_grading: Any) -> ReportProjection: ...
+
+    def assessments(self, native_grading: Any, case_id: str | None = None) -> Iterable[Assessment]: ...
+
+    def compare(self, baseline_grading: Any, candidate_grading: Any) -> Any: ...