V1/product/edm/Maintaining an instrument master in LUSID.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        }
      },
      "outputs": [],
      "source": [
        "\"\"\"Maintaining an instrument master\n",
        "\n",
        "Demonstrates how to import, update, retrieve, and delete instruments.\n",
        "\n",
        "Attributes\n",
        "----------\n",
        "instruments\n",
        "properties\n",
        "search\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Instruments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "LUSID treats instruments as a first class object. They are at the core of much of LUSID's functionality and are required to post transactions and holdings. Read more about how instruments are treated inside LUSID here [LUSID Knowledge Base: Instruments](https://support.lusid.com/what-is-an-instrument).\n",
        "\n",
        "In this notebook we will cover how to work with instruments inside LUSID. We will:\n",
        "\n",
        "1) Locally import our instrument universe from a CSV file\n",
        "\n",
        "2) Determine what identifiers we can use for our instruments\n",
        "\n",
        "3) Upsert our instruments into LUSID\n",
        "\n",
        "4) Test that we can retrieve an instrument by its identifier\n",
        "\n",
        "5) Add some reference data to our instruments e.g. security type\n",
        "\n",
        "6) Search for all equity instruments using the security type reference data we added\n",
        "\n",
        "7) Update the identifier for one of our instruments\n",
        "\n",
        "8) Delete a handful of instruments \n",
        "\n",
        "*First things first, run the cell below to import the libraries and create the LUSID client*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Import LUSID\n",
        "import lusid\n",
        "import lusid.models as models\n",
        "import lusid_sample_data as import_data\n",
        "from lusidjam import RefreshingToken\n",
        "\n",
        "# Import Libraries\n",
        "import pprint\n",
        "from datetime import datetime, timedelta, time\n",
        "import pytz\n",
        "import printer as prettyprint\n",
        "import pandas as pd\n",
        "import uuid\n",
        "import os\n",
        "\n",
        "# Authenticate our user and create our API client\n",
        "secrets_path = os.getenv(\"FBN_SECRETS_PATH\")\n",
        "\n",
        "api_factory = lusid.utilities.ApiClientFactory(\n",
        "    token=RefreshingToken(),\n",
        "    api_secrets_filename = secrets_path,\n",
        "    app_name=\"LusidJupyterNotebook\")\n",
        "\n",
        "print ('LUSID Environment Initialised')\n",
        "print ('API Version: ', api_factory.build(lusid.api.ApplicationMetadataApi).get_lusid_versions().build_version)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 1) Import our instrument universe"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The first thing that we need to do is get the information about our instruments. In this case we are going to import our instrument universe from a CSV file which has been exported from another one of our systems. \n",
        "\n",
        "*Run the cell below to import our instruments and show the first 15 securities*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        }
      },
      "outputs": [],
      "source": [
        "# Import our instruments from a CSV file using Pandas\n",
        "instruments = pd.read_csv('data/instruments.csv')\n",
        "# View the first 15 instruments\n",
        "instruments.head(n=15)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Here we can see that our instrument universe contains a mix of equities and bonds. Each instrument has a number of identifiers attached to it as well as some basic reference information. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 2) Get allowable instrument identifiers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Great now we have our instrument information we want to add our instruments to LUSID.\n",
        "\n",
        "To add each instrument to LUSID we must have at least one unique identifier for it. \n",
        "\n",
        "This is because LUSID uses a bi-temporal data store, which means that no instrument is ever truly deleted. There are thus restrictions on what can and can't be used as a unique identifier. This ensures that there are no collisions between instruments which would arise from using an identifier which may be re-purposed. Read more about LUSID's bi-temporal data store here [LUSID Knowledge Base: Bi-Temporal Data Store](https://support.lusid.com/what-is-bi-temporal-data).\n",
        "\n",
        "We can call LUSID to find out what the allowable types of instrument indentifiers are. Read more about identifier schemes in LUSID here [LUSID Knowledge Base: Identifier Schemes](https://support.lusid.com/which-instrument-identifier-schemes-should-i-use-with-lusid). \n",
        "\n",
        "For further usage of the get instrument identifiers API call refer to the [LUSID API Docs: Get Allowable Instrument Identifiers](https://docs.lusid.com/#operation/GetInstrumentIdentifiers).\n",
        "\n",
        "*Run the cell below to get our allowable instrument identifiers*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Call LUSID to get our allowable instrument indentifiers\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).get_instrument_identifier_types()\n",
        "\n",
        "# Extract the unique identifiers from the response and print them\n",
        "prettyprint.get_identifiers(response, unique=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "These are the unique identifiers that we can use when adding our instruments to LUSID. We must provide at least one of them for each instrument. \n",
        "\n",
        "We can also find the available non-unique identifiers.\n",
        "\n",
        "*Run the cell below to see the non-unique identifiers that are available*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Extract the non-unique identifiers from the response and print them\n",
        "prettyprint.get_identifiers(response, unique=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 3) Upsert instruments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now that we know which instrument identifiers we can use, we can go ahead and create an instrument definition for each instrument. These can then be upserted into LUSID. Read about instrument definitions here [LUSID Knowledge Base: What is an Instrument?](https://support.lusid.com/what-is-an-instrument).\n",
        "\n",
        "As part of this definition we will also attach two alias identifiers to our instruments. Read more about alias identifiers here [LUSID Knowledge Base: What is an Alias Identifier?](https://support.lusid.com/alias-identifiers).\n",
        "\n",
        "We use an upsert method to add instrument definitions to the instrument universe. Read more about the behaviour of the upsert method here [LUSID Knowledge Base: Upsert](https://support.lusid.com/upsert-command).\n",
        "\n",
        "For further usage of the upsert instruments API call refer to the [LUSID API Docs: Upserting Instruments](https://docs.lusid.com/#operation/UpsertInstruments).\n",
        "\n",
        "*Run the cell below to upsert our instruments into LUSID*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Initialise dictionary to hold our instrument definitions\n",
        "definitions = {}\n",
        "instrument_scope = 'Finbourne-Examples'\n",
        "\n",
        "# Iterate over each row in our instrument universe\n",
        "for row, instrument in instruments.iterrows():\n",
        "    \n",
        "    # Specify your identifier columns\n",
        "    identifier_columns = [\n",
        "        ('isin', 'Isin'), \n",
        "        ('figi', 'Figi'), \n",
        "        ('ticker', 'Ticker'),\n",
        "        ('client_internal', 'ClientInternal')\n",
        "    ]\n",
        "    \n",
        "    # Create your identifiers\n",
        "    identifiers = {}\n",
        "    for identifier in identifier_columns:\n",
        "        identifiers[identifier[1]] = models.InstrumentIdValue(\n",
        "            value=instrument[identifier[0]])\n",
        "    \n",
        "    # Create our definitions\n",
        "    definitions[instrument['instrument_name']] = models.InstrumentDefinition(\n",
        "        name=instrument['instrument_name'],\n",
        "        identifiers=identifiers)\n",
        "    \n",
        "# Call the LUSID API to upsert our instrument definitions\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).upsert_instruments(request_body=definitions, scope = instrument_scope)\n",
        "\n",
        "# Print each the definition of each instrument returned in the response\n",
        "for figi, instrument in response.values.items():\n",
        "    print('Figi: ' + figi + '\\n',\n",
        "          'Instrument Name: ' + instrument.name + '\\n', \n",
        "          'Instrument Scope: ' + instrument.scope + '\\n', \n",
        "          'LUSID Instrument ID: ' + instrument.lusid_instrument_id + '\\n'+'\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We have added our instruments to LUSID! We can now use these instruments to book trades and set holdings.\n",
        "\n",
        "As you can see every instrument that is upserted into LUSID is given a LUSID unique instrument Identifier. This is a globally unique identifier for the instrument and is used in some calls to LUSID. Read more about LUSID Unique Instrument Identifiers here [LUSID Knoweldge Base: LUSID Instrument Identifiers](https://support.lusid.com/what-is-a-lusid-unique-identifier-luid)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 4) Retrieve an Instrument by its Identifier"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In addition to listing all instruments we can also retrieve an instrument individually by searching for it by one of its unique identifiers. \n",
        "\n",
        "Here we can look up one of our instruments by its Financial Instrument Global Identifier (FIGI). \n",
        "\n",
        "For further usage of the get instrument API call refer to the [LUSID API Docs: Get Instrument Defintion](https://docs.lusid.com/#operation/GetInstrument).\n",
        "\n",
        "*Run the cell below to retrieve our instrument's definition by its FIGI*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Call the LUSID API to retrieve an instrument by its FIGI\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).get_instrument(scope = instrument_scope,\n",
        "    identifier_type='Figi',\n",
        "    identifier='BBG000C05BD1')\n",
        "\n",
        "# Print the response with our instrument definition\n",
        "print('Instrument Name: ' + response.name + '\\n', \n",
        "      'FIGI: ' + response.identifiers['Figi'] + '\\n',\n",
        "      'ClientInternal: ' + response.identifiers['ClientInternal'] + '\\n',\n",
        "      'Instrument Scope: ' + response.scope + '\\n',\n",
        "      'LUSID Instrument ID: ' + response.lusid_instrument_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "As we gave each of our instruments two unique identifiers, i.e. a FIGI and a ClientInternal, we can also look up the same instrument by its ClientInternal identifier.\n",
        "\n",
        "*Run the cell below to retrieve our instrument definition by its ClientInternal identifier*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Call the LUSID API to retrieve an instrument by its ClientInternal ID\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).get_instrument(scope = instrument_scope,\n",
        "    identifier_type='ClientInternal',\n",
        "    identifier='imd_43535553')\n",
        "\n",
        "# Print the response with our instrument\n",
        "print('Instrument Name: ' + response.name + '\\n', \n",
        "      'FIGI: ' + response.identifiers['Figi'] + '\\n',\n",
        "      'ClientInternal: ' + response.identifiers['ClientInternal'] + '\\n',\n",
        "      'Instrument Scope: ' + response.scope + '\\n',\n",
        "      'LUSID Instrument ID: ' + response.lusid_instrument_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also retrieve multiple instruments by passing multiple values of a given identifier into the get instruments method. For further usage of the get instruments API call refer to the [LUSID API Docs: Get Instrument Defintion](https://docs.lusid.com/#operation/GetInstruments).\n",
        "\n",
        "*Run the cell below to retrieve multiple instrument definitions by their FIGI*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Call the LUSID API to retrieve all instruments with a Figi in the provided list\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).get_instruments(scope = instrument_scope,\n",
        "    identifier_type='Figi',\n",
        "    request_body=['BBG000C05BD1', 'BBG000DQQNJ8'])\n",
        "\n",
        "# Print the response with our instrument definitions\n",
        "for figi, instrument in response.values.items():\n",
        "    print('Instrument Name: ' + instrument.name + '\\n', \n",
        "          'FIGI: ' + figi + '\\n',\n",
        "          'ClientInternal: ' + instrument.identifiers['ClientInternal'] + '\\n',\n",
        "          'Instrument Scope: ' + instrument.scope + '\\n',\n",
        "          'LUSID Instrument ID: ' + instrument.lusid_instrument_id + '\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 5) Upsert instrument properties"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In addition to our unique identifier and aliases we can also add properties to our instruments. \n",
        "\n",
        "To define a property we need to create a property definition and then call LUSID to create that property. Read more about property definitions here [LUSID Knowledge Base: Property Definitions](https://support.lusid.com/what-is-a-property-definition). \n",
        "\n",
        "Note that every property is defined by a data type which is referenced by a data type id. Read more about data types here [LUSID Knowledge Base: Data Types](https://support.lusid.com/what-is-a-data-type).\n",
        "\n",
        "Let us create a property to hold the asset class of our instrument.\n",
        "\n",
        "For further usage of the create property definition API call refer to the [LUSID API Docs: Create Property Definition](https://docs.lusid.com/#operation/CreatePropertyDefinition).\n",
        "\n",
        "*Run the cell below to create our security type property*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Define the scope that we will use for our properties\n",
        "properties_scope = 'custom_properties_{}'.format(str(uuid.uuid4()))\n",
        "\n",
        "# Create the request for our new property\n",
        "property_request = models.CreatePropertyDefinitionRequest(\n",
        "    domain='Instrument',\n",
        "    scope=properties_scope,\n",
        "    code='asset_class',\n",
        "    value_required=True,\n",
        "    display_name='asset_class',\n",
        "    life_time='TimeVariant',\n",
        "    data_type_id=models.ResourceId(\n",
        "        scope='system', \n",
        "        code='string'))\n",
        "\n",
        "# Call LUSID to create our new property\n",
        "property_response = api_factory.build(lusid.api.PropertyDefinitionsApi).create_property_definition(\n",
        "    create_property_definition_request=property_request)\n",
        "\n",
        "# Grab the key off the response to use when referencing this property in other LUSID calls\n",
        "asset_class_property_key = property_response.key\n",
        "\n",
        "# Print our property key\n",
        "print (asset_class_property_key)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "As you can see from the call above every property is identified by its key. Read more about properties and their keys here [LUSID Knowledge Base: Properties](https://support.lusid.com/what-is-a-property-definition).\n",
        "\n",
        "We can now add this property to each of our instruments.\n",
        "\n",
        "For further usage of the upsert instrument properties API call refer to the [LUSID API Docs: Upserting Instrument Properties](https://docs.lusid.com/#operation/UpsertInstruments)\n",
        "\n",
        "*Run the cell below to set our asset class property for each of our instruments*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now that we have created our property we can set it across our instrument universe.\n",
        "\n",
        "*Run the cell below to set our asset class property for each of our instruments*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "requests = []\n",
        "\n",
        "for row in instruments.iterrows():\n",
        "    # Collect our instrument data from the row, note row[0] is the index of the row e.g. 3\n",
        "    instrument = row[1]\n",
        "    \n",
        "    # Create our security_type property for this instrument\n",
        "    asset_class_property = models.ModelProperty(\n",
        "        key=asset_class_property_key,\n",
        "        value=models.PropertyValue(\n",
        "            label_value=instrument['market_sector'])\n",
        "    )    \n",
        "    \n",
        "    # Build our request to set our property\n",
        "    requests.append(\n",
        "        models.UpsertInstrumentPropertyRequest(\n",
        "            identifier_type='Figi',\n",
        "            identifier=instrument['figi'],\n",
        "            properties=[asset_class_property]))\n",
        "\n",
        "# Call the LUSID API to add our property across all instruments\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).upsert_instruments_properties(scope = instrument_scope,\n",
        "    upsert_instrument_property_request=requests)\n",
        "\n",
        "# Print our response\n",
        "\n",
        "print ('Instrument properties upserted at {}'.format(\n",
        "    response.as_at_date))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can now call LUSID to retrieve an instrument definition for one of our instruments with our user defined security type property attached. We do this by specifying the property key in the instrument_property_keys argument of the method. \n",
        "\n",
        "*Run the cell below to call LUSID and retrieve our instrument*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Call LUSID to get the ISIN and security type for one of our instruments\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).get_instrument(scope = instrument_scope,\n",
        "    identifier_type='Figi',\n",
        "    identifier='BBG000C05BD1',\n",
        "    property_keys=[\n",
        "        asset_class_property_key\n",
        "    ])\n",
        "\n",
        "# Print the response\n",
        "print('Instrument Name: ' + response.name + '\\n', \n",
        "      'Figi: ' + response.identifiers['Figi'] + '\\n',\n",
        "      'ClientInternal: ' + response.identifiers['ClientInternal'] + '\\n',\n",
        "      'Isin: ' + response.identifiers['Isin'] + '\\n',\n",
        "      'Ticker: ' + response.identifiers['Ticker'] + '\\n',\n",
        "      'Instrument Scope: ' + response.scope + '\\n',\n",
        "      'Lusid Instrument ID: ' + response.lusid_instrument_id + '\\n',\n",
        "      'Asset Class: ' + response.properties[0].value.label_value + '\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also delete a property using the same upsert properties endpoint. We do this by specifying the property key that we'd like to delete. \n",
        "\n",
        "*Run the cell below to delete the asset class property for one of our instruments*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "\n",
        "# Call the LUSID API to add our property across all instruments\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).delete_instrument_properties(scope = instrument_scope,\n",
        "    identifier_type='Figi',\n",
        "    identifier=\"BBG000C05BD1\",\n",
        "    request_body=[\n",
        "          asset_class_property_key\n",
        "    ],\n",
        "    effective_at=datetime.now(pytz.UTC).isoformat()\n",
        ")\n",
        "\n",
        "# Print our response\n",
        "print ('Properties deleted at {}'.format(\n",
        "    response.as_at))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 6) Search instruments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now that we have set some properties on our instruments, we can now go ahead and search our instrument universe that we've just created using these properties.\n",
        "\n",
        "In this case let's search for all equity instruments using our asset class property.\n",
        "\n",
        "For further usage of the instruments search API call refer to the [LUSID API Docs: Search Instruments](https://docs.lusid.com/#operation/InstrumentsSearch)\n",
        "\n",
        "*Run the cell below to search for all our equity securities*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Build our serach request\n",
        "search_request_internal = models.InstrumentSearchProperty(\n",
        "    key=asset_class_property_key,\n",
        "    value='equity')\n",
        "\n",
        "# Call LUSID to search for instruments\n",
        "response = api_factory.build(lusid.api.SearchApi).instruments_search(scope = instrument_scope,\n",
        "    instrument_search_property=[search_request_internal],\n",
        "    mastered_only=True)\n",
        "\n",
        "# Print the instrument definitions from our response\n",
        "for instrument in response[0].mastered_instruments:\n",
        "    print('Instrument Name: ' + instrument.name + '\\n', \n",
        "          'Figi: ' + instrument.identifiers['Figi'].value + '\\n',\n",
        "          'ClientInternal: ' + instrument.identifiers['ClientInternal'].value + '\\n',\n",
        "          'LUSID Instrument ID: ' + instrument.identifiers['LusidInstrumentId'].value +'\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Using search we can also search for instruments that are not currently in the instrument universe inside LUSID. \n",
        "\n",
        "*Run the cell below to search for an instrument that is not in our instrument universe*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "search_request_external = models.InstrumentSearchProperty(\n",
        "    key='Instrument/default/Figi',\n",
        "    value='BBG000BD5TW4')\n",
        "\n",
        "response = api_factory.build(lusid.api.SearchApi).instruments_search(scope = instrument_scope,\n",
        "    instrument_search_property=[search_request_external],\n",
        "    mastered_only=False)\n",
        "\n",
        "for instrument in response[0].external_instruments:\n",
        "    print ('Instrument Name: ' + instrument.name + '\\n', \n",
        "          'Figi: ' + instrument.identifiers['Figi'].value)\n",
        "    for _property in instrument.properties:\n",
        "        print (_property.key, '-', _property.value.label_value)\n",
        "    print ('\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also chain our search requests together. When we use multiple search requests LUSID uses OR logic.\n",
        "\n",
        "*Run the cell below to use both our search requests together*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "response = api_factory.build(lusid.api.SearchApi).instruments_search(scope = instrument_scope,\n",
        "    instrument_search_property=[search_request_internal, search_request_external],\n",
        "    mastered_only=False)\n",
        "\n",
        "for instrument in response[0].mastered_instruments:\n",
        "    print('Instrument Name: ' + instrument.name + '\\n', \n",
        "          'Figi: ' + instrument.identifiers['Figi'].value + '\\n',\n",
        "          'ClientInternal: ' + instrument.identifiers['ClientInternal'].value + '\\n',\n",
        "          'LUSID Instrument ID: ' + instrument.identifiers['LusidInstrumentId'].value +'\\n')\n",
        "\n",
        "for instrument in response[1].external_instruments:\n",
        "    print ('Instrument Name: ' + instrument.name + '\\n', \n",
        "          'Figi: ' + instrument.identifiers['Figi'].value)\n",
        "    for _property in instrument.properties:\n",
        "        print (_property.key, '-', _property.value.label_value)\n",
        "    print ('\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 7) Update instrument identifier"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also update an instruments identifiers. For further usage of the update instrument identifier API call refer to the [LUSID API Docs: Update an Instrument Identifier](https://docs.lusid.com/#operation/UpdateInstrumentIdentifier).\n",
        "\n",
        "*Run the cell below to update the Client Internal Id for one of our instruments*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "pycharm": {
          "is_executing": false
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "request = models.UpdateInstrumentIdentifierRequest(\n",
        "    type='ClientInternal',\n",
        "    value='imd_43535554',\n",
        "    effective_at=None)\n",
        "\n",
        "response = api_factory.build(lusid.api.InstrumentsApi).update_instrument_identifier(scope = instrument_scope,\n",
        "    identifier_type='Figi',\n",
        "    identifier='BBG000C05BD1',\n",
        "    update_instrument_identifier_request=request)\n",
        "\n",
        "# Print the response showing the updated ClientInternal ID\n",
        "print('Instrument Name: ' + response.name + '\\n', \n",
        "      'Figi: ' + response.identifiers['Figi'] + '\\n',\n",
        "      'ClientInternal: ' + response.identifiers['ClientInternal'] + '\\n',\n",
        "      'Isin: ' + response.identifiers['Isin']+ '\\n',\n",
        "      'Ticker: ' + response.identifiers['Ticker'] + '\\n',\n",
        "      'Instrument Scope: ' + response.scope + '\\n',\n",
        "      'Lusid Instrument ID: ' + response.lusid_instrument_id + '\\n')"
      ]
    }
  ],
  "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}