NAV
python shell
API Reference
Realtime Reference

Introduction

The Epsilon3 API is centered around REST principles, using standard HTTP response codes, verbs, and authentication. All API endpoints use resource-oriented URLs and JSON-encoded request and response bodies.

Authentication

The API key is expected as the username component of a basic auth header

export EPSILON3_API_KEY=YOUR_API_KEY

curl -u ${EPSILON3_API_KEY}: ...

# Export API key in shell outside of code with export EPSILON3_API_KEY=YOUR_API_KEY
import os

requests.post(
  url,
  auth=(os.environ.get('EPSILON3_API_KEY'), ''),
  ...
)

Authentication is performed using a per-workspace API key. Reach out to Epsilon3 support for API access.

Builds API

The Builds API can be used to manage your part templates (or bills of materials) and list your entire inventory.

Parts

Get Parts

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/builds/parts',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/builds/parts \
  -u "$EPSILON3_API_KEY":

GET https://api.epsilon3.io/v1/builds/parts

Retrieve all parts defined in your workspace.

Example Response Body

{
  "parts": [
    {
      "id": "vnWtKWleNWiuSQbBPNdE5F",
      "part_number": "P-1",
      "name": "Sample Part",
      "revision": "C",
      "tracking": "serial",
      "description": "This is a sample part assembled in house."
    },
    ...
  ]
}

Get Part

GET https://api.epsilon3.io/v1/builds/parts/:partId?revisionId={revisionId}

Retrieve a single part using its ID.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/builds/parts/vnWtKWleNWiuSQbBPNdE5F

Example Response Body

{
  "id": "vnWtKWleNWiuSQbBPNdE5F",
  "revision": "C",
  "part_number": "P-1",
  "name": "Sample Part",
  "description": "This is a sample part assembled in house.",
  "tracking": "serial",
  "details": [
    {
      "id": "xagtLhLxMEPLTgEHDNiEBa",
      "name": "External Id",
      "value": "123"
    }
  ],
  "revisions": [
    {
      "revision": "C",
      "id": "W4e4WfDe6ZU8OZdvIaJIUw"
    },
    {
      "revision": "B",
      "id": "W4e4WfDe6ZU8OZdvIaJIUw"
    },
    {
      "revision": "A",
      "id": "aIv8S4kVCWuHui7Dax7Smy"
    }
  ],
  "components": [
    {
      "part_id": "xi4kPknhkM79WlWdaEXHth",
      "quantity": 1,
      "revision": "B",
      "revision_id": "3KV7aieAp7jkkE1wZl8WAp"
    }
  ]
}

Create Parts

POST https://api.epsilon3.io/v1/builds/parts

Add one or more parts to your workspace.

Request Body

parts: an array of objects, each containing the following set of fields

Response

The response status code will be 200 and return a list of the created parts.

Request URL

POST https://api.epsilon3.io/v1/builds/parts

Example Request Body

{
  "parts": [
    {
      "part_number": "P-1",
      "name": "Sample Part",
      "revision": "C",
      "tracking": "serial",
      "description": "This is a sample part assembled in house."
    },
    ...
  ]
}

Example Response Body

{
  "parts": [
    {
      "id": "vnWtKWleNWiuSQbBPNdE5F",
      "part_number": "P-1",
      "name": "Sample Part",
      "revision": "C",
      "tracking": "serial",
      "description": "This is a sample part assembled in house.",
      "components": [],
      "revisions": [
        {
          "revision": "C",
          "id": "MkeDh0hepepkhKbczKGP0H"
        }
      ]
    },
    ...
  ]
}

Example request body with a component part

{
  "parts": [
    {
      "part_number": "P-2",
      "name": "Sample Part with components",
      "revision": "A",
      "tracking": "serial",
      "description": "This is a sample part assembled in house.",
      "components": [
        {
          "part_number": "P-1",
          "revision": "C",
          "quantity": 1
        }
      ]
    },
    ...
  ]
}

Example Response Body

{
  "parts": [
    {
      "id": "FMtBcwA5fYZwV4xOJwlRdZ",
      "part_number": "P-2",
      "name": "Sample Part with components",
      "revision": "A",
      "tracking": "serial",
      "description": "This is a sample part assembled in house.",
      "components": [
        {
          "part_id": "vnWtKWleNWiuSQbBPNdE5F",
          "revision": "C",
          "revision_id": "MkeDh0hepepkhKbczKGP0H",
          "quantity": 1
        }
      ],
      "revisions": [
        {
          "revision": "A",
          "id": "k7jaxluqyThfl7PLBIkCbI"
        }
      ]
    },
    ...
  ]
}

Update Part

PATCH https://api.epsilon3.io/v1/builds/parts/:partId

Updates values of one or more fields for a specific part.

Request Body

The request body should be a JSON object that contains the specific fields of the part to be updated. The request body must contain at least one field. Following fields are supported:

Example Request Body

{
  "name": "Sample Part with components",
  "revision": "B",
  "tracking": "serial",
  "description": "This is a sample part assembled in house.",
  "components": [
    {
      "part_number": "P-1",
      "quantity": 1,
      "revision": "C"
    }
  ]
}

Example Response Body

{
  "id": "FMtBcwA5fYZwV4xOJwlRdZ",
  "revision": "B",
  "part_number": "P-2",
  "name": "Sample Part with components",
  "description": "This is a sample part assembled in house.",
  "tracking": "serial",
  "components": [
    {
      "part_id": "vnWtKWleNWiuSQbBPNdE5F",
      "revision": "C",
      "revision_id": "MkeDh0hepepkhKbczKGP0H",
      "quantity": 1,
    }
  ],
  "details": [
    {
      "id": "xagtLhLxMEPLTgEHDNiEBa",
      "name": "External Id",
      "value": "123"
    }
  ],
  "revisions": [
    {
      "revision": "B",
      "id": "W4e4WfDe6ZU8OZdvIaJIUw"
    },
    {
      "revision": "A",
      "id": "k7jaxluqyThfl7PLBIkCbI"
    }
  ]
}

Delete Part

DELETE https://api.epsilon3.io/v1/builds/parts

Bulk deletes parts using provided array of part ids. Deleting a part will also delete it's associated revisions and items. NOTE: Deleted parts will be permanently deleted.

Request Body

{
  "ids": array (string)
}

Example Request Body

{
  "ids": ["SRHRaJV1qBiYZdQ3Tm7P6C", "vnWtKWleNWiuSQbBPNdE5F"]
}

Example Response Body

{
  "deleted_part_ids": ["SRHRaJV1qBiYZdQ3Tm7P6C"],
  "invalid_part_ids": ["vnWtKWleNWiuSQbBPNdE5F"]
}

Inventory

List Inventory

GET https://api.epsilon3.io/v1/builds/inventory

Retrieve all items in your workspace's inventory.

Parameters

Request URL

GET https://api.epsilon3.io/v1/builds/inventory

Example Response Body

{
  "items": [
    {
      "id": "Uqo1eK43QThNE78Rl3HTco",
      "part_id": "vnWtKWleNWiuSQbBPNdE5F",
      "part_revision_id": "MkeDh0hepepkhKbczKGP0H",
      "tracking_id": "P1-004",
      "quantity": 1,
      "location_id": "SRHRaJV1qBiYZdQ3Tm7P6C",
      "unit_cost_cents": 20000,
      "notes": "Passed all quality checks!",
      "created_at": "2023-07-18T14:49:08.713Z"
    },
    ...
  ]
}

Get Inventory Item

GET https://api.epsilon3.io/v1/builds/inventory/:itemId

Retrieve a specific inventory item using its ID.

Example Request URL

GET https://api.epsilon3.io/v1/builds/inventory/Uqo1eK43QThNE78Rl3HTco

Example Response Body

{
  "id": "Uqo1eK43QThNE78Rl3HTco",
  "part_id": "vnWtKWleNWiuSQbBPNdE5F",
  "part_revision_id": "MkeDh0hepepkhKbczKGP0H",
  "tracking_id": "P1-004",
  "quantity": 1,
  "location_id": "SRHRaJV1qBiYZdQ3Tm7P6C",
  "unit_cost_cents": 20000,
  "notes": "Passed all quality checks!",
  "created_at": "2023-07-18T14:49:08.713Z"
}

Add Inventory

POST https://api.epsilon3.io/v1/builds/inventory

Adds new items to inventory.

Request Body

Example Request Body

{
  "items": [
    {
      "part_id": "T7bpWix6bs86tEoCqIk26n",
      "part_revision_id": "m4ssiRUzCcN9mJUKjhvHvA",
      "tracking_id": "TP00001",
      "quantity": 1,
      "location_id": "sw9H7eqyaydlDF390IYliI",
      "unit_cost_cents": 50000,
      "notes": "All inspections passed!"
    },
    ...
  ]
}

Example Response Body

{
  "items": [
    {
      "id": "f4yEjyK8PQNkdRy6EvncFy",
      "part_id": "T7bpWix6bs86tEoCqIk26n",
      "part_revision_id": "m4ssiRUzCcN9mJUKjhvHvA",
      "tracking_id": "TP00001",
      "quantity": 1,
      "location_id": "sw9H7eqyaydlDF390IYliI",
      "unit_cost_cents": 50000,
      "notes": "Passed all quality checks!",
      "created_at": "2023-12-17T01:33:16.996Z"
    },
    ...
  ]
}

Update Inventory Item

PATCH https://api.epsilon3.io/v1/builds/inventory/:itemId

Updates values of one or more fields for a specific item.

Request Body

The request body should be a JSON object that contains the specific fields of the item to be updated. The request body must contain at least one field. Following fields are supported:

Example Request Body

{
  "quantity": 1,
  "location_id": "SRHRaJV1qBiYZdQ3Tm7P6C",
  "unit_cost_cents": 20000,
  "notes": "Passed all quality checks!"
}

Example Response Body

{
  "id": "Uqo1eK43QThNE78Rl3HTco",
  "part_id": "vnWtKWleNWiuSQbBPNdE5F",
  "part_revision_id": "MkeDh0hepepkhKbczKGP0H",
  "tracking_id": "P1-004",
  "quantity": 1,
  "location_id": "SRHRaJV1qBiYZdQ3Tm7P6C",
  "unit_cost_cents": 20000,
  "notes": "Passed all quality checks!",
  "created_at": "2023-07-18T14:49:08.713Z"
}

Delete Inventory

DELETE https://api.epsilon3.io/v1/builds/inventory

Bulk deletes inventory items using provided array of item ids.

Request Body

{
  "ids": array (string),
}

Example Request Body

{
  "ids": ["SRHRaJV1qBiYZdQ3Tm7P6C", "vnWtKWleNWiuSQbBPNdE5F"]
}

Example Response Body

{
  "deleted_item_ids": ["SRHRaJV1qBiYZdQ3Tm7P6C"],
  "invalid_item_ids": ["vnWtKWleNWiuSQbBPNdE5F"]
}

Commanding API

Epsilon3’s commanding API supports creating, updating, retrieving, or deleting commands. Uploading commands to the commanding API allows the user to do the following in Epsilon3:

Create or update a command

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/commands',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
        "name": "test.command",
        "dictionary_id": 1,
        "arguments": [
            {
            "name": "arg1",
            "type": "enum",
            "values": [
                {
                    "string": "OFF",
                    "value": 0
                },
                {
                    "string": "ON",
                    "value": 1
                }]
            },
            {
                "name": "arg2",
                "type": "int"
                "optional": true
            }
        ]}
    )

curl -X POST \
  https://api.epsilon3.io/v1/commands \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
    "name": "test.command",
    "dictionary_id": 1,
    "arguments": [
      {
        "name": "arg1",
        "type": "enum",
        "values": [
            {
              "string": "OFF",
              "value": 0
            },
            {
              "string": "ON",
              "value": 1
            }
        ]
      },
      {
        "name": "arg2",
        "type": "int",
        "optional": true
      }
    ]
}'

Request Body (Command Object)

{
  "name": string,
  "dictionary-id": integer (optional),
  "arguments": array (optional)
}

Argument Object

{
  "name": string,
  "type": string,
  "optional": boolean (optional, defaults to false)
  "values": array (optional)
}

HTTP Request

POST https://api.epsilon3.io/v1/commands

The name field should be unique per dictionary. The arguments field contains an array of one or more Argument objects. The optional dictionary_id field allows the command to be related to a dictionary. If no dictionary_id is provided, the command will be related to the default dictionary.

Supported argument types:

Enum Object

{
  "string": string,
  "value": number
}

Example Request Body (No Arguments)

{
  "name": "test.hatch.1.open"
}

Example Request Body (with a dictionary)

{
  "name": "test.hatch.1.open",
  "dictionary_id": 5
}

Example Request Body (Float)

{
  "name": "test.pressure.level",
  "arguments": [
    {
      "name": "psi",
      "type": "float"
    }
  ]
}

Example Request Body (Int)

{
  "name": "test.timer",
  "arguments": [
    {
      "name": "seconds",
      "type": "int"
    }
  ]
}

Example Request Body (String)

{
  "name": "test.alert",
  "arguments": [
    {
      "name": "message",
      "type": "string"
    }
  ]
}

Example Request Body (Enum)

{
  "name": "test.power.switch",
  "arguments": [
    {
      "name": "state",
      "type": "enum",
      "values": [
        {
          "string": "OFF",
          "value": 0
        },
        {
          "string": "ON",
          "value": 1
        }
    ]
    }
  ]
}

Example Request Body (File)

{
  "name": "test.config.file",
  "arguments": [
    {
      "name": "config.file",
      "type": "file"
    }
  ]
}

Response Body

{
  "id": integer,
  "name": string,
  "dictionary_id": integer,
  "description": string (optional),
  "arguments": array (optional),
  "created_at": string, timestamp in ISO-8601 format
}

List all available commands

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/commands',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/commands \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/commands

Response Body (List of Command Objects)

[{
  "id": integer,
  "name": string,
  "dictionary_id": integer,
  "description": string (optional)
  "arguments": array (optional)
  "created_at": string, timestamp in ISO-8601 format
}]

Retrieve a command by name

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/commands',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    params={
      "name": "test.command",
      "dictionary-id": 1
    }
)

curl -X GET \
  "https://api.epsilon3.io/v1/commands/query?name=test.command&dictionary-id=1" \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/commands/query?name={name}&dictionary-id={dictionary-id}

The URL parameter name is required and must be URL encoded. An optional dictionary-id may be provided to choose a specific dictionary. If dictionary-id is not included, the default dictionary will be used.

Delete commands

Sample Request

import requests
import os

requests.delete(
    url='https://api.epsilon3.io/v1/commands',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
      "ids": [1, 2, 3]
    }
)

curl -X DELETE \
  https://api.epsilon3.io/v1/commands \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
    "ids": [1, 2, 3]
  }'

HTTP Request

DELETE https://api.epsilon3.io/v1/commands/

Request Body

{
  "ids": array (integer),
}

Example Request Body

{
  "ids": [123, 456]
}

Dictionary API

Dictionaries are used to organize your commands, telemetry parameters, and external data types. Epsilon3’s dictionary API supports creating, updating, retrieving, or deleting dictionary definitions. Creating a dictionary with the API allows the user to link commands, telemetry, and external data to that dictionary which enables the following in Epsilon3:

Create a dictionary

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/dictionaries',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
             "name": "Vehicle-1"
         }
    )

curl -X POST \
  https://api.epsilon3.io/v1/dictionaries \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
          "name": "Vehicle-1"
      }'

HTTP Request

Request Body (Dictionary Object)

{
  "name": string
}

POST https://api.epsilon3.io/v1/dictionaries

The request body should contain a Dictionary object. The field name is required. The name field should be unique.

Response Body

{
  "id": integer,
}

List all available dictionaries

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/dictionaries',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/dictionaries \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/dictionaries

Response Body

[{
  "id": integer,
  "name": string,
  "created_at": string, timestamp in ISO-8601 format
}]

Delete dictionaries

Sample Request

import requests
import os

requests.delete(
    url='https://api.epsilon3.io/v1/dictionaries',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
      "ids": [1, 2, 3]
    }
)

curl -X DELETE \
  https://api.epsilon3.io/v1/dictionaries \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
    "ids": [1, 2, 3]
  }'

HTTP Request

DELETE https://api.epsilon3.io/v1/dictionaries

Request Body

{
  "ids": array (integer),
}

Example Request Body

{
  "ids": [2, 3, 10]
}

`

Events API

Events are used in schedules to plan operations and milestones. Epsilon3's events API currently supports the following capabilities.

Get Events

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/planning/events',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    params={
      "start": "2023-07-26T00:00:00.000Z",
      "end": "2023-08-09T00:00:00.000Z",
      "eventType": "unscheduled",
      "exclude_recurrences": True,
    }
)

curl -X GET \
  "https://api.epsilon3.io/v1/planning/events?start=2023-07-26T00:00:00.000Z&end=2023-08-09T00:00:00.000Z&eventType=unscheduled&exclude_recurrences=true" \
  -u "$EPSILON3_API_KEY":

GET /api/v1/planning/events

Retrieves events under

Query Parameters

Request URL

GET /api/v1/planning/events?start=2023-07-26T00:00:00.000Z&end=2023-08-09T00:00:00.000Z

Response Body

{
  "events": [
    {
      "id": "DVEYVZ2qp8sk2KgvA6zOkn",
      "name": "Galactic Innovators Summit",
      "start": "2023-08-30T13:00:00.000Z",
      "end": "2023-08-30T18:00:00.000Z",
      "procedure_id": null,
      "procedure_section_id": null,
      "run_id": null,
      "swimlane_id": null,
      "description": null,
      "duration": "PT5H"
    },
    {
      "id": "DphgSy369ewI3QbzIzhjz6",
      "name": "Space Exploration Workshop",
      "start": "2023-08-30T10:30:00.000Z",
      "end": "2023-08-30T12:30:00.000Z",
      "procedure_id": null,
      "procedure_section_id": null,
      "run_id": null,
      "swimlane_id": null,
      "description": null,
      "duration": "PT2H"
    }
  ]
}

Get Event

GET /api/v1/planning/events/:eventId

Retrieves a specific event.

Parameters

Request URL

GET /api/v1/planning/events/test_event_id

Response Body

{
  "id": "QuACGmyZHp7qMMOUM64SRg",
  "name": "Space Colony Simulation Test",
  "description": "Test Description",
  "start": "2023-07-30T09:00:00.000Z",
  "end": "2023-07-30T17:00:00.000Z",
  "duration": "PT8H",
  "procedure_id": "45KqIG4QZV1S5oOYZaxE9y",
  "procedure_section_id": null,
  "run_id": null,
  "swimlane_id": "DpSTO81RP9fZSUd8d8ffY4",
  "rrule": "RRULE:FREQ=DAILY;INTERVAL=3",
  "recurrence_id": "ChEIi3cXJVXCidYlVgMqTl",
  "recurrence_date": null,
  "notes": "Here are some notes with:\n- **Markdown components**",
  "dependencies": {
    "in": [
      {
        "id": "DhawCJ3URB7sNd8rRZ8r3H",
        "source": "1RXszDst3d16WeXn1GiNLB"
      }
    ],
    "out": [
      {
        "id": "jX88nSfgTK22KL7DZyUJjc",
        "target": "3rfiluxsbzKwGbJOW8VIAZ"
      }
    ]
  },
  "status": null,
  "predecessor_id": null
}

If the event doesn't exist, it will respond with a 404 status code.

Update Event

PATCH /api/v1/planning/events/:eventId

Updates a specific event.

Parameters

Request Body

The request body should be a JSON object that contains the details of the event to be updated. The following fields are supported:

Response The response status code will be 200 and return a copy of the updated event.

Request URL

PATCH /api/v1/planning/events/test_event_id

Example Request Body

{
  "id": "3rfiluxsbzKwGbJOW8VIAZ",
  "name": "Test Event",
  "description": "Test Description",
  "start": "2023-07-26T17:00:00Z",
  "duration": "PT6H4S",
  "dependencies": {
    "in": [
      {
        "source": "QuACGmyZHp7qMMOUM64SRg",
        "target": "3rfiluxsbzKwGbJOW8VIAZ"
      }
    ],
    "out": []
  }
}

Create Event

POST /api/v1/planning/events

Request URL

POST /api/v1/events

Example Request Body

{
  "name": "Test Event",
  "description": "Description goes here",
  "start": "2023-08-08T00:00:00.000Z",
  "duration": "PT6H4S",
  "procedure_id": "45KqIG4QZV1S5oOYZaxE9y",
  "procedure_section_id": null,
  "dependencies": { "in": [{ "source": "6NSi9FIBDN1xrWEV4Q8HQR" }], "out": [] },
  "swimlane_id": "DpSTO81RP9fZSUd8d8ffY4",
  "rrule": "RRULE:FREQ=DAILY;INTERVAL=1",
  "notes": "Here are some notes with **markdown**"
}

Creates a new event.

Parameters

No path parameters are required for this endpoint.

Request Body

The request body should be a JSON object that contains the details of the event to be created. The following fields are supported:

Response

The response status code will be 201 and return a JSON object containing the ID of the newly created event.

Delete Event

DELETE /api/v1/planning/events/:eventId

Request URL

DELETE /api/v1/planning/events/test_event_id

Deletes an event.

Parameters

Response

The response status code will be 204 for a successful response.

External Data API

Epsilon3’s external data API supports the following capabilities:

Create or update an external data item type

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/external-data',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
             "type": "x-axis",
             "label": "X Axis",
             "dictionary_id": 1
         }
    )

curl -X POST \
  https://api.epsilon3.io/v1/external-data \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
          "type": "x-axis",
          "label": "X Axis",
          "dictionary_id": 1
      }'

Request Body

{
  "type": string,
  "label": string,
  "dictionary_id": integer (optional)
}

HTTP Request

POST https://api.epsilon3.io/v1/external-data

The request body should contain an External Data Item object with the following required fields: type & label. The optional dictionary_id field allows the External Data Item to be related to a dictionary. If no dictionary_id is provided, the external data item will be related to the default dictionary.

List all external data items

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/external-data',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/external-data \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/external-data

Example Response

[
  {
    "type": "work_order",
    "label": "Work Order",
    "dictionary_id": 1
  },
  {
    "type": "part_number",
    "label": "Part Number",
    "dictionary_id": 1
  },
  {
    "type": "support_ticket",
    "label": "Support Ticket",
    "dictionary_id": 1
  }
]

Delete external data

Sample Request

import requests
import os

requests.delete(
    url='https://api.epsilon3.io/v1/external-data',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
      "ids": [1, 2, 3]
    }
)

curl -X DELETE \
  https://api.epsilon3.io/v1/external-data \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
    "ids": [1, 2, 3]
  }'

HTTP Request

DELETE https://api.epsilon3.io/v1/external-data

Request Body

{
  "ids": array (integer),
}

Example Request Body

{
  "ids": [123, 456]
}

Procedures API

Audit procedures with invalid data

This endpoint audits procedures and returns the location of invalid telemetry, commanding or external data blocks.

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/auditInvalid',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/auditInvalid \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/procedures/auditInvalid

Response Body

{ "procedures": [
  {
    "id": string,
    "name": string,
    "invalid_blocks": {
      "section_content": [
        {
          "section_id": string,
          "section_name": string,
          "step_id": string,
          "step_name": string,
          "content_type": string, ( input | telemetry | commanding | external_item )
          "content_name": string,
          "content_id": string,
          "reason": string, ( e.g. "Invalid external data" )
        }
      ],
      "procedure_variables": [
        {
          "variable_id": string,
          "variable_name": string,
          "external_search_data_type": string,
          "reason": string, ( e.g. "Invalid commanding" )
        }
      ]
    }
  }
]}

List procedure summaries

Retrieves a summarized view of all available procedures.

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/procedures/summary',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/procedures/summary \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/procedures/summary

Response Body

{ "data": [
  {
    "_id": string;
    "_rev": string;
    "name": string;
    "procedure_id": (optional) string;
    "state": "draft" | "in_review" | "released");
    "code": string;
    "version": string;
    "project_id": (optional) string;
    "project_name": (optional) string;
    "project_code": (optional) string;
    "archived": boolean;
    "editedAt": string;
    "reviewer_groups": (optional) Array<ReviewerGroup>;
    "tags": (optional) Array<Tag>;
  }
]}

Retrieve a procedure

Retrieves all available information for an individual procedure by ID.

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/procedures/sampleProcedureId',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/procedures/sampleProcedureId \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/procedures/:procedure-id

Response Body

  {
    "_id": string;
    "_rev": (optional) string;
    "procedure_id": (optional) string;
    "project_id": (optional) string;
    "project_name": (optional) string;
    "project_code": (optional) string;
    "code": string;
    "name": string;
    "variables": (optional) Array<DraftVariable>;
    "headers": (optional) Array<DraftHeader>;
    "version": (optional) string;
    "description": string;
    "archived": boolean;
    "state": (optional) "draft" | "in_review";
    "sections": Array<DraftSection>;
    "reviewer_groups": (optional) Array<ReviewerGroup>;
    "reviewer_actions_history": (optional) Array<ReviewerAction>;
    "locked_by": (optional) string;
    "locked_at": (optional) string;
    "redline_actions": (optional) Array<RedlineAction>;
    "editedAt": (optional) string;
    "editedUserId": (optional) string;
    "owner": (optional) string;
    "procedure_rev_num": (optional) number;
    "release_note": (optional) ReleaseNote;
    "comments": (optional) Array<ReviewComment>;
    "approvals": (optional) Array<Approval>;
    "tags": (optional) Array<Tag>;
    "settings": (optional) Settings;
    "reviewers": (optional) Array<Reviewer>;
    "end_run_signoffs_groups": (optional) Array<{
          id: string;
          operators: Array<string>;
        }>;
    "default_view_mode": (optional) string;
    "dictionary_id": (optional) number;
    "is_strict_signoff_enabled": (optional) boolean;
  }

Complimentary schemas

ReviewerGroup

{
  "id": string;
  "reviewers": Array<Reviewer>;
  "actions": Array<ReviewerAction>;
};

Reviewer

{
  "id": string;
  "reviewer_ids": Array<ReviewerId>;
  "is_required": (optional) true;
}

ReviewerId

{
  type: string;
  value: string;
};

ReviewerAction

{
  "type": string;
  "reviewer_id": string;
  "user_id": string;
  "approved_at": string;
}

Tag

{
  "key": string;
  "name": string;
}

DraftVariable

{
  "id": string;
  "name": string;
  "type": 'input',
  "rule": (optional) Rule;
  "units": (optional) string;
  "input_type": (optional) 'text' | 'number' | 'checkbox';
  "inputType": (optional) 'text' | 'number' | 'checkbox' | 'timestamp' | 'attachment' | 'list' | 'select' | 'external_item' | 'external_search' | 'multiple_choice';
  "redlines": (optional) Array<BlockRedline>;
  "version": (optional) 2;
  "dateTimeType": (optional) 'date' | 'time' | 'datetime';
  "include_in_summary": (optional) boolean;
  "list": (optional) string;
  "options": (optional) Array<string>;
  "external_item_type": (optional) string;
  "dictionary_id": (optional) number;
  "external_search_type": (optional) {
    "data_type_dictionary_id": (optional) number;
    "data_type": string;
    "filter_options": Array<string>;
  };
}

BlockRedline

DraftVariable | {
  "id": string;
  "type": 'alert' | 'text';
  "subtype": (optional) 'note' | 'caution' | 'warning';
  "text": (optional) string;
}

DraftHeader

{
  "id": string;
  "name": string;
  "content": Array<DraftHeaderBlock>;
  "header_field_redlines": (optional) {
    [field: string]: Array<DraftFieldRedline>;
  };
  "redlines": (optional) Array<DraftHeaderBlock | DraftFieldRedline>;
};

DraftHeaderBlock

{
  "id": string;
  "type": "alert" | "attachment" | "text";
  "subtype": (optional) "note" | "caution" | "warning";
  "text": string;
  "redlines": (optional) Array<BlockRedline>;
}

DraftFieldRedline

{
  redline_id: (optional) string;
  created_at: (optional) string;
  user_id: (optional) string;
  redlineIndex: number;
  name: string;
  redlineId: (optional) string;
  createdAt: (optional) string;
  userId: (optional) string;
}

RedlineAction

{
  "redline_id": string;
  "state": 'accepted' | 'rejected' | 'resolved';
  "resolved_at": string;
  "resolved_by": string;
  "resolution_procedure_rev_num": (optional) number;
  "release_procedure_rev_num": (optional) number;
}

DraftSection

{
  "id": string;
  "name": string;
  "headers": (optional) Array<DraftHeader>;
  "steps": Array<DraftStep | DraftAddedStep>;
  "snippet_id": (optional) string;
  "snippet_name": (optional) string;
  "snippet_rev": (optional) number;
  "snippet_ids_map": (optional) Object<string, string>;
  "shows_snippet_detached_message": (optional) boolean;
}

DraftStep

{
  "id": string;
  "name": string;
  "type": (optional) string;
  "headers": (optional) Array<DraftHeader>;
  "timing": (optional) string;
  "duration": (optional) string;
  "location": (optional) string;
  "channel": (optional) string;
  "content": Array<DraftStepBlock>;
  "signoffs": Array<Signoff>;
  "dependencies": (optional) Array<StepDependency>;
  "conditionals": (optional) Array<Conditional>;
  "actions": (optional) Array<StepAction>;
  "step_field_redlines": (optional) {
    [field: string]: Array<DraftFieldRedline>;
  };
  "shows_snippet_detached_message": (optional) boolean;
  "snippet_id": (optional) string;
  "snippet_name": (optional) string;
  "snippet_rev": (optional) number;
  "snippet_ids_map": (optional) Object<string, string>;
  "redline_id": (optional) string;
  "precedingStepId": (optional) string;
  "requires_previous": (optional) boolean;
  "created_during_run": true;
  "created_at": string;
  "created_by": string;
}

StepDependency

{
  "id": string;
  "dependent_ids": Array<string>;
}

Conditional

{
  "id": string;
  "source_type": 'step' | 'content';
  "state": 'completed' | 'failed';
  "content_id": null;
  "source_id": string;
  "target_id": string;
  "target_type": 'step';
}

StepAction

{
  "type": 'signoff';
  "user_id": string;
  "timestamp": string;
  "conditional_value": (optional) string;
  "signoff_id": string;
  "operator": string;
}

ReleaseNote

{
  "user_id": string;
  "timestamp": string;
  "text": string;
}

ReviewComment

{
  "id": string;
  "reference_id": string;
  "redline_id": (optional) string;
  "text": string;
  "user_id": string;
  "created_at": string;
  "type": (optional) 'redline_comment';
  "source_run_id": (optional) string;
  "resolved": (optional) boolean;
  "resolved_by": (optional) string;
  "resolved_at": (optional) string;
  "resolution_procedure_rev_num": (optional) number;
}

Approval

{
  "user_id": string;
  "approved_at": string;
}

Settings

{
  "print_settings": (options) {
      "header": (options) PrintContent;
      "footer": (options) PrintContent;
    };
}

PrintContent

{
  "text": (optional) string;
  "variable_id": (optional) string;
}

Runs API

Epsilon3’s API supports starting a running procedure.

Start a running procedure

This endpoint creates new procedure runs.

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/runs',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
          "procedure_id": "up9goX1AgzCuffxUXbpI1K",
          "procedure_variables": {
            "manufacturer": "tesla",
            "VIN": 12345,
            "four-wheel drive?": false,
          }
        }
    )

curl -X POST \
  https://api.epsilon3.io/v1/runs \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
       "procedure_id": "up9goX1AgzCuffxUXbpI1K",
       "procedure_variables": {
         "manufacturer": "tesla",
         "VIN": 12345,
         "four-wheel drive?": false,
       }
      }'

HTTP Request

Request Body

{
  "procedure_id": string,
  "procedure_variables": {
    "variable name": string | number | boolean
  }
}

POST https://api.epsilon3.io/v1/runs

Example Response Body

{
  "run_id": "GMFvqA1qLgrw0xIEc95M2o"
}

The request body must contain the id of the procedure to start, and can optionally be used to pre-populate procedure variables.

Request value types correspond to the type of the procedure variable:

Procedure Variable Type Request Value Type
Text string
Number number; or, a string parsable to a number
Checkbox boolean
List & Custom List string
Multiple Choice string
Timestamp string, timestamp in ISO-8601 format*

*For time-only timestamp variables (with no date component required), the format may be HH:mm or HH:mm:ss. The date portion will default to the start of the epoch - January 1, 1970 UTC

Unsupported variable types: Attachment, Sketch, External Data, External Search

The run can be viewed at https://app.epsilon3.io/runs/<run_id>.

Pause or resume a running procedure

This endpoint allows you to pause or resume a procedure with an optional comment.

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/runs/up9goX1AgzCuffxUXbpI1K/pause',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={ "comment": "Safety check pause" }
    )

curl -X POST \
  https://api.epsilon3.io/v1/runs/up9goX1AgzCuffxUXbpI1K/pause \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{ "comment": "Safety check pause" }'

HTTP Request

Request Body

{ "comment": string (optional) }

POST https://api.epsilon3.io/v1/runs/:runId/pause OR POST https://api.epsilon3.io/v1/runs/:runId/resume

The runId parameter in the URL must contain the id of the running procedure to pause/resume.

Retrieve list of running procedure summaries

This endpoint allows you to retrieve a list of summarized running procedures with an optional filter for run state.

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/runs/summary',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    params={
      "run-state": ["paused", "completed"],
    }
)

curl -X GET \
  "https://api.epsilon3.io/v1/runs/summary?run-state=paused&run-state=completed" \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/runs/summary

Query parameter Value
run-state running \

Query parameter example usage GET https://api.epsilon3.io/v1/runs/summary?run-state=paused

Query parameter using multiple values GET https://api.epsilon3.io/v1/runs/summary?run-state=paused&run-state=completed

Example Response Body

{
  "_id": string,
  "code": string,
  "completedAt": string, timestamp in ISO-8601 format,
  "name": string,
  "operation": string,
  "project_id": string,
  "run_tags": [
    {key: string, name: string},
    ...
  ],
  "run_section": (optional) string,
  "source_run": (optional) string,
  "starttime": string, timestamp in ISO-8601 format,
  "state": "running" | "completed" | "paused",
  "status": "success" | "failure" | "abort",
  "skipped_steps": integer,
  "completed_steps": integer,
  "failed_steps": integer,
  "total_steps": integer,
  "not_required_steps": integer,
  "participant_user_ids": array(string),
}

End a running procedure

This endpoint allows you to end a procedure with an optional comment or status. When a running procedure is ended via this endpoint, any telemetry data that has not been recorded will be stored.

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/runs/up9goX1AgzCuffxUXbpI1K/end',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
          "comment": "Everything looks OK.",
          "status": "success"
        }
    )

curl -X POST \
  https://api.epsilon3.io/v1/runs/up9goX1AgzCuffxUXbpI1K/end \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
       "comment": "Everything looks OK.",
       "status": "success"
     }'

HTTP Request

Request Body

{
  "comment": string (optional),
  "status": string (optional)
}

Allowed status values are: - success - failure - abort

POST https://api.epsilon3.io/v1/runs/:runId/end

The runId parameter in the URL must contain the id of the running procedure to end.

Swimlanes API

Swimlanes are used in schedules to group events in the Gantt chart. Epsilon3's swimlanes API currently supports the following capabilities.

Get Swimlanes

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/swimlanes',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/swimlanes \
  -u "$EPSILON3_API_KEY":

GET /api/v1/swimlanes

Retrieves all swimlane

Response Body

{
  "swimlanes": [
    {
      "id": "DpSTO81RP9fZSUd8d8ffY4",
      "name": "Swimlane Exo"
    },
    {
      "id": "9ozH0ZOXLLBRZg4K0v1CXf",
      "name": "New"
    },
    {
      "id": "A2T07M4MkQeiJQqW7xOH6w",
      "name": "API Swimlane"
    },
    {
      "id": "F1HKrIQ8gY6UIHRj1qhclC",
      "name": "Launch"
    },
    {
      "id": "zAt5hyS3FEmvy4THcTIIVh",
      "name": "QA Check"
    }
  ]
}

Update Swimlane

PATCH /api/v1/swimlanes/:swimlane_id

Updates a specific swimlane.

Request URL

PATCH /api/v1/swimlane/test_swimlane_id

Example Request Body

{
  "name": "Patched Swimlane"
}

Parameters

Request Body

The request body should be a JSON object that contains the details of the swimlane to be updated. The following fields are supported:

Response The response status code will be 204 for a succcessful message

Create Swimlane

POST /api/v1/swimlanes

Request URL

POST /api/v1/swimlanes

Example Request Body

{
  "name": "New Swimlane"
}

Creates a new swimlane.

Parameters

No path parameters are required for this endpoint.

Request Body

The request body should be a JSON object that contains the details of the swimlane to be created. The following fields are supported:

Response

The response status code will be 201 and return a JSON object containing the ID of the newly created swimlane.

Delete Swimlane

DELETE /api/v1/swimlanes/:swimlane_id

Request URL

DELETE /api/v1/swimlanes/test_swimlane_id

Deletes an swimlane.

Parameters

Response

The response status code will be 204 for a successful response.

Telemetry API

Epsilon3’s telemetry API supports creating, updating, retrieving, or deleting telemetry parameters. Uploading telemetry parameters to the API allows the user to do the following in Epsilon3:

Create or update a telemetry parameter

Sample Request

import requests
import os

requests.post(
    url='https://api.epsilon3.io/v1/telemetry/parameters',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    json={
          "name": "test.simulation.error",
          "type": "enum",
          "dictionary_id": 1,
          "description": "Payload error flag",
          "refresh_rate_ms": 10000,
          "values": { "0": "FAIL", "1": "SUCCESS" }
        }
    )

curl -X POST \
  https://api.epsilon3.io/v1/telemetry/parameters \
  -H 'Content-Type: application/json' \
  -u "$EPSILON3_API_KEY": \
  -d '{
      "name": "test.simulation.error",
      "type": "enum",
      "dictionary_id": 1,
      "description": "Payload error flag",
      "refresh_rate_ms": 10000,
      "values": { "0": "FAIL", "1": "SUCCESS" }
    }'

HTTP Request

Request Body (Parameter Object)

{
  "name": string,
  "type": string,
  "dictionary_id": integer (optional),
  "description": string (optional),
  "units": string (optional),
  "refresh_rate_ms": integer (optional),
  "values": object (optional - required for enum and aggregate types)
}

POST https://api.epsilon3.io/v1/telemetry/parameters

The request body should contain a Parameter object. The fields name and type are required. The name field should be unique per dictionary. The optional dictionary_id field allows the parameter to be related to a dictionary. If no dictionary_id is provided, the parameter will be related to the default dictionary. The parameter refresh_rate_ms is a positive integer denoting the number of milliseconds the UI will wait before refreshing the value, defaults to 1000 (1 second) if not provided. The values parameter is required for enum and aggregate type parameters. For enum types, values represents a mapping of integer keys to string labels - each integer key corresponds to a unique string label. For aggregate types, values represents an array of parameter objects - each object has a required name and type field (a values field is required if type is enum)

Response Body

{
  "id": string,
  "name": string,
  "type": string,
  "dictionary_id": integer,
  "created_at": string, timestamp in ISO-8601 format
}

Example Enum Request

{
  "name": "test.simulation.enum",
  "type": "enum",
  "dictionary_id": 5,
  "description": "Enum represnting state of simulation",
  "refresh_rate_ms": 1000,
  "values": { "0": "FAIL", "1": "SUCCESS" }
}

Example Aggregate Request

{
  "name": "test.simulation.aggregate",
  "type": "aggregate",
  "dictionary_id": 5,
  "description": "Aggregate type represnting state of simulation",
  "refresh_rate_ms": 1000,
  "values": [{"name": "test_val", "type": "float"}, {"name": "test_enum", "type": "enum", "values":{ "0": "FAIL", "1": "SUCCESS" }}]
}

Supported types:

List all available telemetry parameters

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/telemetry/parameters',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/telemetry/parameters \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/telemetry/parameters

Response Body (List of Parameter Objects)

[{
  "id": string,
  "name": string,
  "type": string,
  "dictionary_id": integer,
  "created_at": string, timestamp in ISO-8601 format,
  "refresh_rate_ms": number,
  "values": object (Represents a mapping of integer keys to string labels)
}]

Retrieve a telemetry parameter by name

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/telemetry/parameters',
    auth=(os.environ.get('EPSILON3_API_KEY'), ''),
    params={
      "name": "test.simulation.error",
      "dictionary_id": 1
    }
)

curl -X GET \
  "https://api.epsilon3.io/v1/telemetry/parameters/query?name=test.simulation.error&dictionary_id=1" \
  -u "$EPSILON3_API_KEY":

HTTP Request

GET https://api.epsilon3.io/v1/telemetry/parameters/query?name={name}&dictionary_id={dictionary_id}

The URL parameter name is required and must be URL encoded. An optional dictionary_id may be provided to choose a specific dictionary. If dictionary_id is not included, the default dictionary will be used.

Delete parameters

HTTP Request

DELETE https://api.epsilon3.io/v1/telemetry/parameters

Request Body

{
  "ids": array (integer),
}

Example Request Body

{
  "ids": [123, 456]
}

Test Management API

Conditions

List Conditions

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/testing/conditions',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/testing/conditions \
  -u "$EPSILON3_API_KEY":

GET https://api.epsilon3.io/v1/testing/conditions

Retrieve all conditions defined in your workspace.

Example Response Body

{
  "data": [
    {
      "id": "089dab71-f13a-43b1-a350-481c873129f1",
      "name": "Speed",
      "units": [
          "MPH",
          "KPH"
      ]
    },
    ...
  ]
}

Get Condition

GET https://api.epsilon3.io/v1/testing/conditions/:id

Retrieve a single condtion using its ID.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/conditions/089dab71-f13a-43b1-a350-481c873129f1

Example Response Body

{
    "id": "089dab71-f13a-43b1-a350-481c873129f1",
    "name": "Speed",
    "units": [
        "MPH",
        "KPH"
    ]
}

Risks

List Risks

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/testing/risks',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/testing/risks \
  -u "$EPSILON3_API_KEY":

GET https://api.epsilon3.io/v1/testing/risks

Retrieve all risks defined in your workspace.

Example Response Body

{
  "data": [
    {
      "id": "f2161547-615e-4959-a989-91f3627d20d1",
      "name": "Altitude Loss",
      "cause": "Stall",
      "notes": "Work in progress",
      "effect": "Inadequate altitude for recovery",
      "category": "Mechanical",
      "severity": 0,
      "probability": 1,
      "mitigation": "Experienced Test Pilot: Ensure a highly skilled test pilot with experience in stall recovery is at the controls. Safety Equipment: Ensure the aircraft is equipped with safety features, such as a stall warning system, to aid in stall recovery.",
      "updated_at": "2024-01-24T21:00:39.421Z",
    },
    ...
  ]
}

Get Risk

GET https://api.epsilon3.io/v1/testing/risks/:id

Retrieve a single risk using its ID.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/risks/f2161547-615e-4959-a989-91f3627d20d1

Example Response Body

{
  "id": "f2161547-615e-4959-a989-91f3627d20d1",
  "name": "Altitude Loss",
  "cause": "Stall",
  "notes": "Work in progress",
  "effect": "Inadequate altitude for recovery",
  "category": "Mechanical",
  "severity": 0,
  "probability": 1,
  "mitigation": "Experienced Test Pilot: Ensure a highly skilled test pilot with experience in stall recovery is at the controls. Safety Equipment: Ensure the aircraft is equipped with safety features, such as a stall warning system, to aid in stall recovery.",
  "updated_at": "2024-01-24T21:00:39.421Z",
}

List Risk Versions

GET https://api.epsilon3.io/v1/testing/risks/:id/versions

Retrieve all the versions for a risk.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/risks/f2161547-615e-4959-a989-91f3627d20d1/versions

Example Response Body

{
  "data": [
    {
      "id": 123,
      "timestamp": "2024-01-24T21:00:39.421Z",
      "record":
        {
          "id": "f2161547-615e-4959-a989-91f3627d20d1",
          "name": "Altitude Loss",
          "cause": "Stall",
          "notes": "Work in progress",
          "effect": "Inadequate altitude for recovery",
          "category": "Mechanical",
          "severity": 0,
          "probability": 1,
          "mitigation": "Experienced Test Pilot: Ensure a highly skilled test pilot with experience in stall recovery is at the controls. Safety Equipment: Ensure the aircraft is equipped with safety features, such as a stall warning system, to aid in stall recovery.",
          "updated_at": "2024-01-24T21:00:39.421Z",
        }
    },
    ...
  ]
}

Get Risk Version

GET https://api.epsilon3.io/v1/testing/risks/:id/versions/:versionId

Retrieve a single version for a risk.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/risks/f2161547-615e-4959-a989-91f3627d20d1/versions/123

Example Response Body

{
  "id": 123,
  "timestamp": "2024-01-24T21:00:39.421Z",
  "record":
    {
      "id": "f2161547-615e-4959-a989-91f3627d20d1",
      "name": "Altitude Loss",
      "cause": "Stall",
      "notes": "Work in progress",
      "effect": "Inadequate altitude for recovery",
      "category": "Mechanical",
      "severity": 0,
      "probability": 1,
      "mitigation": "Experienced Test Pilot: Ensure a highly skilled test pilot with experience in stall recovery is at the controls. Safety Equipment: Ensure the aircraft is equipped with safety features, such as a stall warning system, to aid in stall recovery.",
      "updated_at": "2024-01-24T21:00:39.421Z",
    }
}

Test Cases

List Test Cases

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/testing/cases',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/testing/cases \
  -u "$EPSILON3_API_KEY":

GET https://api.epsilon3.io/v1/testing/cases

Retrieve all test cases defined in your workspace.

Example Response Body

{
  "data": [
    {
      "id": "f2161547-615e-4959-a989-91f3627d20d1",
      "name": "Cruise",
      "test_case_conditions": [
          {
              "name": "Speed",
              "units": "MPH",
              "value": "22",
              "condition_id": "089dab71-f13a-43b1-a350-481c873129f1"
          }
      ],
    },
    ...
  ]
}

Get Test Case

GET https://api.epsilon3.io/v1/testing/cases/:id

Retrieve a single test case using its ID.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/cases/f2161547-615e-4959-a989-91f3627d20d1

Example Response Body

{
  "id": "f2161547-615e-4959-a989-91f3627d20d1",
  "name": "Cruise",
  "test_case_conditions": [
      {
          "name": "Speed",
          "units": "MPH",
          "value": "22",
          "condition_id": "089dab71-f13a-43b1-a350-481c873129f1"
      }
  ],
  "risks": [], // list of associated risks
  "requirements": [], // list of associated requirements
  "runs": [], // list of associated runs
}

List Test Case Versions

GET https://api.epsilon3.io/v1/testing/cases/:id/versions

Retrieve all the versions for a test case.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/cases/f2161547-615e-4959-a989-91f3627d20d1/versions

Example Response Body

{
  "data": [
    {
      "id": 123,
      "timestamp": "2024-01-24T21:00:39.421Z",
      "record":
        {
          "id": "f2161547-615e-4959-a989-91f3627d20d1",
          "name": "Cruise",
          "test_case_conditions": [
            {
              "name": "Speed",
              "units": "MPH",
              "value": "22",
              "condition_id": "089dab71-f13a-43b1-a350-481c873129f1"
            }
          ],
        }
    },
    ...
  ]
}

Get Test Case Version

GET https://api.epsilon3.io/v1/testing/cases/:id/versions/:versionId

Retrieve a single version for a test case.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/cases/f2161547-615e-4959-a989-91f3627d20d1/versions/123

Example Response Body

{
  "id": 123,
  "timestamp": "2024-01-24T21:00:39.421Z",
  "record":
    {
      "id": "f2161547-615e-4959-a989-91f3627d20d1",
      "name": "Cruise",
      "test_case_conditions": [
        {
          "name": "Speed",
          "units": "MPH",
          "value": "22",
          "condition_id": "089dab71-f13a-43b1-a350-481c873129f1"
        }
      ],
    }
}

Requirements

List Requirements

Sample Request

import requests
import os

requests.get(
    url='https://api.epsilon3.io/v1/testing/requirements',
    auth=(os.environ.get('EPSILON3_API_KEY'), '')
)

curl -X GET \
  https://api.epsilon3.io/v1/testing/requirements \
  -u "$EPSILON3_API_KEY":

GET https://api.epsilon3.io/v1/testing/requirements

Retrieve all requirements defined in your workspace.

Example Response Body

{
  "data": [
    {
        "id": "6be45049-ed63-4d53-b839-a0a719f94be9",
        "custom_id": "A-100",
        "position": 1,
        "text": "The aircraft should be a commercial passenger airplane designed for carrying passengers and cargo.",
        "priority": {
            "id": 1,
            "name": "High",
            "color": "red-200"
        },
        "type": "secondary",
        "notes": "This is not a military aircraft."
    },
    ...
  ]
}

Get Requirement

GET https://api.epsilon3.io/v1/testing/requirements/:id

Retrieve a single requirement using its ID.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/requirements/6be45049-ed63-4d53-b839-a0a719f94be9

Example Response Body

{
  "id": "6be45049-ed63-4d53-b839-a0a719f94be9",
  "custom_id": "A-100",
  "position": 1,
  "text": "The aircraft should be a commercial passenger airplane designed for carrying passengers and cargo.",
  "priority": {
      "id": 1,
      "name": "High",
      "color": "red-200"
  },
  "type": "secondary",
  "notes": "This is not a military aircraft.",
  "cases": [], // list of associated test cases
  "source_links": [], // list of associated requirements this requirement is a source of
  "target_links": [], // list of associated requirements that target this requirement
  "attachments": [], // list of attachment metadata
}

List Requirement Versions

GET https://api.epsilon3.io/v1/testing/requirements/:id/versions

Retrieve all the versions for a requirement.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/requirements/6be45049-ed63-4d53-b839-a0a719f94be9/versions

Example Response Body

{
  "data": [
    {
      "id": 123,
      "timestamp": "2024-01-24T21:00:39.421Z",
      "record":
        {
          "id": "6be45049-ed63-4d53-b839-a0a719f94be9",
          "custom_id": "A-100",
          "position": 1,
          "text": "The aircraft should be a commercial passenger airplane designed for carrying passengers and cargo.",
          "priority": {
              "id": 1,
              "name": "High",
              "color": "red-200"
          },
          "type": "secondary",
          "notes": "This is not a military aircraft."
        }
    },
    ...
  ]
}

Get Requirement Version

GET https://api.epsilon3.io/v1/testing/requirements/:id/versions/:versionId

Retrieve a single version for a requirement.

Parameters

Example Request URL

GET https://api.epsilon3.io/v1/testing/requirements/6be45049-ed63-4d53-b839-a0a719f94be9/versions/123

Example Response Body

{
  "id": 123,
  "timestamp": "2024-01-24T21:00:39.421Z",
  "record":
    {
      "id": "6be45049-ed63-4d53-b839-a0a719f94be9",
      "custom_id": "A-100",
      "position": 1,
      "text": "The aircraft should be a commercial passenger airplane designed for carrying passengers and cargo.",
      "priority": {
          "id": 1,
          "name": "High",
          "color": "red-200"
      },
      "type": "secondary",
      "notes": "This is not a military aircraft."
    }
}
python shell

Realtime Introduction

Epsilon3, facilitates seamless real-time data exchange to integrate with any third party software platform through the use of the socketIO and webhook communication protocols.

The following modules are currently supported

Epsilon3 provides sample python clients that contain all the core logic needed to connect to Epsilon3 system so that only custom integration logic needs to be added.

Getting Started

Download Sample Client

Set Environment Variables

Add your API key as an environment variable

export EPSILON3_API_KEY=your_api_key

export EPSILON3_API_KEY=your_api_key

(Optional) If you are in the United Kingdom instance you will also need to set the correct URL

export EPSILON3_API_URL='https://api.uk.epsilon3.io'

export EPSILON3_API_URL='https://api.uk.epsilon3.io'

(Optional) If using the Webhook version you will also need to add your webhook key as an environment variable

export EPSILON3_WEBHOOK_KEY=your_webhook_key

export EPSILON3_WEBHOOK_KEY=your_webhook_key

Note: Webhook key registration necessary, contact Epsilon3 support for assistance.

Webhook signature verification

Epsilon3 provides a python module called webhook_auth for verifying that requests sent to your webhooks come from Epsilon3 and not a third party.

Perform signature verification by passing your webhook secret key, the request payload, and the Epsilon3-Signature header to the provided function verify_webhook_signature. This function will return True if the signature can be verified, and False otherwise.

For additional information regarding webhook signature verification or if you’d like to verify webhook signatures manually, please contact Epsilon3 for support.

Run the Application

In a terminal window navigate to the directory where the Realtime Client was downloaded, unzip it and then navigate into it. e.g.

cd client-python-socketio

cd client-python-socketio

Install project dependencies

pipenv install

pipenv install

Activate the project's python environment

pipenv shell

pipenv shell

Run the application

SocketIO version

python app.py

python app.py

Webhook version

flask aiorun

flask aiorun

Commanding

For information on creating commands to use within a procedure please see the Commanding API Section

Listen for a command in real-time

The SocketIO/Webhook clients provide different namespaces to use websockets more efficiently and provide separate communication channels. For real-time commanding, clients can listen for:

Namespace /v1/commands/realtime

Event name send_command

Once a SocketIO or Webhook client is running, they will receive real-time requests to execute commands triggered from running procedures.

Example Request

{
  "name": "test.pressure.level",
  "dictionary_id": 2,
  "arguments":
  {
    "psi": 7.8,
  },
  "operation": "To infinity and beyond!",
  "variables":
  {
    "test.variable1":
    {
      "name": "test.variable1",
      "input_type": "text",
      "value": "hello world",
    },
    "test.variable2":
    {
      "name": "test.variable2",
      "input_type": "number",
    },
  },
  "metadata":
  {
    "user": "test@epsilon3.io",
    "run_id": "QoxCWp4C6kSY5xWUmKj0ye",
    "run_starttime": "2022-12-25T22:34:53.623Z",
    "procedure_code": "Launch123",
    "procedure_name": "alpha",
    "procedure_version": "1.3a",
  }
}

Client Request

The request payload contains the following:

Example Response

{
  "name": "test.pressure.level",
  "success": true,
  "received_at": "2022-12-25T22:34:53.623Z", (ISO-8601 format)
  "message": "Pressure level tested" (optional)
}

Client Response

The optional message field can be used to return a string with additional information that will be shown on the UI.

External Data

For information on creating external data items to use within a procedure please see the External Data API Section

Listen for real-time requests for external data

The sample clients provide different namespaces to use websockets more efficiently and provide separate communication channels. For real-time external data, clients can listen for:

Namespace /v1/external-data/items

Event names search and item

Once a SocketIO or Webhook client is running, they will receive real-time requests triggered from procedures to retrieve external data.

Client Request

Example Request

{
  "type": "work_order",      // External Data Item type to query
  "term": "1234",             // Query search string
  "dictionary_id": 1,
  "metadata":
  {
    "user": "test@epsilon3.io",
    "run_id": "QoxCWp4C6kSY5xWUmKj0ye",
    "run_starttime": "2022-12-25T22:34:53.623Z",
    "procedure_code": "Launch123",
    "procedure_name": "alpha",
    "procedure_version": "1.3a",
  }
}

The request argument is an object containing the external data item type to query, the dictionaryId and a query search string.

Client Response

Example Response

"type": "places",
"success": true,
"message": "Items located.",
"items": [
  {
    "id": "unique id",
    "name": "Locations",
    "label": "Fun places",
    "url": "https://www.epsilon3.io",
    "valid": true,
    "details":[
      {
        "name": "City",
        "value": "Milwaukee"
      },
      {
        "name": "State",
        "value": "Wisconsin"
      },
    ]
  }
]

The client should return an object which contains

Notifications

The sample clients provide different namespaces to use websockets more efficiently and provide separate communication channels. For real-time notifications, clients can listen for:

Namespace /v1/notifications/realtime

Event name notification

Event subtypes

Once a socketIO or Webhook client is running, they will receive real-time requests triggered from procedures to send notifications.

Sending notifications

Notifications can be manually triggered in any running Epsilon3 procedure by clicking the notification button to the left of a step’s signoff buttons.

The returned object is a response object containing a single received property to indicate whether the notification was successfully processed by the client. A {'received': True} response is reflected in Epsilon3 by a success indicator. A {'received': False} response or a lack of response from any client is reflected in Epsilon3 by a failure indicator.

Success Indicator

Failure Indicator

Notification Objects

Notification event objects are received by a listener when a notification is emitted by the connected Epsilon3 workspace.

Notification Object

{
  "id": string,
  "type": string,
  "subtype": string,
  "timestamp": string, timestamp in ISO-8601 format,
  "api_version": float,
  "data": {
    "message": string,
    "run_url": string,
    "section_name": string,
    "step_name": string,
    "users_to_notify": array,
    "remaining_operator_roles": array,
    "notification_source": string
}

Example Notification Event Object

{
  "id": "event_URyUS086KeBSJQcCgA9ENNihHzvKMvWu",
  "type": "notification",
  "subtype": "remaining_step_operators",
  "timestamp": "2022-08-18T19:48:57.608Z",
  "api_version": 1,
  "data": {
    "message": "A step is waiting for your signoff.",
    "run_url": "https://app.epsilon3.io/runs/XmWQs0J3TfPDwQVJCAfJby",
    "section_name": "A",
    "step_name": "A1",
    "users_to_notify": [
      "user1@epsilon3.io",
      "user2@epsilon3.io"
    ],
    "remaining_operator_roles": ["OP1"],
    "notification_source": "user3@epsilon3.io"
  }
}

Telemetry

For information on creating telemetry parameters to use within a procedure please see the Telemetry API Section

Listen for real-time sample requests

The sample clients provide different namespaces to use websockets more efficiently and provide separate communication channels. For real-time telemetry, clients can listen for:

Namespace /v1/telemetry/realtime

Event name get_sample

Once a SocketIO or Webhook client is running, they will receive real-time requests triggered from procedures to retrieve telemetry parameters.

Send telemetry values to Epsilon3

Send telemetry values to Epsilon3 for use within procedures. As new requests are received, Epsilon3 will update any running procedures with the latest values in real time. Sending telemetry values to Epsilon3 will provide users these capabilities:

The Epsilon3 API uses Socket.IO to support real-time and bi-directional telemetry integrations with websockets. When applications connect to this API with a Socket.IO compatible client, they’ll receive real-time requests for telemetry samples. This allows for efficient polling of telemetry data as the API will only request samples for active running procedures. See Appendix 1 for a quick start guide that covers creating a Socket.IO client and connecting to the API using python-socketio.

Example Request

{
  "name": "test.simulation.error",
  "dictionary_id": 2,
  "operation": "To infinity and beyond!",
  "variables":
  {
    "test.variable1":
    {
      "name": "test.variable1",
      "input_type": "text",
      "value": "hello world"
    },
    "test.variable2":
    {
      "name": "test.variable2",
      "input_type": "number"
    }
  },
  "metadata":
  [
    {
      "user": "test@epsilon3.io",
      "run_id": "QoxCWp4C6kSY5xWUmKj0ye",
      "run_starttime": "2022-12-25T22:34:53.623Z",
      "procedure_code": "Launch123",
      "procedure_name": "alpha",
      "procedure_version": "1.3a"
    },
    {
      "user": "test2@epsilon3.io",
      "run_id": "w5ssf4QGzfYK7znXO6P4gZ",
      "run_starttime": "2022-12-25T23:12:4.123Z",
      "procedure_code": "Launch456",
      "procedure_name": "beta",
      "procedure_version": "1.0"
    }
  ]
}

Socket.IO provides different namespaces to use websockets more efficiently and provide separate communication channels. For real-time telemetry data, clients can listen for the event get_sample within the namespace /v1/telemetry/realtime. The request payload contains the following:

The returned object is a Sample object matching the indicated parameter. The recorded_at field is the time the telemetry value was recorded in ISO-8601 format. The value field should be a string representing the current telemetry value.

shell