examples/querying_entity_versions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "07297a3d-048b-496b-adb0-8fdd67316021",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Hosts: Working with asset Versions\n",
    "\n",
    "This notebook shows how to perform common versioning-related tasks using OpenAssetIO, the OpenAssetIO-MediaCreation traits, and a supporting manager.\n",
    "\n",
    "It uses a contrived library that contains several versions of the OpenAssetIO logo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60bd9de5-64c3-4f15-8824-ff1d94a894d7",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Setup\n",
    "\n",
    "See \"Hello OpenAssetIO\" notebook for details on how to bootstrap OpenAssetIO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "80285f6a-8134-4055-9430-a48a5f79e7d3",
   "metadata": {
    "editable": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [],
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.357676282Z",
     "start_time": "2024-01-26T15:32:47.317138774Z"
    }
   },
   "outputs": [],
   "source": [
    "from resources import helpers\n",
    "\n",
    "manager, context = helpers.bootstrap(\"resources/querying_entity_versions/openassetio_config.toml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a80594a-b171-49c5-8cfd-00e334759b1e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Getting started"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22277554-b477-4600-8c2a-90ee8d5c064e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "In this example we're going to to ask the manager about other versions of the OpenAssetIO logo contained within our sample library. \n",
    "\n",
    "We've been given a URI by a colleague, which we need to turn into a strongly-typed `EntityReference` before we can use it to query the asset management system.\n",
    "\n",
    "This process ensures that only known URIs are passed to any subsequent API calls. The `createEntityReference` method will throw if the input is not known to the manager. There are other forms with different failure behaviours if exceptions aren't your thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "82c3962a-27b5-4375-b4fa-dbd14dcfc93b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.359499959Z",
     "start_time": "2024-01-26T15:32:47.357981404Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> `<openassetio.EntityReference bal:///project_artwork/logos/openassetio>`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "logo_ref = manager.createEntityReference(\"bal:///project_artwork/logos/openassetio\")\n",
    "\n",
    "helpers.display_result(repr(logo_ref))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec69ae04-1895-4243-a949-71360175b173",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Now we have an entity reference for our logo, we can use the API to learn more about it.\n",
    "\n",
    "Versioning information is [not part of the core API](https://github.com/OpenAssetIO/OpenAssetIO/blob/main/doc/decisions/DR017-Entity-version-queries.md) itself. MediaCreation traits that describe how we generally work with versions in the post-production industry are used as arguments to core API methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4348da46-9467-4734-9f96-d84e26f7c11f",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Querying an entity's version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e32a587-5233-441e-9b80-1b2d6d3769fb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "An entity's version can be resolved using the imaginatively named `VersionTrait` from the `lifecycle` module of the `openassetio_mediacreation` package `traits`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0fcf0214-2561-488a-8eee-0330ca27710d",
   "metadata": {
    "scrolled": true,
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.376483773Z",
     "start_time": "2024-01-26T15:32:47.361460456Z"
    }
   },
   "outputs": [],
   "source": [
    "from openassetio_mediacreation.traits.lifecycle import VersionTrait\n",
    "from openassetio.access import ResolveAccess\n",
    "\n",
    "entity_data = manager.resolve(logo_ref, {VersionTrait.kId}, ResolveAccess.kRead, context)\n",
    "\n",
    "version_trait = VersionTrait(entity_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6c4f0ff-0e5d-40b7-84d6-d46efa8cba7a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "The MediaCreation `VersionTrait` is used to wrap the generic `TraitsData` returned from `resolve` to provide accessors to the trait's properties. In this case - the entity's versioning information.\n",
    "\n",
    "This trait uses the term \"tag\" for some string that identifies the version of an entity. Using a string, rather than a number allows full flexibility in how a specific manager may wish to handle versions and dynamic \"meta-versions\".\n",
    "\n",
    "**Note: The tags themselves are specific to each manager, and are not defined by the API or the MediaCreation library. Hosts must not attempt to string munge entity references, and instead use the methods covered in this document if they wish to obtain references for specific versions. Otherwise, this defeats the function of the API as an abstraction layer.**\n",
    "\n",
    "The `specifiedTag` property holds the version tag addressed by the entity reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1c0683dd-c601-41b4-a069-d5acb3c40cbf",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.425958956Z",
     "start_time": "2024-01-26T15:32:47.418487961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> `latest`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helpers.display_result(version_trait.getSpecifiedTag())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17049575-fc94-4ac1-9db4-466cccbe1061",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "BAL uses the `v=` query param to define versions in its references. Ours did not have one (`\"bal:///project_artwork/logos/openassetio\"`), so BAL elects to return the latest version. Again note, this is a BAL specific behaviour, other managers may handle things differently.\n",
    "\n",
    "The version trait defines that the `specifiedTag` property holds the tag that would behave in the same way when used in a subsequent query (see 'Querying a specific version' below). BAL set this to `\"latest\"`, reflecting the behaviour described above.\n",
    "\n",
    "The version trait also has a `stableTag` property. This holds the tag for the targeted entity that is guaranteed to be free of dynamic behaviour. BAL set this to `\"2\"`, the tag of the latest version at the time the query was made."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "52fe1001-166a-4356-b6ba-869e76bdd05d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.426458394Z",
     "start_time": "2024-01-26T15:32:47.418643879Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> `2`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "helpers.display_result(version_trait.getStableTag())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6485867c-086a-4e97-98b6-c56a08da31ef",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Note that not all managers version all entities, this trait will not be imbued to the resulting data if the queried entity is un-versioned."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "802716be-296d-453a-81b2-e068e5a8fc16",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Querying other versions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa250993-ba14-4e3a-be3b-3a2cc0234c30",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "It was noted earlier that Hosts, generally speaking, should never \"string munge\" an existing entity reference to derive another one as this makes assumptions about how any manager may work. The composition of entity reference strings is certain to be unique to each manager and must not be relied upon. \n",
    "\n",
    "Entity references should be considered \"opaque handles\", and instead use the appropriate API methods to achieve the same end.\n",
    "\n",
    "The `EntityVersionsRelationshipSpecification` from the `specifications.lifecycle` module defines a well-known relationship trait set for querying different versions of the same entity. It is used with the `getWithRelationship` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "67fe58a8-ac53-48cd-8862-0516416a8fc4",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [],
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.474032934Z",
     "start_time": "2024-01-26T15:32:47.418729334Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> - `bal:///project_artwork/logos/openassetio`\n> - `bal:///project_artwork/logos/openassetio?v=2`\n> - `bal:///project_artwork/logos/openassetio?v=1`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from openassetio.access import RelationsAccess\n",
    "\n",
    "from openassetio_mediacreation.specifications.lifecycle import EntityVersionsRelationshipSpecification\n",
    "\n",
    "# Note that the relationship query methods don't yet have the same\n",
    "# convenience overloads that resolve does, and so required the use\n",
    "# of the more elaborate callback signature.\n",
    "related_refs = []\n",
    "manager.getWithRelationship(\n",
    "    [logo_ref],\n",
    "    EntityVersionsRelationshipSpecification.create().traitsData(),\n",
    "    10,\n",
    "    RelationsAccess.kRead, \n",
    "    context, \n",
    "    lambda _, pager: related_refs.extend(pager.get()), lambda _, err: print(err.message))\n",
    "\n",
    "helpers.display_result(related_refs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6323964-49c3-4490-a495-f87680911072",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "We now have the references for all versions of the logo. The `EntityVersionsRelationshipSpecification` allows the inclusion of dynamic \"meta-versions\", and so you can see the BAL has provided references for both the \"latest\" and stable variations of the entity references. Some asset management systems may have a whole host of dynamic references to cover concepts such as approval and other workflow related statuses.\n",
    "\n",
    "The `EntityVersionsRelationshipSpecification` also defines that versions will be ordered with the most relevant first. This is usually reverse chronological order."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c29b77-c842-4745-8568-3402e5048185",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Querying stable versions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf5e5838-f5da-4334-ad5f-64e26902a503",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "While powerful, dynamic versioning behaviour can be error-prone in some situations. MediaCreation also provides a specialisation of the entity versions relationship that only provides stable references - `StableEntityVersionsRelationshipSpecification` - for situations where you need to guarantee that a referenced entity will not change over time.\n",
    "\n",
    "For the curious, this extends `EntityVersionsRelationshipSpecification` with one additional trait - the `StableTrait`.\n",
    "\n",
    "If we use this, BAL will now only give us references that point to concrete versions of the logo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fe115b9d-77e6-432f-ab60-aca0387e96bb",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [],
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.474698406Z",
     "start_time": "2024-01-26T15:32:47.462602377Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> - `bal:///project_artwork/logos/openassetio?v=2`\n> - `bal:///project_artwork/logos/openassetio?v=1`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from openassetio.access import RelationsAccess\n",
    "\n",
    "from openassetio_mediacreation.specifications.lifecycle import StableEntityVersionsRelationshipSpecification\n",
    "\n",
    "# Note that the relationship query methods don't yet have the same\n",
    "# convenience overloads that resolve does, and so required the use\n",
    "# of the more elaborate callback signature.\n",
    "versions_refs = []\n",
    "manager.getWithRelationship(\n",
    "    [logo_ref], \n",
    "    StableEntityVersionsRelationshipSpecification.create().traitsData(), \n",
    "    10,\n",
    "    RelationsAccess.kRead, \n",
    "    context, \n",
    "    lambda _, pager: versions_refs.extend(pager.get()), lambda _, err: print(err.message))\n",
    "\n",
    "helpers.display_result(versions_refs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0314bb-41cd-4f2c-8887-82562537fba3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Now we have these references, lets take a look at how the logo has evolved:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3fd0a169-f8c7-4dfd-8c03-fc92d0bf8c3f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [],
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.523394860Z",
     "start_time": "2024-01-26T15:32:47.462806799Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The OpenAssetIO logo (Version '2')\n"
     ]
    },
    {
     "data": {
      "text/plain": "<PIL.JpegImagePlugin.JpegImageFile image mode=L size=400x83>",
      "image/png": "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",
      "image/jpeg": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The OpenAssetIO logo (Version '1')\n"
     ]
    },
    {
     "data": {
      "text/plain": "<PIL.JpegImagePlugin.JpegImageFile image mode=L size=370x83>",
      "image/png": "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",
      "image/jpeg": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from openassetio.access import ResolveAccess\n",
    "from openassetio_mediacreation.traits.content import LocatableContentTrait\n",
    "from openassetio_mediacreation.traits.identity import DisplayNameTrait\n",
    "from openassetio_mediacreation.traits.lifecycle import VersionTrait\n",
    "\n",
    "# We can re-use the list of references to batch-resolve several traits for \n",
    "# all versions at once. This can be useful for building menus/pickers/etc...\n",
    "# Batching helps mitigate the cost of expensive database lookups that incur\n",
    "# a fixed per-call cost due to network latency\n",
    "all_versions_entity_data = manager.resolve(\n",
    "    versions_refs, \n",
    "    {LocatableContentTrait.kId, DisplayNameTrait.kId, VersionTrait.kId}, \n",
    "    ResolveAccess.kRead, context)\n",
    "\n",
    "# Display some rudimentary information about each version\n",
    "for entity_data in all_versions_entity_data:\n",
    "    name = DisplayNameTrait(entity_data).getName()\n",
    "    version_tag = VersionTrait(entity_data).getStableTag()\n",
    "    print(f\"{name} (Version '{version_tag}')\")\n",
    "    helpers.display_image(LocatableContentTrait(entity_data).getLocation())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a05b7b25-6414-4679-8dfa-d34c0a0d24b5",
   "metadata": {
    "editable": true,
    "jp-MarkdownHeadingCollapsed": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "## Querying a specific version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62c0dea8-42ed-47a0-b62a-fffe552ddf05",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "We can also set trait properties when we make a relationship query, and this will act as a filter. we're going to use the `getWithRelationship` method with the unversioned entity reference, to query the reference for a specific version of the entity - v1 - using a specific version tag (perhaps entered by the user or previously obtained from the `VersionTrait`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fa2020ad-f6bb-458d-8ab1-8dd9b93dc1ce",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [],
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.523925290Z",
     "start_time": "2024-01-26T15:32:47.510634889Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> - `bal:///project_artwork/logos/openassetio?v=1`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from openassetio.access import RelationsAccess\n",
    "\n",
    "from openassetio_mediacreation.specifications.lifecycle import EntityVersionsRelationshipSpecification\n",
    "\n",
    "# Define the relationship we wish to query, and the specific\n",
    "# tag we want to look up (using data from a previous API call\n",
    "# or specified by the end-user).\n",
    "relationship_spec = EntityVersionsRelationshipSpecification.create()\n",
    "relationship_spec.versionTrait().setSpecifiedTag(\"1\")\n",
    "\n",
    "# Note that the relationship query methods don't yet have the same\n",
    "# convenience overloads that resolve does, and so required the use\n",
    "# of the more elaborate callback signature.\n",
    "related_refs = []\n",
    "manager.getWithRelationship(\n",
    "    [logo_ref], \n",
    "    relationship_spec.traitsData(), \n",
    "    10,\n",
    "    RelationsAccess.kRead, \n",
    "    context, \n",
    "    lambda _, pager: related_refs.extend(pager.get()), lambda _, err: print(err.message))\n",
    "\n",
    "helpers.display_result(related_refs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4b2eb7-47a4-4000-808e-37018ab38b30",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "We now have a reference to the specific version, without needing to know anything about how the managers entity references are formatted."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aeaf557-955b-48b3-b9f9-0edb2bf2512e",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Obtaining a stable reference"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b54e1a8c-5ced-4133-b464-a38fa31e765f",
   "metadata": {},
   "source": [
    "As we saw earlier, some asset management systems may make use of dynamic behaviour, such as a \"latest\" version. If you desire to persist an entity reference as it stands at any given point in time, you can query the `StableReferenceRelationshipSpecification`from the `specifications.lifecycle` module. This only ever returns a single entity reference, that is guaranteed to be free from any dynamic behaviour. This can be useful if you need to persist a reference and guarantee the referenced entity won't change over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c65a49f4-17ef-469f-ac13-1e4baf02779b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-01-26T15:32:47.567365618Z",
     "start_time": "2024-01-26T15:32:47.510755525Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": "> **Result:**\n> - `bal:///project_artwork/logos/openassetio?v=2`"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from openassetio.access import RelationsAccess\n",
    "\n",
    "from openassetio_mediacreation.specifications.lifecycle import StableReferenceRelationshipSpecification\n",
    "\n",
    "# Note that the relationship query methods don't yet have the same\n",
    "# convenience overloads that resolve does, and so required the use\n",
    "# of the more elaborate callback signature.\n",
    "stable_refs = []\n",
    "manager.getWithRelationship(\n",
    "    [logo_ref], \n",
    "    StableReferenceRelationshipSpecification.create().traitsData(),\n",
    "    10,\n",
    "    RelationsAccess.kRead, \n",
    "    context, \n",
    "    lambda _, pager: stable_refs.extend(pager.get()), lambda _, err: print(err.message))\n",
    "\n",
    "helpers.display_result(stable_refs)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}