How a result was made

Every result Ophiolite calculates records how it was made: who made it and when, through what (the browser, Python, an agent on someone’s behalf), with which calculation and Ophiolite release, the settings, and the exact version of each input. A result published from Python with a method you declared says who reported it and that Ophiolite did not run that calculation. A file you uploaded is where the history starts.

You see only what you may open. Steps you cannot open are not shown, and the page says so.

In the browser

Open a result. How this was made reads, for example:

Made on Tuesday 6 October 2026, 14:12 by Sanne de Vries. Through the browser. Made with Shale volume from gamma ray, version 1, Ophiolite 2026.10.60. Made from HON-GT-01 gamma ray, version 2, added by Bram Koster on 1 October.

• Show earlier steps lists the inputs and their inputs, a page at a time (Show more). A step reached twice reads “(shown above)”. A long history ends with results to open and continue from.
• What changed compares this version with the one before it: the settings, each input’s version and what changed there, the calculation and the Ophiolite release.
• What depends on this lists the results made from this version, and says when one of them has a newer input.
• Technical details holds the identifiers, for support and for scripts.

When a newer version of an input exists, the result says “Newer input available”.

Make it again

Make it again runs the same calculation on the same input versions with the same settings. Make it with newer inputs names the versions it will use instead (“This will use HON-GT-01 version 3 instead of version 2. Everything else stays the same.”) and uses exactly those, even if another version is added while you read.

Nothing runs before you confirm, and nothing is saved or shared unless you choose:

• Same result: the result already holds these values; no new version is saved.
• Different: Ophiolite says where and by how much the values differ, and which release made each. You can come back to it for 24 hours. Choose Save as a new result (only you can open it until you share it), Add as a new version of the result (Ophiolite names the people who will see it and be told, and asks you to confirm), or Discard.

If the people who can see the result change after you confirmed, Ophiolite says so, names them again and saves nothing until you confirm again.

Making it again needs permission to run calculations and to build on every input. A result Ophiolite did not run, one made before Ophiolite recorded how, and one whose calculation is no longer part of the release say so instead.

In QGIS

A map from your project shows How this was made (opens in Ophiolite) in its row of the Ophiolite panel. It opens the version the layer shows, not the newest one, in your browser; the address holds no key, and Ophiolite keeps it through sign-in.

In Python

client is an ophiolite.Client for your project; see Build on Ophiolite for a key and the SDK. result is the exact version you are asking about, for example the receipt a calculation returned. Read how it was made, a page at a time:

from ophiolite import story

page = client.story(result['asset_id'], result['revision'])
for line in story.lines(page):
    print(line)
while page.get('next_cursor'):
    page = client.story(result['asset_id'], result['revision'], cursor=page['next_cursor'])
    for line in story.lines(page):
        print(line)

What was made from it:

made_from_it = client.dependents(result['asset_id'], result['revision'])
for line in story.lines(made_from_it):
    print(line)

Make it again with the newest version of each input. The preview names the exact versions; the run uses those, and nothing is saved by it:

import time
import uuid

preview = client.remake(result['asset_id'], result['revision'], step='preview', inputs='newer')
for one in preview['inputs']:
    print(one['label'], 'version', one['version'], 'instead of version', one['recorded_version'])
inputs = [{'slot': one['slot'], 'asset_id': one['asset_id'], 'revision': one['revision']} for one in preview['inputs']]
command = 'make-again-' + uuid.uuid4().hex
status = client.remake(result['asset_id'], result['revision'], step='run', inputs=inputs, command_id=command)
while status['state'] in ('pending', 'running'):
    time.sleep(1)
    status = client.remake(result['asset_id'], result['revision'], step='status', execution_id=status['execution_id'])
status = client.remake(result['asset_id'], result['revision'], step='status', execution_id=status['execution_id'])
print([o['outcome'] for o in status['outcomes']])  # 'equal' or 'different'

An output that differs is kept for 24 hours. Save it as the next version of the result after checking who will see it; the digest is your confirmation of exactly those people:

held = status['held'][0]
print(held['summary']['changed'], 'of', held['summary']['of'], 'values differ')
print('Who will see it:', held['audience']['recipients'])
saved = client.remake_save(status['execution_id'], [{'role': held['role'], 'target': 'new-version', 'command_id': command + '-0',
                                                     'audience_digest': held['audience']['digest']}])
version = saved['saves'][0]

What changed between the two versions:

changes = client.what_changed((result['asset_id'], result['revision']), (version['asset_id'], version['revision']))
for setting in changes['settings']:
    print(setting['label'], setting['b'], 'was', setting['a'])
for one in changes['inputs']:
    print('Input version', (one.get('b') or {}).get('version'), 'was', (one.get('a') or {}).get('version'))
print('Release:', changes['release']['b'], 'was', changes['release']['a'])

The command line has the same four: ophiolite story, ophiolite dependents, ophiolite what-changed and ophiolite remake (with --newer, and --save --target new-result or new-version).