Notehub Py Library Overview

import notehub_py

import notehub_py

configuration = notehub_py.Configuration(
    access_token = "YOUR_ACCESS_TOKEN"
)

import notehub_py
from pprint import pprint

configuration = notehub_py.Configuration(
    access_token = "YOUR_ACCESS_TOKEN"
)

project_uid = "app:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

with notehub_py.ApiClient(configuration) as api_client:
    api_instance = notehub_py.EventApi(api_client)
    try:
        response = api_instance.get_events(project_uid, page_size=10)
        pprint(response)
    except notehub_py.ApiException as e:
        print(f"Error: {e}")

import notehub_py
from notehub_py.models.get_billing_account200_response import (
    GetBillingAccount200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.BillingAccountApi(api_client)
    billing_account_uid = "00000000-0000-0000-000000000001"  # str |

    try:
        api_response = api_instance.get_billing_account(billing_account_uid)
        print("The response of BillingAccountApi->get_billing_account:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling BillingAccountApi->get_billing_account: %s\n" % e)

import notehub_py
from notehub_py.models.get_billing_account_balance_history200_response import (
    GetBillingAccountBalanceHistory200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.BillingAccountApi(api_client)
    billing_account_uid = "00000000-0000-0000-000000000001"  # str |
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)

    try:
        api_response = api_instance.get_billing_account_balance_history(
            billing_account_uid, start_date=start_date, end_date=end_date
        )
        print(
            "The response of BillingAccountApi->get_billing_account_balance_history:\n"
        )
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling BillingAccountApi->get_billing_account_balance_history: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.get_billing_accounts200_response import (
    GetBillingAccounts200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.BillingAccountApi(api_client)

    try:
        api_response = api_instance.get_billing_accounts()
        print("The response of BillingAccountApi->get_billing_accounts:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling BillingAccountApi->get_billing_accounts: %s\n" % e
        )

import notehub_py
from notehub_py.models.note_input import NoteInput
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    note_id = "note_id_example"  # str |
    note_input = (
        notehub_py.NoteInput()
    )  # NoteInput | Body or payload of note to be added to the device

    try:
        api_instance.add_db_note(
            project_or_product_uid, device_uid, notefile_id, note_id, note_input
        )
    except Exception as e:
        print("Exception when calling DeviceApi->add_db_note: %s\n" % e)

import notehub_py
from notehub_py.models.note_input import NoteInput
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    note_input = (
        notehub_py.NoteInput()
    )  # NoteInput | Body or payload of note to be added to the device

    try:
        api_instance.add_qi_note(
            project_or_product_uid, device_uid, notefile_id, note_input
        )
    except Exception as e:
        print("Exception when calling DeviceApi->add_qi_note: %s\n" % e)

import notehub_py
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |

    try:
        api_instance.create_notefile(project_or_product_uid, device_uid, notefile_id)
    except Exception as e:
        print("Exception when calling DeviceApi->create_notefile: %s\n" % e)

import notehub_py
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_instance.delete_device(project_or_product_uid, device_uid)
    except Exception as e:
        print("Exception when calling DeviceApi->delete_device: %s\n" % e)

import notehub_py
from notehub_py.models.environment_variables import EnvironmentVariables
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    key = "key_example"  # str | The environment variable key to delete.

    try:
        api_response = api_instance.delete_device_environment_variable(
            project_or_product_uid, device_uid, key
        )
        print("The response of DeviceApi->delete_device_environment_variable:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->delete_device_environment_variable: %s\n"
            % e
        )

import notehub_py
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    note_id = "note_id_example"  # str |

    try:
        api_instance.delete_note(
            project_or_product_uid, device_uid, notefile_id, note_id
        )
    except Exception as e:
        print("Exception when calling DeviceApi->delete_note: %s\n" % e)

import notehub_py
from notehub_py.models.delete_notefiles_request import DeleteNotefilesRequest
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    delete_notefiles_request = (
        notehub_py.DeleteNotefilesRequest()
    )  # DeleteNotefilesRequest |

    try:
        api_instance.delete_notefiles(
            project_or_product_uid, device_uid, delete_notefiles_request
        )
    except Exception as e:
        print("Exception when calling DeviceApi->delete_notefiles: %s\n" % e)

import notehub_py
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_instance.disable_device(project_or_product_uid, device_uid)
    except Exception as e:
        print("Exception when calling DeviceApi->disable_device: %s\n" % e)

import notehub_py
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_instance.enable_device(project_or_product_uid, device_uid)
    except Exception as e:
        print("Exception when calling DeviceApi->enable_device: %s\n" % e)

import notehub_py
from notehub_py.models.get_db_note200_response import GetDbNote200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    note_id = "note_id_example"  # str |
    delete = True  # bool | Whether to delete the note from the DB notefile (optional)
    deleted = True  # bool | Whether to return deleted notes (optional)

    try:
        api_response = api_instance.get_db_note(
            project_or_product_uid,
            device_uid,
            notefile_id,
            note_id,
            delete=delete,
            deleted=deleted,
        )
        print("The response of DeviceApi->get_db_note:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_db_note: %s\n" % e)

import notehub_py
from notehub_py.models.device import Device
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_response = api_instance.get_device(project_or_product_uid, device_uid)
        print("The response of DeviceApi->get_device:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device: %s\n" % e)

import notehub_py
from notehub_py.models.env_tree_json_node import EnvTreeJsonNode
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        # Get environment variable hierarchy for a device
        api_response = api_instance.get_device_environment_hierarchy(
            project_or_product_uid, device_uid
        )
        print("The response of DeviceApi->get_device_environment_hierarchy:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->get_device_environment_hierarchy: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.get_device_environment_variables_by_pin200_response import (
    GetDeviceEnvironmentVariablesByPin200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_response = api_instance.get_device_environment_variables(
            project_or_product_uid, device_uid
        )
        print("The response of DeviceApi->get_device_environment_variables:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->get_device_environment_variables: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.get_device_environment_variables_by_pin200_response import (
    GetDeviceEnvironmentVariablesByPin200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint


# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    product_uid = "com.blues.bridge:sensors"  # str |
    device_uid = "dev:000000000000000"  # str |
    x_auth_token = (
        "x_auth_token_example"  # str | For accessing endpoints by Device pin.
    )

    try:
        api_response = api_instance.get_device_environment_variables_by_pin(
            product_uid, device_uid, x_auth_token
        )
        print("The response of DeviceApi->get_device_environment_variables_by_pin:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->get_device_environment_variables_by_pin: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.get_device_health_log200_response import (
    GetDeviceHealthLog200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)
    log_type = [
        "log_type_example"
    ]  # List[str] | Return only specified log types (optional)

    try:
        api_response = api_instance.get_device_health_log(
            project_or_product_uid,
            device_uid,
            start_date=start_date,
            end_date=end_date,
            log_type=log_type,
        )
        print("The response of DeviceApi->get_device_health_log:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_health_log: %s\n" % e)

import notehub_py
from notehub_py.models.get_device_latest_events200_response import (
    GetDeviceLatestEvents200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_response = api_instance.get_device_latest_events(
            project_or_product_uid, device_uid
        )
        print("The response of DeviceApi->get_device_latest_events:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_latest_events: %s\n" % e)

import notehub_py
from notehub_py.models.get_device_plans200_response import GetDevicePlans200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_response = api_instance.get_device_plans(project_or_product_uid, device_uid)
        print("The response of DeviceApi->get_device_plans:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_plans: %s\n" % e)

import notehub_py
from notehub_py.models.get_device_public_key200_response import (
    GetDevicePublicKey200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |

    try:
        api_response = api_instance.get_device_public_key(
            project_or_product_uid, device_uid
        )
        print("The response of DeviceApi->get_device_public_key:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_public_key: %s\n" % e)

import notehub_py
from notehub_py.models.get_device_public_keys200_response import (
    GetDevicePublicKeys200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)

    try:
        api_response = api_instance.get_device_public_keys(
            project_or_product_uid, page_size=page_size, page_num=page_num
        )
        print("The response of DeviceApi->get_device_public_keys:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_public_keys: %s\n" % e)

import notehub_py
from notehub_py.models.get_device_sessions200_response import (
    GetDeviceSessions200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)
    first_sync = False  # bool | When true, filters results to only show first sync sessions (optional) (default to False)

    try:
        api_response = api_instance.get_device_sessions(
            project_or_product_uid,
            device_uid,
            page_size=page_size,
            page_num=page_num,
            start_date=start_date,
            end_date=end_date,
            first_sync=first_sync,
        )
        print("The response of DeviceApi->get_device_sessions:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_device_sessions: %s\n" % e)

import notehub_py
from notehub_py.models.get_devices200_response import GetDevices200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)
    tag = ["tag_example"]  # List[str] | Tag filter (optional)
    serial_number = [
        "serial_number_example"
    ]  # List[str] | Serial number filter (optional)
    fleet_uid = ["fleet_uid_example"]  # List[str] |  (optional)
    notecard_firmware = [
        "notecard_firmware_example"
    ]  # List[str] | Firmware version filter (optional)
    location = ["location_example"]  # List[str] | Location filter (optional)
    host_firmware = [
        "host_firmware_example"
    ]  # List[str] | Host firmware filter (optional)
    product_uid = ["product_uid_example"]  # List[str] |  (optional)
    sku = ["sku_example"]  # List[str] | SKU filter (optional)

    try:
        api_response = api_instance.get_devices(
            project_or_product_uid,
            page_size=page_size,
            page_num=page_num,
            device_uid=device_uid,
            tag=tag,
            serial_number=serial_number,
            fleet_uid=fleet_uid,
            notecard_firmware=notecard_firmware,
            location=location,
            host_firmware=host_firmware,
            product_uid=product_uid,
            sku=sku,
        )
        print("The response of DeviceApi->get_devices:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_devices: %s\n" % e)

import notehub_py
from notehub_py.models.get_devices200_response import GetDevices200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    fleet_uid = "fleet_uid_example"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)
    tag = ["tag_example"]  # List[str] | Tag filter (optional)
    serial_number = [
        "serial_number_example"
    ]  # List[str] | Serial number filter (optional)
    notecard_firmware = [
        "notecard_firmware_example"
    ]  # List[str] | Firmware version filter (optional)
    location = ["location_example"]  # List[str] | Location filter (optional)
    host_firmware = [
        "host_firmware_example"
    ]  # List[str] | Host firmware filter (optional)
    product_uid = ["product_uid_example"]  # List[str] |  (optional)
    sku = ["sku_example"]  # List[str] | SKU filter (optional)

    try:
        api_response = api_instance.get_fleet_devices(
            project_or_product_uid,
            fleet_uid,
            page_size=page_size,
            page_num=page_num,
            device_uid=device_uid,
            tag=tag,
            serial_number=serial_number,
            notecard_firmware=notecard_firmware,
            location=location,
            host_firmware=host_firmware,
            product_uid=product_uid,
            sku=sku,
        )
        print("The response of DeviceApi->get_fleet_devices:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_fleet_devices: %s\n" % e)

import notehub_py
from notehub_py.models.get_notefile200_response import GetNotefile200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    max = 56  # int | The maximum number of Notes to return in the request. (optional)
    deleted = True  # bool | true to return deleted notes. (optional)
    delete = True  # bool | true to delete the notes returned by the request. (optional)

    try:
        api_response = api_instance.get_notefile(
            project_or_product_uid,
            device_uid,
            notefile_id,
            max=max,
            deleted=deleted,
            delete=delete,
        )
        print("The response of DeviceApi->get_notefile:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->get_notefile: %s\n" % e)

import notehub_py
from notehub_py.models.notefile import Notefile
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    files = [
        "files_example"
    ]  # List[str] | One or more files to obtain change information from. (optional)
    pending = (
        True  # bool | show only files that are pending sync to the Notecard (optional)
    )

    try:
        api_response = api_instance.list_notefiles(
            project_or_product_uid, device_uid, files=files, pending=pending
        )
        print("The response of DeviceApi->list_notefiles:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->list_notefiles: %s\n" % e)

import notehub_py
from notehub_py.models.provision_device_request import ProvisionDeviceRequest
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    provision_device_request = (
        notehub_py.ProvisionDeviceRequest()
    )  # ProvisionDeviceRequest | Provision a device to a specific ProductUID

    try:
        api_response = api_instance.provision_device(
            project_or_product_uid, device_uid, provision_device_request
        )
        print("The response of DeviceApi->provision_device:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->provision_device: %s\n" % e)

import notehub_py
from notehub_py.models.environment_variables import EnvironmentVariables
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    environment_variables = (
        notehub_py.EnvironmentVariables()
    )  # EnvironmentVariables | Environment variables to be added to the device

    try:
        api_response = api_instance.set_device_environment_variables(
            project_or_product_uid, device_uid, environment_variables
        )
        print("The response of DeviceApi->set_device_environment_variables:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->set_device_environment_variables: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.environment_variables import EnvironmentVariables
from notehub_py.rest import ApiException
from pprint import pprint


# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    product_uid = "com.blues.bridge:sensors"  # str |
    device_uid = "dev:000000000000000"  # str |
    x_auth_token = (
        "x_auth_token_example"  # str | For accessing endpoints by Device pin.
    )
    environment_variables = (
        notehub_py.EnvironmentVariables()
    )  # EnvironmentVariables | Environment variables to be added to the device

    try:
        api_response = api_instance.set_device_environment_variables_by_pin(
            product_uid, device_uid, x_auth_token, environment_variables
        )
        print("The response of DeviceApi->set_device_environment_variables_by_pin:\n")
        pprint(api_response)
    except Exception as e:
        print(
            "Exception when calling DeviceApi->set_device_environment_variables_by_pin: %s\n"
            % e
        )

import notehub_py
from notehub_py.models.body import Body
from notehub_py.models.signal_device200_response import SignalDevice200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    body = (
        notehub_py.Body()
    )  # Body | Body or payload of signal to be sent to the device

    try:
        api_response = api_instance.signal_device(
            project_or_product_uid, device_uid, body
        )
        print("The response of DeviceApi->signal_device:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling DeviceApi->signal_device: %s\n" % e)

import notehub_py
from notehub_py.models.note_input import NoteInput
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.DeviceApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    device_uid = "dev:000000000000000"  # str |
    notefile_id = "notefile_id_example"  # str |
    note_id = "note_id_example"  # str |
    note_input = (
        notehub_py.NoteInput()
    )  # NoteInput | Body or payload of note to be added to the device

    try:
        api_instance.update_db_note(
            project_or_product_uid, device_uid, notefile_id, note_id, note_input
        )
    except Exception as e:
        print("Exception when calling DeviceApi->update_db_note: %s\n" % e)

import notehub_py
from notehub_py.models.get_events200_response import GetEvents200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.EventApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)
    sort_by = "captured"  # str |  (optional) (default to 'captured')
    sort_order = "asc"  # str |  (optional) (default to 'asc')
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)
    date_type = "captured"  # str | Which date to filter on, either 'captured' or 'uploaded'.  This will apply to the startDate and endDate parameters (optional) (default to 'captured')
    system_files_only = True  # bool |  (optional)
    files = "_health.qo, data.qo"  # str |  (optional)
    format = (
        "json"  # str | Response format (JSON or CSV) (optional) (default to 'json')
    )
    serial_number = [
        "serial_number_example"
    ]  # List[str] | Filter by Serial Number (optional)
    fleet_uid = ["fleet_uid_example"]  # List[str] | Filter by Fleet UID (optional)
    session_uid = [
        "session_uid_example"
    ]  # List[str] | Filter by Session UID (optional)
    event_uid = ["event_uid_example"]  # List[str] | Filter by Event UID (optional)
    select_fields = "select_fields_example"  # str | Comma-separated list of fields to select from JSON payload (e.g., \"field1,field2.subfield,field3\"), this will reflect the columns in the CSV output. (optional)

    try:
        api_response = api_instance.get_events(
            project_or_product_uid,
            page_size=page_size,
            page_num=page_num,
            device_uid=device_uid,
            sort_by=sort_by,
            sort_order=sort_order,
            start_date=start_date,
            end_date=end_date,
            date_type=date_type,
            system_files_only=system_files_only,
            files=files,
            format=format,
            serial_number=serial_number,
            fleet_uid=fleet_uid,
            session_uid=session_uid,
            event_uid=event_uid,
            select_fields=select_fields,
        )
        print("The response of EventApi->get_events:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling EventApi->get_events: %s\n" % e)

import notehub_py
from notehub_py.models.get_events_by_cursor200_response import (
    GetEventsByCursor200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.EventApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    limit = 50  # int |  (optional) (default to 50)
    cursor = "cursor_example"  # str | A cursor, which can be obtained from the `next_cursor` value from a previous call to this endpoint. The results set returned will include this event as its first result if the given identifier is actually the UID of an event. If this event UID is not found, the parameter is ignored and the results set is the same as if the parameter was not included.  (optional)
    sort_order = "asc"  # str |  (optional) (default to 'asc')
    system_files_only = True  # bool |  (optional)
    files = "_health.qo, data.qo"  # str |  (optional)
    fleet_uid = "fleet_uid_example"  # str |  (optional)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)

    try:
        api_response = api_instance.get_events_by_cursor(
            project_or_product_uid,
            limit=limit,
            cursor=cursor,
            sort_order=sort_order,
            system_files_only=system_files_only,
            files=files,
            fleet_uid=fleet_uid,
            device_uid=device_uid,
        )
        print("The response of EventApi->get_events_by_cursor:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling EventApi->get_events_by_cursor: %s\n" % e)

import notehub_py
from notehub_py.models.get_events200_response import GetEvents200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.EventApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    fleet_uid = "fleet_uid_example"  # str |
    page_size = 50  # int |  (optional) (default to 50)
    page_num = 1  # int |  (optional) (default to 1)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)
    sort_by = "captured"  # str |  (optional) (default to 'captured')
    sort_order = "asc"  # str |  (optional) (default to 'asc')
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)
    date_type = "captured"  # str | Which date to filter on, either 'captured' or 'uploaded'.  This will apply to the startDate and endDate parameters (optional) (default to 'captured')
    system_files_only = True  # bool |  (optional)
    files = "_health.qo, data.qo"  # str |  (optional)
    format = (
        "json"  # str | Response format (JSON or CSV) (optional) (default to 'json')
    )
    serial_number = [
        "serial_number_example"
    ]  # List[str] | Filter by Serial Number (optional)
    session_uid = [
        "session_uid_example"
    ]  # List[str] | Filter by Session UID (optional)
    event_uid = ["event_uid_example"]  # List[str] | Filter by Event UID (optional)
    select_fields = "select_fields_example"  # str | Comma-separated list of fields to select from JSON payload (e.g., \"field1,field2.subfield,field3\"), this will reflect the columns in the CSV output. (optional)

    try:
        api_response = api_instance.get_fleet_events(
            project_or_product_uid,
            fleet_uid,
            page_size=page_size,
            page_num=page_num,
            device_uid=device_uid,
            sort_by=sort_by,
            sort_order=sort_order,
            start_date=start_date,
            end_date=end_date,
            date_type=date_type,
            system_files_only=system_files_only,
            files=files,
            format=format,
            serial_number=serial_number,
            session_uid=session_uid,
            event_uid=event_uid,
            select_fields=select_fields,
        )
        print("The response of EventApi->get_fleet_events:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling EventApi->get_fleet_events: %s\n" % e)

import notehub_py
from notehub_py.models.get_events_by_cursor200_response import (
    GetEventsByCursor200Response,
)
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.EventApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    fleet_uid = "fleet_uid_example"  # str |
    limit = 50  # int |  (optional) (default to 50)
    cursor = "cursor_example"  # str | A cursor, which can be obtained from the `next_cursor` value from a previous call to this endpoint. The results set returned will include this event as its first result if the given identifier is actually the UID of an event. If this event UID is not found, the parameter is ignored and the results set is the same as if the parameter was not included.  (optional)
    sort_order = "asc"  # str |  (optional) (default to 'asc')
    system_files_only = True  # bool |  (optional)
    files = "_health.qo, data.qo"  # str |  (optional)
    device_uid = ["device_uid_example"]  # List[str] | A Device UID. (optional)
    start_date = 1628631763  # int | Start date for filtering results, specified as a Unix timestamp (optional)
    end_date = 1657894210  # int | End date for filtering results, specified as a Unix timestamp (optional)

    try:
        api_response = api_instance.get_fleet_events_by_cursor(
            project_or_product_uid,
            fleet_uid,
            limit=limit,
            cursor=cursor,
            sort_order=sort_order,
            system_files_only=system_files_only,
            files=files,
            device_uid=device_uid,
            start_date=start_date,
            end_date=end_date,
        )
        print("The response of EventApi->get_fleet_events_by_cursor:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling EventApi->get_fleet_events_by_cursor: %s\n" % e)

import notehub_py
from notehub_py.models.route_log import RouteLog
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.EventApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    event_uid = "4506f411-dea6-44a0-9743-1130f57d7747"  # str |

    try:
        api_response = api_instance.get_route_logs_by_event(
            project_or_product_uid, event_uid
        )
        print("The response of EventApi->get_route_logs_by_event:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling EventApi->get_route_logs_by_event: %s\n" % e)

import notehub_py
from notehub_py.models.cancel_job_run200_response import CancelJobRun200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    report_uid = "my-reconciliation-job-1707654321000"  # str | Unique identifier for a job run report

    try:
        api_response = api_instance.cancel_job_run(project_or_product_uid, report_uid)
        print("The response of JobsApi->cancel_job_run:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->cancel_job_run: %s\n" % e)

import notehub_py
from notehub_py.models.create_job201_response import CreateJob201Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    name = "name_example"  # str | Name for the job
    body = None  # object | The job definition as raw JSON

    try:
        api_response = api_instance.create_job(project_or_product_uid, name, body)
        print("The response of JobsApi->create_job:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->create_job: %s\n" % e)

import notehub_py
from notehub_py.models.delete_job200_response import DeleteJob200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    job_uid = "my-reconciliation-job"  # str | Unique identifier for a batch job

    try:
        api_response = api_instance.delete_job(project_or_product_uid, job_uid)
        print("The response of JobsApi->delete_job:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->delete_job: %s\n" % e)

import notehub_py
from notehub_py.models.job import Job
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    job_uid = "my-reconciliation-job"  # str | Unique identifier for a batch job

    try:
        api_response = api_instance.get_job(project_or_product_uid, job_uid)
        print("The response of JobsApi->get_job:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->get_job: %s\n" % e)

import notehub_py
from notehub_py.models.job_run import JobRun
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    report_uid = "my-reconciliation-job-1707654321000"  # str | Unique identifier for a job run report

    try:
        api_response = api_instance.get_job_run(project_or_product_uid, report_uid)
        print("The response of JobsApi->get_job_run:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->get_job_run: %s\n" % e)

import notehub_py
from notehub_py.models.get_job_runs200_response import GetJobRuns200Response
from notehub_py.rest import ApiException
from pprint import pprint

configuration = notehub_py.Configuration(access_token="PERSONAL_ACCESS_TOKEN")

# Enter a context with an instance of the API client
with notehub_py.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = notehub_py.JobsApi(api_client)
    project_or_product_uid = "app:2606f411-dea6-44a0-9743-1130f57d77d8"  # str |
    job_uid = "my-reconciliation-job"  # str | Unique identifier for a batch job
    status = "status_example"  # str | Filter runs by status (optional)
    dry_run = True  # bool | Filter runs by dry run flag (optional)

    try:
        api_response = api_instance.get_job_runs(
            project_or_product_uid, job_uid, status=status, dry_run=dry_run
        )
        print("The response of JobsApi->get_job_runs:\n")
        pprint(api_response)
    except Exception as e:
        print("Exception when calling JobsApi->get_job_runs: %s\n" % e)