seamless-database 2.1.0__tar.gz → 2.3.0__tar.gz

seamless_database-2.3.0/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Author: Sjoerd de Vries, MBI platform.
+Copyright (c) 2023-2026 CNRS. 
+
+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.

{seamless_database-2.1.0 → seamless_database-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seamless-database
-Version: 2.1.0
+Version: 2.3.0
 Summary: SQLite-backed metadata database service for Seamless
 Author: Sjoerd de Vries
 License-Expression: MIT
@@ -18,8 +18,10 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
 Requires-Dist: aiohttp
 Requires-Dist: peewee
+Dynamic: license-file
 
 # seamless-database
 
@@ -35,13 +37,60 @@ The database stores the following kinds of records:
 |-------|---------|
 | **Transformation** | Maps a transformation checksum to its result checksum |
 | **RevTransformation** | Reverse lookup: finds which transformations produced a given result |
-| **BufferInfo** | Stores buffer metadata (length, dtype, encoding, etc.) for a checksum |
+| **HashType** | Stores the packed checksum classification word used by new HashType validation and conversion checks |
 | **SyntacticToSemantic** | Maps between syntactic and semantic checksums per celltype |
-| **Expression** | Caches expression evaluation results (input checksum + path + celltype → result checksum) |
-| **MetaData** | Stores execution metadata for transformations (executor, environment, timing) |
-| **IrreproducibleTransformation** | Records transformations whose results are not reproducible |
+| **Expression** | Caches expression evaluation results keyed by `(input_checksum, path, input_celltype, celltype)` |
+| **MetaData** | Stores a canonical execution record for each successful, non-probe transformation |
+| **IrreproducibleTransformation** | Records transformations whose results are not reproducible; metadata is preserved on migration |
 
-All data is persisted in a single SQLite file (typically `seamless.db`).
+All data is persisted in a single SQLite file (typically `seamless.db`). The current protocol version is **2.3**.
+
+## Expression cache schema
+
+Expression `input_celltype` describes the input checksum's interpretation;
+`celltype` describes the produced result. Both are part of the composite cache
+key. Database, jobserver, remote client, and Dask payloads use those same names.
+The unreleased old `celltype`/`target_celltype` keys are not accepted aliases.
+Existing development caches need these statements, in order, or a recreated
+expression cache table:
+
+```sql
+ALTER TABLE expression RENAME COLUMN celltype TO input_celltype;
+ALTER TABLE expression RENAME COLUMN target_celltype TO celltype;
+```
+
+## Execution records
+
+`MetaData` stores one canonical execution record per successful, non-probe transformation, keyed by `tf_checksum`. Records are **write-once**: subsequent calls to a recorded transformation hit the normal `Transformation` cache and do not re-enter the record path.
+
+Two record sizes coexist under the same schema:
+
+- **Minimal record (default)** — `schema_version`, `tf_checksum`, `result_checksum`, `seamless_version`, `execution_mode`, `remote_target`, `wall_time_seconds`, `cpu_time_user_seconds`, `cpu_time_system_seconds`, `memory_peak_bytes`, `gpu_memory_peak_bytes`. The hot path pays only timing/memory capture and one write.
+- **Full record (`record: true` in `seamless.profile.yaml`)** — adds environment fingerprints (content-addressed `node`, `environment`, `queue` sub-buffer checksums), compilation context, validation snapshots, contract-violation lists, execution envelope (requested cluster/queue/node, scratch/fingertip flags, resolved `__env__`), and per-job freshness/retry/worker fields.
+
+The validator on `PUT metadata` checks identity only — record syntax (integer `schema_version`, body `tf_checksum`/`result_checksum` matching the request, sane `checksum_fields` if present) — not the full payload schema. Identical duplicates are idempotent successes; differing bodies are rejected. Once `IrreproducibleTransformation` rows exist for a `tf_checksum`, `PUT metadata` for that checksum is rejected to avoid silently migrating it back into the normal cache.
+
+When a normal entry moves to `IrreproducibleTransformation`, its metadata body travels with it unchanged.
+
+### Schema upgrade from legacy
+
+The legacy `meta_data` table had two columns (`checksum PRIMARY KEY`, `metadata JSON`). On startup, `seamless-database`:
+
+- creates the upgraded table fresh if absent,
+- drops and recreates the legacy table if it is empty,
+- preserves an already-upgraded table on subsequent starts,
+- and **fails loudly** if a non-empty legacy table is present (it must be migrated explicitly).
+
+### Endpoints (request types)
+
+- `PUT metadata` — atomically creates missing `Transformation` and `RevTransformation` rows alongside the `MetaData` row. Body: `{type: "metadata", checksum: <tf>, result: <result>, value: <record>}`.
+- `GET metadata` — return the canonical record body for a `tf_checksum`.
+- `GET irreproducible` — return all rows for a `tf_checksum`, optionally filtered by `result`. Each row includes `checksum`, `result`, and `metadata`.
+- `PUT irreproducible` — move a normal entry into `IrreproducibleTransformation`, preserving metadata.
+
+The remote-client equivalents are `set_execution_record`, `get_execution_record`, and `get_irreproducible_records` in `seamless-remote`.
+
+See the [agent contract](https://github.com/sjdv1982/seamless/blob/main/docs/agent/contracts/execution-records.md) for the full behavioral spec.
 
 ## Role in the Seamless ecosystem
 

{seamless_database-2.1.0 → seamless_database-2.3.0}/README.md

@@ -12,13 +12,60 @@ The database stores the following kinds of records:
 |-------|---------|
 | **Transformation** | Maps a transformation checksum to its result checksum |
 | **RevTransformation** | Reverse lookup: finds which transformations produced a given result |
-| **BufferInfo** | Stores buffer metadata (length, dtype, encoding, etc.) for a checksum |
+| **HashType** | Stores the packed checksum classification word used by new HashType validation and conversion checks |
 | **SyntacticToSemantic** | Maps between syntactic and semantic checksums per celltype |
-| **Expression** | Caches expression evaluation results (input checksum + path + celltype → result checksum) |
-| **MetaData** | Stores execution metadata for transformations (executor, environment, timing) |
-| **IrreproducibleTransformation** | Records transformations whose results are not reproducible |
+| **Expression** | Caches expression evaluation results keyed by `(input_checksum, path, input_celltype, celltype)` |
+| **MetaData** | Stores a canonical execution record for each successful, non-probe transformation |
+| **IrreproducibleTransformation** | Records transformations whose results are not reproducible; metadata is preserved on migration |
 
-All data is persisted in a single SQLite file (typically `seamless.db`).
+All data is persisted in a single SQLite file (typically `seamless.db`). The current protocol version is **2.3**.
+
+## Expression cache schema
+
+Expression `input_celltype` describes the input checksum's interpretation;
+`celltype` describes the produced result. Both are part of the composite cache
+key. Database, jobserver, remote client, and Dask payloads use those same names.
+The unreleased old `celltype`/`target_celltype` keys are not accepted aliases.
+Existing development caches need these statements, in order, or a recreated
+expression cache table:
+
+```sql
+ALTER TABLE expression RENAME COLUMN celltype TO input_celltype;
+ALTER TABLE expression RENAME COLUMN target_celltype TO celltype;
+```
+
+## Execution records
+
+`MetaData` stores one canonical execution record per successful, non-probe transformation, keyed by `tf_checksum`. Records are **write-once**: subsequent calls to a recorded transformation hit the normal `Transformation` cache and do not re-enter the record path.
+
+Two record sizes coexist under the same schema:
+
+- **Minimal record (default)** — `schema_version`, `tf_checksum`, `result_checksum`, `seamless_version`, `execution_mode`, `remote_target`, `wall_time_seconds`, `cpu_time_user_seconds`, `cpu_time_system_seconds`, `memory_peak_bytes`, `gpu_memory_peak_bytes`. The hot path pays only timing/memory capture and one write.
+- **Full record (`record: true` in `seamless.profile.yaml`)** — adds environment fingerprints (content-addressed `node`, `environment`, `queue` sub-buffer checksums), compilation context, validation snapshots, contract-violation lists, execution envelope (requested cluster/queue/node, scratch/fingertip flags, resolved `__env__`), and per-job freshness/retry/worker fields.
+
+The validator on `PUT metadata` checks identity only — record syntax (integer `schema_version`, body `tf_checksum`/`result_checksum` matching the request, sane `checksum_fields` if present) — not the full payload schema. Identical duplicates are idempotent successes; differing bodies are rejected. Once `IrreproducibleTransformation` rows exist for a `tf_checksum`, `PUT metadata` for that checksum is rejected to avoid silently migrating it back into the normal cache.
+
+When a normal entry moves to `IrreproducibleTransformation`, its metadata body travels with it unchanged.
+
+### Schema upgrade from legacy
+
+The legacy `meta_data` table had two columns (`checksum PRIMARY KEY`, `metadata JSON`). On startup, `seamless-database`:
+
+- creates the upgraded table fresh if absent,
+- drops and recreates the legacy table if it is empty,
+- preserves an already-upgraded table on subsequent starts,
+- and **fails loudly** if a non-empty legacy table is present (it must be migrated explicitly).
+
+### Endpoints (request types)
+
+- `PUT metadata` — atomically creates missing `Transformation` and `RevTransformation` rows alongside the `MetaData` row. Body: `{type: "metadata", checksum: <tf>, result: <result>, value: <record>}`.
+- `GET metadata` — return the canonical record body for a `tf_checksum`.
+- `GET irreproducible` — return all rows for a `tf_checksum`, optionally filtered by `result`. Each row includes `checksum`, `result`, and `metadata`.
+- `PUT irreproducible` — move a normal entry into `IrreproducibleTransformation`, preserving metadata.
+
+The remote-client equivalents are `set_execution_record`, `get_execution_record`, and `get_irreproducible_records` in `seamless-remote`.
+
+See the [agent contract](https://github.com/sjdv1982/seamless/blob/main/docs/agent/contracts/execution-records.md) for the full behavioral spec.
 
 ## Role in the Seamless ecosystem
 

{seamless_database-2.1.0 → seamless_database-2.3.0}/database.py

@@ -9,14 +9,16 @@ import socket
 import sys
 import time
 from urllib.parse import quote
-from peewee import DoesNotExist
+from peewee import DoesNotExist, IntegrityError
 
 from database_models import (
     db_init,
     db_atomic,
     Transformation,
     RevTransformation,
-    BufferInfo,
+    CellJoin,
+    RevCellJoin,
+    HashType,
     SyntacticToSemantic,
     Expression,
     MetaData,
@@ -54,80 +56,14 @@ def parse_checksum(checksum, as_bytes=False):
     raise TypeError(type(checksum))
 
 
-# from the Seamless code
-class SeamlessBufferInfo:
-    __slots__ = (
-        "checksum",
-        "length",
-        "is_utf8",
-        "is_json",
-        "json_type",
-        "is_json_numeric_array",
-        "is_json_numeric_scalar",
-        "is_numpy",
-        "dtype",
-        "shape",
-        "is_seamless_mixed",
-        "str2text",
-        "text2str",
-        "binary2bytes",
-        "bytes2binary",
-        "binary2json",
-        "json2binary",
-    )
-
-    def __init__(self, checksum, params: dict = {}):
-        for slot in self.__slots__:
-            setattr(self, slot, params.get(slot))
-        if isinstance(checksum, str):
-            checksum = parse_checksum(checksum)
-        self.checksum = checksum
-
-    def __setattr__(self, attr, value):
-        if value is not None:
-            if attr == "length":
-                if not isinstance(value, int):
-                    raise TypeError(type(value))
-                if not value >= 0:
-                    raise ValueError
-            if attr.startswith("is_"):
-                if not isinstance(value, bool):
-                    raise TypeError(type(value))
-        if attr.find("2") > -1 and value is not None:
-            if isinstance(value, bytes):
-                value = value.hex()
-        super().__setattr__(attr, value)
-
-    def __setitem__(self, item, value):
-        return setattr(self, item, value)
-
-    def __getitem__(self, item):
-        return getattr(self, item)
-
-    def update(self, other):
-        if not isinstance(other, SeamlessBufferInfo):
-            raise TypeError
-        for attr in self.__slots__:
-            v = getattr(other, attr)
-            if v is not None:
-                setattr(self, attr, v)
-
-    def get(self, attr, default=None):
-        value = getattr(self, attr)
-        if value is None:
-            return default
-        else:
-            return value
-
-    def as_dict(self):
-        result = {}
-        for attr in self.__slots__:
-            if attr == "checksum":
-                continue
-            v = getattr(self, attr)
-            if v is not None:
-                result[attr] = v
-        return result
+def _valid_hash_type_word(value):
+    if not isinstance(value, int):
+        return False
+    try:
+        from seamless.checksum.hash_type import HashType as CoreHashType
+    except ImportError:
+        return False
+    return CoreHashType.is_valid_word(value)
 
 
 def err(*args, **kwargs):
@@ -153,6 +89,12 @@ def _normalize_metadata_value(value):
     raise TypeError(type(value))
 
 
+def _normalize_expression_path_payload(path):
+    if not isinstance(path, str):
+        raise TypeError(type(path))
+    return json.dumps(path)
+
+
 def _normalize_freshness_tokens(value):
     if isinstance(value, dict):
         return value
@@ -223,6 +165,17 @@ def _ensure_rev_transformation_row(checksum: str, result: str) -> None:
     RevTransformation.create(checksum=checksum, result=result)
 
 
+def _ensure_rev_celljoin_row(checksum: str, celltype: str, result: str) -> None:
+    query = RevCellJoin.select().where(
+        RevCellJoin.checksum == checksum,
+        RevCellJoin.celltype == celltype,
+        RevCellJoin.result == result,
+    )
+    if query.exists():
+        return
+    RevCellJoin.create(checksum=checksum, celltype=celltype, result=result)
+
+
 def _delete_rev_transformation_rows(checksum: str, result: str) -> None:
     (
         RevTransformation.delete()
@@ -342,16 +295,18 @@ def build_sqlite_readonly_uri(path: str) -> str:
 
 types = (
     "protocol",
-    "buffer_info",
+    "hash_type",
     "syntactic_to_semantic",
     "semantic_to_syntactic",
     "transformation",
     "metadata",
     "bucket_probe",
     "expression",
+    "celljoin",
     "irreproducible",
     "rev_expression",  # only GET
     "rev_transformations",  # only GET
+    "rev_celljoins",  # only GET
 )
 
 
@@ -364,7 +319,7 @@ def format_response(response, *, none_as_404=False):
         else:
             status = 404
             response = "ERROR: Unknown key"
-    elif isinstance(response, (bool, dict, list)):
+    elif isinstance(response, (bool, dict, list, int)):
         response = json.dumps(response)
     elif not isinstance(response, (str, bytes)):
         status = 400
@@ -377,7 +332,7 @@ def format_response(response, *, none_as_404=False):
 
 class DatabaseServer:
     future = None
-    PROTOCOL = ("seamless", "database", "2.2")
+    PROTOCOL = ("seamless", "database", "2.4")
 
     def __init__(
         self,
@@ -582,11 +537,11 @@ class DatabaseServer:
             pass
 
     async def _get(self, type_, checksum, request):
-        if type_ == "buffer_info":
+        if type_ == "hash_type":
             try:
-                return json.loads(BufferInfo[checksum].buffer_info)
+                return HashType[checksum].hash_type
             except DoesNotExist:
-                raise DatabaseError("Unknown key") from None
+                return None
 
         elif type_ == "semantic_to_syntactic":
             try:
@@ -686,18 +641,18 @@ class DatabaseServer:
 
         elif type_ == "expression":
             try:
+                input_celltype = request["input_celltype"]
+                path = _normalize_expression_path_payload(request["path"])
                 celltype = request["celltype"]
-                path = json.dumps(request["path"])
-                target_celltype = request["target_celltype"]
-            except KeyError:
+            except (KeyError, TypeError):
                 raise DatabaseError("Malformed expression request")
             result = (
                 Expression.select()
                 .where(
                     Expression.input_checksum == checksum,
                     Expression.path == path,
+                    Expression.input_celltype == input_celltype,
                     Expression.celltype == celltype,
-                    Expression.target_celltype == target_celltype,
                 )
                 .execute()
             )
@@ -705,6 +660,20 @@ class DatabaseServer:
                 return None
             return parse_checksum(result[0].result)
 
+        elif type_ == "celljoin":
+            try:
+                celltype = request["celltype"]
+            except (KeyError, TypeError):
+                raise DatabaseError("Malformed celljoin request") from None
+            if celltype not in ("mixed", "plain", "deepcell", "deepfolder"):
+                raise DatabaseError("Malformed celljoin request")
+            row = CellJoin.get_or_none(
+                (CellJoin.checksum == checksum) & (CellJoin.celltype == celltype)
+            )
+            if row is None:
+                return None
+            return parse_checksum(row.result)
+
         elif type_ == "rev_expression":
             expressions = (
                 Expression.select()
@@ -720,8 +689,8 @@ class DatabaseServer:
                 expr = {
                     "checksum": expression.input_checksum,
                     "path": json.loads(expression.path),
+                    "input_celltype": expression.input_celltype,
                     "celltype": expression.celltype,
-                    "target_celltype": expression.target_celltype,
                     "result": checksum,
                 }
                 result.append(expr)
@@ -740,27 +709,35 @@ class DatabaseServer:
             result = [transformation.checksum for transformation in transformations]
             return result
 
+        elif type_ == "rev_celljoins":
+            rows = (
+                RevCellJoin.select()
+                .where(RevCellJoin.result == checksum)
+                .execute()
+            )
+            if not rows:
+                return None
+            return [
+                {"checksum": row.checksum, "celltype": row.celltype}
+                for row in rows
+            ]
+
         else:
             raise DatabaseError("Unknown request type")
 
     async def _put(self, type_, checksum, request):
 
-        if type_ == "buffer_info":
+        if type_ == "hash_type":
             try:
                 value = request["value"]
-                if not isinstance(value, dict):
+                if not _valid_hash_type_word(value):
                     raise TypeError
-                SeamlessBufferInfo(checksum, value)
-                try:
-                    existing = json.loads(BufferInfo[checksum].buffer_info)
-                    existing.update(value)
-                    value = existing
-                except DoesNotExist:
-                    pass
-                value = json.dumps(value, sort_keys=True, indent=2)
-            except Exception:
-                raise DatabaseError("Malformed PUT buffer info request") from None
-            BufferInfo.create(checksum=checksum, buffer_info=value)
+            except (KeyError, TypeError):
+                raise DatabaseError("Malformed PUT hash_type request") from None
+            try:
+                HashType.create(checksum=checksum, hash_type=value)
+            except IntegrityError:
+                return _conflict_response("HashType already exists with different value")
 
         elif type_ == "semantic_to_syntactic":
             try:
@@ -771,9 +748,7 @@ class DatabaseServer:
             try:
                 celltype, subcelltype = request["celltype"], request["subcelltype"]
             except KeyError:
-                raise DatabaseError(
-                    "Malformed PUT semantic-to-syntactic request"
-                ) from None
+                raise DatabaseError("Malformed PUT semantic-to-syntactic request") from None
             for syntactic_checksum0 in value:
                 syntactic_checksum = parse_checksum(syntactic_checksum0, as_bytes=False)
                 with db_atomic():
@@ -791,35 +766,65 @@ class DatabaseServer:
                 raise DatabaseError(
                     "Malformed PUT transformation result request: value must be a checksum"
                 ) from None
-            Transformation.create(checksum=checksum, result=value)
-            RevTransformation.create(checksum=checksum, result=value)
+            with db_atomic():
+                row = _get_transformation_row(checksum)
+                if row is not None and row.result != value:
+                    return _conflict_response(
+                        "Transformation already exists with different result"
+                    )
+                if row is None:
+                    Transformation.create(checksum=checksum, result=value)
+                _ensure_rev_transformation_row(checksum, value)
+
+        elif type_ == "celljoin":
+            try:
+                value = parse_checksum(request["value"], as_bytes=False)
+                celltype = request["celltype"]
+            except (KeyError, TypeError, ValueError):
+                raise DatabaseError(
+                    "Malformed PUT celljoin result request"
+                ) from None
+            if celltype not in ("mixed", "plain", "deepcell", "deepfolder"):
+                raise DatabaseError("Malformed PUT celljoin result request")
+            with db_atomic():
+                row = CellJoin.get_or_none(
+                    (CellJoin.checksum == checksum)
+                    & (CellJoin.celltype == celltype)
+                )
+                if row is not None and row.result != value:
+                    return _conflict_response(
+                        "CellJoin already exists with different result"
+                    )
+                if row is None:
+                    CellJoin.create(
+                        checksum=checksum, celltype=celltype, result=value
+                    )
+                _ensure_rev_celljoin_row(checksum, celltype, value)
 
         elif type_ == "expression":
             try:
                 value = parse_checksum(request["value"], as_bytes=False)
+                input_celltype = request["input_celltype"]
+                path = _normalize_expression_path_payload(request["path"])
                 celltype = request["celltype"]
-                path = json.dumps(request["path"])
-                target_celltype = request["target_celltype"]
-            except KeyError:
+            except (KeyError, TypeError):
                 raise DatabaseError("Malformed expression request")
             try:
-                # assert celltype in celltypes TODO? also for target_celltype
-                assert len(path) <= 100
-                if len(request["path"]):
-                    assert celltype in ("mixed", "plain", "binary")
+                # assert input_celltype in celltypes TODO? also for celltype
+                assert len(input_celltype) <= 20
                 assert len(celltype) <= 20
-                assert len(target_celltype) <= 20
             except AssertionError:
-                raise DatabaseError(
-                    "Malformed expression request (constraint violation)"
+                raise DatabaseError("Malformed expression request (constraint violation)")
+            try:
+                Expression.create(
+                    input_checksum=checksum,
+                    path=path,
+                    input_celltype=input_celltype,
+                    celltype=celltype,
+                    result=value,
                 )
-            Expression.create(
-                input_checksum=checksum,
-                path=path,
-                celltype=celltype,
-                target_celltype=target_celltype,
-                result=value,
-            )
+            except IntegrityError:
+                return _conflict_response("Expression already exists with different result")
 
         elif type_ == "metadata":
             try:
@@ -867,12 +872,8 @@ class DatabaseServer:
             try:
                 bucket_kind = request["bucket_kind"]
                 label = request["label"]
-                bucket_checksum = parse_checksum(
-                    request["bucket_checksum"], as_bytes=False
-                )
-                freshness_tokens = _normalize_freshness_tokens(
-                    request["freshness_tokens"]
-                )
+                bucket_checksum = parse_checksum(request["bucket_checksum"], as_bytes=False)
+                freshness_tokens = _normalize_freshness_tokens(request["freshness_tokens"])
                 captured_at = request["captured_at"]
                 _validate_bucket_probe_request(
                     bucket_kind,
@@ -908,8 +909,24 @@ class DatabaseServer:
                 result = parse_checksum(request["result"], as_bytes=False)
             except (KeyError, ValueError):
                 raise DatabaseError("Malformed 'irreproducible' request") from None
+            mode = request.get("mode", "manual")
+            if mode not in ("manual", "automatic"):
+                raise DatabaseError("Malformed irreproducible mode")
             with db_atomic():
                 tf_row = _get_transformation_row(checksum)
+                if mode == "automatic":
+                    if tf_row is None:
+                        return web.Response(status=404, text="Transformation not found")
+                    if parse_checksum(tf_row.result, as_bytes=False) == result:
+                        return _conflict_response("Reported result is the recorded result")
+                    if not IrreproducibleTransformation.select().where(
+                        IrreproducibleTransformation.checksum == checksum,
+                        IrreproducibleTransformation.result == result,
+                    ).exists():
+                        IrreproducibleTransformation.create(
+                            checksum=checksum, result=result, metadata=""
+                        )
+                    return "OK"
                 if tf_row is not None:
                     tf_result = parse_checksum(tf_row.result, as_bytes=False)
                     if tf_result != result:
@@ -1064,4 +1081,3 @@ If it doesn't exist, a new file is created.""",
 BUCKET_KINDS = frozenset(
     ("node", "environment", "node_env", "queue", "queue_node")
 )
-