Skip to content
Processing Framework

TrimbleCloud.Processing package

Subpackages

Submodules

TrimbleCloud.Processing.deployment_secrets_api module

class TrimbleCloud.Processing.deployment_secrets_api.DeploymentSecretsAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Deployment Secrets

async create(deployment_id: str, identifier: str, value: str, name: str = None, description: str = None) → DeploymentSecret

Create a deployment secret

  • Parameters:
    • deployment_id (str) – The id of the Deployment
    • identifier (str) – The Deployment Secret identifier that is unique within the system
    • value (str) – A Base64 encoded string of the Secret value
    • name (str , optional) – Name of the Secret
    • description (str , optional) – A description of the Secret
  • Returns: The created deployment secret
  • Return type: DeploymentSecret (TypedDict)

Example:

client = ProcessingClient(BearerTokenHttpClientProvider(token_provider, "<BASE_ADDRESS>"))
deployment_secret = await client.deployment_secrets.create(
    deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    identifier="my-api-key",
    value="c29tZSBzZWNyZXQgdGV4dA==",
    name="My API Key",
    description="A description the Owner wrote"
)

async delete(id: str, deployment_id: str) → None

Delete the deployment secret

  • Parameters:
    • id (str) – The id of the Deployment secret
    • deployment_id (str) – The id of the Deployment

Example:

await client.deployment_secrets.delete(
    id="e11c800d-1777-47aa-9dc1-b99022a4a552",
    deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0"
)

async get(id: str, deployment_id: str) → DeploymentSecret

Get deployment secrets by id

  • Parameters:
    • id (str) – The id of the Deployment Secret
    • delpoyment_id (str) – The id of the Deployment
  • Returns: The requested deployment secret
  • Return type: DeploymentSecret (TypedDict)

Example:

deployment_secret = await client.deployment_secrets.get(
    id="e11c800d-1777-47aa-9dc1-b99022a4a552",
    deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0"
)

async list(deployment_id: str, query_params: Dict = {}) → Dict[str, Any]

Get a list of deployment secrets

  • Parameters:
    • deployment_id (str) – The id of the Deployment
    • query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of deployment secrets

Example:

params = { "per_page": 6 , "page": 1 }
deployment_secrets = await client.deployment_secrets.list(deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0", query_params=params)

list_sync(deployment_id: str, per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[DeploymentSecret]

Get a list of deployment secrets.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all deployment secrets.

  • Parameters:
    • deployment_id (str) – The id of the Deployment
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • account_id (str) – Filter Deployment Secrets by the Owner’s TID account identifier
    • client_id (str) – Filter Deployment Secrets by the Owner’s TID subject identifier (client ID)
    • owner (str) – Filter Deployment Secrets by the Owner’s internal name. Legacy parameter; prefer account_id or client_id
  • Returns: List of deployment secrets

Example:

secrets = client.deployment_secrets.list_sync(deployment_id="deployment_id")
for secret in secrets:
    print(secrets)

async retire(id: str, deployment_id: str) → DeploymentSecret

Retire the deployment secret

  • Parameters:
    • id (str) – The id of the secret to retire
    • deployment_id (str) – The id of the Deployment
  • Returns: The retired deployment secret
  • Return type: DeploymentSecret (TypedDict)

Example:

deployment_secret = await client.deployment_secrets.retire(
    id="e11c800d-1777-47aa-9dc1-b99022a4a552",
    deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0"
)

async update(id: str, deployment_id: str, name: str = None, description: str = None, value: str = None) → DeploymentSecret

Update the deployment secret

  • Parameters:
    • id (str) – The id of the Deployment Secret
    • deployment_id (str) – The id of the Deployment
    • name (str) – The new name of the Secret
    • description (str) – The new description of the Secret
    • value (str) – A base-64 encoded string of the Secret value. This property will be displayed in the response body.
  • Returns: The updated deployment secret
  • Return type: DeploymentSecret (TypedDict)

Example:

deployment_secret = await client.deployment_secrets.update(
    id="e11c800d-1777-47aa-9dc1-b99022a4a552",
    deployment_id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    description="A new description the Owner wrote",
    value="c29tZSBzZWNyZXQgdGV4dA=="
)

TrimbleCloud.Processing.deployments_api module

class TrimbleCloud.Processing.deployments_api.DeploymentsAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Deployments

async create(identifier: str, regions: List[str], scaling: Scaling, computing: Computing, **kwargs: Any) → Deployment

Create a deployment

  • Parameters:
    • identifier (str) – The identifier of the deployment
    • regions (list) – The location(s) this resource can run in
    • scaling (Scaling) – The configuration object to define minimum and maximum number of concurrent Engines that can be running simultaneously
    • computing (Computing) – The configuration object to define the Engine-compute resources for memory and CPU allocation
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • name (str) – Deployment name
    • description (str) – A description of the Deployment and its function
    • active_engine (str) – The Engine ID that is connected to this Deployment
    • public (bool) – The state of the Deployment’s publication
  • Returns: The created deployment
  • Return type: Deployment (TypedDict)

Example:

client = ProcessingClient(BearerTokenHttpClientProvider(token_provider, "<BASE_ADDRESS>"))
deployment = await client.deployments.create(
    name="Example Deployment",
    description="A description the of the Deployment.",
    identifier="example-deployment",
    active_engine="cb66f1e5-ad76-434b-8d14-6f979d1d2c91",
    regions=["azure-us1"],
    scaling={ "min": 0, "max": 2},
    computing={ "cpu": 0.5, "memory": 512 }
)

async get(id: str) → Deployment

Get a deployment by id

  • Parameters: id (str) – The id of the deployment
  • Returns: The requested deployment
  • Return type: Deployment (TypedDict)

Example:

deployment = await client.deployments.get(id="79cb4260-668a-4be5-adf3-5930d1d164e0")

async list(query_params: Dict = {}) → Dict[str, Any]

Get a list of deployments

  • Parameters: query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of deployments

Example:

params = { "per_page": 6, "page": 1 }
deployments = await client.deployments.list(params)

list_sync(per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[Deployment]

Get a list of deployments.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all deployments.

  • Parameters:
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • account_id (str) – Filter Deployments by the Owner’s TID account identifier
    • client_id (str) – Filter Deployments by the Owner’s TID subject identifier (client ID)
    • owner (str) – Filter Deployments by the Owner’s internal name. Legacy parameter; prefer account_id or client_id
    • identifier (str) – Return all Deployment(s) that match the provided identifier string
    • status (DeploymentStatus) – Filter Deployments based on the status
    • region (str) – Filter Deployments based on the region
    • active_engine (str) – Filter Deployments based on the active Engine ID
  • Returns: List of deployments

Example:

deployments = client.deployments.list_sync()
for deployment in deployments:
    print(deployment)

async retire(id: str) → Deployment

Retire a deployment

  • Parameters: id (str) – The id of the deployment to retire
  • Returns: The retired deployment
  • Return type: Deployment (TypedDict)

Example:

deployment = await client.deployments.retire(id="79cb4260-668a-4be5-adf3-5930d1d164e0")

async update(id: str, **kwargs: Any) → Deployment

Update a deployment

  • Parameters:
    • id (str) – The id of the deployment
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • name (str) – Deployment name
    • description (str) – A description of the Deployment and its function
    • active_engine (str) – The Engine ID that is connected to this Deployment
    • scaling (Scaling) – The configuration object to define minimum and maximum number of concurrent Engines that can be running simultaneously
    • computing (Computing) – The configuration object to define the Engine-compute resources for memory and CPU allocation
  • Returns: The updated deployment
  • Return type: Deployment (TypedDict)

Example:

deployment = await client.deployments.update(
    id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    name="A New Name",
    description="A new description."
)

TrimbleCloud.Processing.engines_api module

class TrimbleCloud.Processing.engines_api.EnginesAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Engines

async create(identifier: str, tag: str, ingestion_type: IngestionType, os: OSType, regions: List[str], **kwargs: Any) → Engine

Create an engine

  • Parameters:
    • identifier (str) – Engine identifier, unique within the system
    • tag (str) – The tag of the engine
    • ingestion_type (IngestionType) – The method of uploading a container image into the system
    • os (OSType) – Which OS for the Engine to use
    • regions (list) – The location(s) this resource can run in
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • name (str) – Engine name
    • description (str) – A description of the Engine and its function
    • os_build (OSBuild) – Specify which OS build to use. This is a required parameter for Windows Engines only.
    • env_vars (list [EnvironmentVariable ]) – Environment variables that are stored and ingested into the Engine’s container
    • secret_variables (list [SecretVariable ]) – Secret variables that are stored and ingested into the Engine’s container
    • secret_files (list [SecretFile ]) – Secret files that are stored and ingested into the Engine’s container
    • public (bool) – The state of the Engine’s publication
  • Returns: The created engine
  • Return type: Engine (TypedDict)

Example:

from TrimbleCloud.Processing.models import IngestionType, OSType


client = ProcessingClient(BearerTokenHttpClientProvider(token_provider, "<BASE_ADDRESS>"))
engine = await client.engines.create(
    identifier="example-engine",
    tag="v1",
    ingestion_type=IngestionType.ACR_TOKEN,
    os=OSType.LINUX,
    regions=["azure-us1"],
    name="Example Engine",
    description="A description the of the engine.",
    env_vars=[
        {
            "value": "literal_string_value",
            "container_var_name": "EXPECTED_ENV_VAR_NAME_IN_CONTAINER"
        }
    ],
    secret_variables=[
        {
            "secret_identifier": "expected-identifier-of-deployment-secret
            "container_var_name": "EXPECTED_SECRET_VAR_NAME_IN_CONTAINER"
        }
    ],
    secret_files=[
        {
            "secret_identifier": "expected-identifier-of-deployment-secret-file",
            "container_file_path": "/my/file/path/example_license.lic"
        }
    ]
)

async get(id: str) → Engine

Get an engine by id

  • Parameters: id (str) – The id of the engine to get
  • Returns: The requested engine
  • Return type: Engine (TypedDict)

Example:

engine = await client.engines.get(id="79cb4260-668a-4be5-adf3-5930d1d164e0")

async list(query_params: Dict = {}) → Dict[str, Any]

Get a list of engines

  • Parameters: query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of engines

Example:

params = { "per_page": 6, "page": 1 }
engines = await client.engines.list(query_params)

list_sync(per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[Engine]

Get a list of engines.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all engines.

  • Parameters:
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • account_id (str) – Filter Engines by the Owner’s TID account identifier
    • client_id (str) – Filter Engines by the Owner’s TID subject identifier (client ID)
    • owner (str) – Filter Engines by the Owner’s internal name. Legacy parameter; prefer account_id or client_id
    • identifier (str) – Return all Engine(s) that match the provided identifier
    • status (EngineStatus) – Filter Engines based on the status
    • region (str) – Filter Engines based on the region
    • os (str) – Filter Engines based on the OS
  • Returns: List of engines

Example:

engines = client.engines.list_sync()
for engine in engines:
    print(engine)

async push_image(id: str, source_image_name: str)

Push your source image to Processing AWS Container Registry

  • Parameters:
    • id (str) – The id of the engine
    • source_image_name (str) – A local image referenced by name. It must be full image name in the format of SOURCE_IMAGE[:TAG]. If the tag is not specified, it will use latest by default.
  • Returns: The output from the server

Example:

response = await client.engines.push_image(
    id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    source_image_name="source_image_name:tag"
)


for line in response:
    print(line)

async retire(id: str) → Engine

Retire an engine

  • Parameters: id (str) – The id of the engine to retire
  • Returns: The retired engine
  • Return type: Engine (TypedDict)

Example:

engine = await client.engines.retire(id="79cb4260-668a-4be5-adf3-5930d1d164e0")

async update(id: str, name: str = None, description: str = None) → Engine

Update an engine (Only name and description can be updated)

  • Parameters:
    • id (str) – The id of the engine to update
    • name (str) – The new name of the engine
    • description (str) – The new description of the engine
  • Returns: The updated engine
  • Return type: Engine (TypedDict)

Example:

engine = await client.engines.update(
    id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    name="A New Name",
    description="A new description."
)

TrimbleCloud.Processing.executions_api module

class TrimbleCloud.Processing.executions_api.ExecutionsAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Executions

async create(procedure_id: str, **kwargs: Any) → Execution

Creates and starts a new Procedure Execution in the system

  • Parameters:
    • procedure_id (str) – The unique id of the target Procedure
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • data_export (bool) – Whether or not the execution’s data will be available for export. Default is false.
    • region (str) – Region name for the Execution to run in. If not provided, then default_region of the Procedure is used.
    • parameters (dict) – Mapping of Procedure-specified parameter names to parameter values
    • metadata (str) – User-specified metadata to be associated with the Execution
    • bound_parameters (dict) – Mapping of Operation-specified output parameter names to output parameter values
  • Returns: The created execution
  • Return type: Execution (TypedDict)

Example:

execution = await client.executions.create(
    id="b592a501-2130-498f-8395-afe3bc4dde98",
    data_export=false,
    region="aws-us1",
    parameters={
        "FILENAME": "Output_File.las",
        "PARENT_ID": "DataOcean-Directory-ID",
        "TARGET": "DataOcean-File-ID"
    }
)

async get(id: str) → Execution

Read an execution

  • Parameters: id (str) – The id of the execution to read
  • Returns: The requested execution
  • Return type: Execution (TypedDict)

Example:

execution = await client.executions.get(id="b592a501-2130-498f-8395-afe3bc4dde98")

async get_data(id: str, output_path: str) → Execution

Get the Execution data

  • Parameters:
    • id (str) – The id of the execution to get data for
    • output_path (str) – Relative path of the user’s Data Ocean account where the data is to be placed
  • Returns: The execution response
  • Return type: Execution (TypedDict)

Example:

execution = await client.executions.get_data(
    id="b592a501-2130-498f-8395-afe3bc4dde98",
    output_path="/sample/data_ocean/path"
)

async get_logs(id: str, output_path: str) → Execution

Obtain log contents for a given Execution via DataOcean

  • Parameters:
    • id (str) – The execution id that logs are desired for
    • output_path (str) – Desired path to write the logs to in the client’s Data Ocean account
  • Returns: The execution response
  • Return type: Execution (TypedDict)

Example:

execution = await client.executions.get_logs(
    id="b592a501-2130-498f-8395-afe3bc4dde98",
    output_path="/example/path/"
)

async list(query_params: Dict = {}) → Dict[str, Any]

Retrieves a list of executions

  • Parameters: query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of executions

Example:

params = { "per_page": 6 , "page": 1 }
executions = await client.executions.list(query_params=params)

async list_activities(id: str, query_params: Dict = {}) → Dict[str, Any]

Get the list of activities tied to a Processing Execution

  • Parameters:
    • id (str) – The id of the execution to get activities for
    • query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of Activities

Example:

params = { "per_page": 10 , "page": 2 }
activities = await client.executions.list_activities(
    id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    query_params=params
)

list_activities_sync(execution_id: str, per_page: int = 100) → Iterable[Dict[str, Any]]

Get a list of activities for an execution.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all items.

  • Parameters:
    • execution_id (str) – The id of the execution to get activities for
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
  • Returns: List of activities

Example:

activities = client.executions.list_activities_sync(execution_id="execution_id")
for activity in activities:
    print(activity)

async list_events(id: str, query_params: Dict = {}) → Dict[str, Any]

Get the list of events tied to a Processing Execution

  • Parameters:
    • id (str) – The id of the execution to get events for
    • query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of Events

Example:

params = { "per_page": 5 , "page": 1 }
events = await client.executions.list_events(
    id="79cb4260-668a-4be5-adf3-5930d1d164e0",
    query_params=params
)

list_events_sync(execution_id: str, per_page: int = 100) → Iterable[Dict[str, Any]]

Get a list of events for an execution.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all items.

  • Parameters:
    • execution_id (str) – The id of the execution to get events for
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
  • Returns: List of events

Example:

events = client.executions.list_events_sync(execution_id="execution_id")
for event in events:
    print(event)

list_sync(per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[Execution]

Get a list of executions.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all executions.

  • Parameters:
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • procedure_uuid (str) – Return Executions that belong to the provided procedure ID
    • execution_status (ExecutionStatus) – Filter Executions by the provided execution status
    • region (str) – Filter Executions by region
    • created_start (str) – Filter Executions that have a created_at time that is after the supplied value
    • created_end (str) – Filter Executions that have a created_at time that is before the supplied value. The created_end parameter must be accompanied by the created_start parameter.
    • completed_start (str) – Filter Executions that have a completed_at time that is after the supplied value.
    • completed_end (str) – Filter Executions that have a completed_at time that is before the supplied value. The completed_end parameter must be accompanied by the completed_start parameter.
    • sort_by (str) – Sort Executions by created_at or completed_at, ascending(+) or descending(-). Examples: -completed_at | +completed_at | -created_at | +created_at
  • Returns: List of executions

Example:

executions = client.executions.list_sync()
for execution in executions:
    print(execution)

TrimbleCloud.Processing.operations_api module

class TrimbleCloud.Processing.operations_api.OperationsAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Operations

async approve(id: str) → Operation

Approve an operation

  • Parameters: id (str) – The id of the Operation to approve
  • Returns: The approved operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.approve(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async clone(id: str) → Operation

Clone an operation

  • Parameters: id (str) – The id of the Operation to clone
  • Returns: The cloned operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.clone(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async create(identifier: str, version: int, deployment_identifier: str, **kwargs: Any) → Operation

Create an operation

  • Parameters:
    • identifier (str) – Unique identifier string for the Operation
    • version (int) – The version of the Operation
    • deployment_identifier (str) – The identifier of the Deployment that supports this Operation
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • regions (list *[*str ]) – List of regions where Operation is allowed to run in
    • public (bool) – Whether the Operation should be public or not
    • name (str) – The name of the Operation
    • description (str) – A description of the Operation and its function
    • engine_name (str) – The name of the backend engine that supports this Operation
    • shared_with (list [SharedWithIdentity ]) – List of identities with whom this Operation has been shared. Each entry contains an account_id and optionally a client_id. An entry with only account_id grants access to all clients in that account. An entry with both client_id and account_id grants access to that specific client only. Note: Sending an array replaces the existing list, not appends to it.
    • parameters (dict *[*str , Parameter ]) – Parameter objects attached to the Operation
    • output_parameters (dict *[*str , Parameter ]) – Parameter objects that define values to be output from an Operation
    • inputs (dict *[*str , Input ]) – Named inputs for the Operation
    • outputs (dict *[*str , Output ]) – Named outputs for the Operation
    • dynamic_output (bool) – Indicates whether or not the Output content is considered dynamic
  • Returns: The created operation
  • Return type: Operation (TypedDict)

Example:

from TrimbleCloud.Processing.models import DataType


operation = await client.operations.create(
    identifier="dataocean_download_path",
    version=10,
    deployment_identifier="dataoceanoperations",
    name="Data Ocean Download by Path",
    description="Download a file or directory of files from Data Ocean.",
    shared_with=[ { "account_id": "f0e1d2c3-b4a5-6789-0fed-cba987654321", "client_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890" } ],
    output_parameters={
        "output_parameter_identifier": {
            "type": DataType.STRING,
            "description": "A sample output parameter",
            "name": "Sample Output Parameter",
            "optional": False
        }
    },
    parameters={
        "parameter_identifier": {
            "type": "string",
            "description": "The Dropbox access token used to download the file",
            "name": "Dropbox Access Token",
            "optional": True,
            "encrypted": False
        }
    },
    inputs={
        "input_identifier": {
            "data_types": [ "*" ],
            "description": "A sample input",
            "name": "First Input",
            "optional": True
        }
    }
)

async delete(id: str) → None

Delete an Operation

  • Parameters: id (str) – The id of the Operation to delete

Example:

await client.operations.delete(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async get(id: str) → Operation

Read an operation

  • Parameters: id (str) – The id of the Operation to read
  • Returns: The requested operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.get(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async list(query_params: Dict = {}) → Dict[str, Any]

Retrieves a list of operations

  • Parameters: query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of operations

Example:

params = { "per_page": 6 , "page": 1 }
operations = await client.operations.list(query_params=params)

list_sync(per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[Operation]

Get a list of operations.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all operations.

  • Parameters:
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • engine (str) – Filter Operations by engine name
    • deployment_identifier (str) – Filter Operations by deployment identifier
    • procedure_uuid (str) – Return Operations that belong to the associated procedure ID
    • identifier (str) – Returns all Operation(s) that match the provided identifier
    • status (Status) – Filter Operations by status
    • execution_status (str) – Filter Operations by execution status
    • region (str) – Filter Operations by region
  • Returns: List of operations

Example:

operations = client.operations.list_sync()
for operation in operations:
    print(operation)

async publish(id: str) → Operation

Publish an operation

  • Parameters: id (str) – The id of the operation to publish
  • Returns: The published operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.publish(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async retire(id: str) → Operation

Retire an operation

  • Parameters: id (str) – The id of the operation to retire
  • Returns: The retired operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.retire(id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a")

async update(id: str, **kwargs: Any) → Operation

Update an Operation. An Operation can only be updated when it is in a MUTABLE state (prior to approval)

  • Parameters:
    • id (str) – The id of the Operation to update
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • identifier (str) – Unique identifier string for the Operation
    • version (int) – The version of the operation
    • deployment_identifier (str) – The identifier of the Deployment that supports this Operation
    • regions (list *[*str ]) – List of regions where Operation is allowed to run in
    • public (bool) – Whether the Operation should be public or not
    • name (str) – The name of the Operation
    • description (str) – A description of the Operation and its function
    • engine_name (str) – The name of the backend engine that supports this Operation
    • shared_with (list [SharedWithIdentity ]) – List of identities with whom this Operation has been shared. Each entry contains an account_id and optionally a client_id. An entry with only account_id grants access to all clients in that account. An entry with both client_id and account_id grants access to that specific client only. Note: Sending an array replaces the existing list, not appends to it.
    • parameters (dict *[*str , Parameter ]) – Parameter objects attached to the Operation
    • output_parameters (dict *[*str , Parameter ]) – Parameter objects that define values to be output from an Operation
    • inputs (dict *[*str , Input ]) – Named inputs for the Operation
    • outputs (dict *[*str , Output ]) – Named outputs for the Operation
    • dynamic_output (bool) – Indicates whether or not the Output content is considered dynamic
    • deprecation_message (str) – A message indicating that the Operation is deprecated
    • retired_after (str) – The date after which the Operation is retired
  • Returns: The updated operation
  • Return type: Operation (TypedDict)

Example:

operation = await client.operations.update(
    id="f2a04a08-9a48-45d3-8ddb-d0b1cc40982a",
    name="Data Ocean Download by Path",
    description="Download a file or directory of files from Data Ocean."
)

TrimbleCloud.Processing.procedures_api module

class TrimbleCloud.Processing.procedures_api.ProceduresAPI(http_client_provider, consumer_key)

Bases: object

API Methods relating to Trimble Cloud Platform Processing Framework Procedures

async approve(id: str) → Procedure

Approve a procedure

  • Parameters: id (str) – The id of the procedure to approve
  • Returns: The approved procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.approve(id="8fad9689-c459-4fed-933a-acc5c3dec8bb")

async create(identifier: str, version: int, default_region: str, operations: Dict[str, OperationChain], **kwargs: Any) → Procedure

Create a procedure

  • Parameters:
    • identifier (str) – Unique identifier string for the Procedure
    • version (int) – The version of the Procedure
    • default_region (str) – Region name the Procedure should execute in by default
    • operations (dict *[*str , OperationChain ]) – Mapping of Procedure names and definitions
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • name (str) – The name of the Procedure
    • description (str) – A description of the Procedure and its function
    • tags (str) – List of tags (as strings) associated with the Procedure
    • documentation_url (str) – Optional URL to reference external documentation for the Procedure
    • shared_with (list [SharedWithIdentity ]) – List of identities with whom this Procedure has been shared. Each entry contains an account_id and optionally a client_id. An entry with only account_id grants access to all clients in that account. An entry with both client_id and account_id grants access to that specific client only. Note: Sending an array replaces the existing list, not appends to it.
    • parameters (dict *[*str , ProcedureParameter ]) – Parameter mappings for the Procedures contained within the Procedure
  • Returns: The created procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.create(
    identifier="tzf_to_las_test",
    version=4,
    default_region="aws-us1",
    operations={
        "Operation-1": {
            "identifier": "tzf_to_las",
            "version": 1,
            "engine_name": "tzftolas",
            "parameters": {
                "filename": {
                "source": "FILENAME",
                "optional": True
                }
            },
            "inputs": {
                "in_files": {
                "data_types": "*",
                "sources": [ "dataocean_read:output" ]
                }
            },
            "outputs": {
                "out_files": {
                    "data_type": "*"
                }
            },
            "name": "tzf_to_las",
            "description": "Converts a TZF file into a LAS point cloud."
        }
    },
    name="tzf_to_las_test",
    description="This Procedure tests the tzf_to_las operation.",
    shared_with=[ { "account_id": "f0e1d2c3-b4a5-6789-0fed-cba987654321", "client_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890" } ],
    parameters={
        "FILENAME": {
            "type": "string",
            "default_value": "OUTPUT.las",
            "description": "Name to give to output file"
        }
    }
)

async delete(id: str) → None

Delete a procedure

  • Parameters: id (str) – The id of the procedure to delete

Example:

await client.procedures.delete(id="8fad9689-c459-4fed-933a-acc5c3dec8bb")

async get(id: str) → Procedure

Read a procedure

  • Parameters: id (str) – The id of the procedure to read
  • Returns: The requested procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.get(id="8fad9689-c459-4fed-933a-acc5c3dec8bb")

async list(query_params: Dict = {}) → Dict[str, Any]

Retrieves a list of procedures

  • Parameters: query_params (dict , optional) – The query parameters to use in the request, must be an object accepted by urlencode
  • Returns: List of procedures

Example:

params = { "per_page": 6 , "page": 1 }
procedures = await client.procedures.list(query_params=params)

list_sync(per_page: int = 100, **kwargs: Dict[str, Any]) → Iterable[Procedure]

Get a list of procedures.

This method abstracts the complexity of pagination and provides an iterable interface to retrieve all procedures.

  • Parameters:
    • per_page (int ) (optional) – The number of items to return per iteration. Default is 100.
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • public (bool) – Filter Procedures by public status
    • operation_uuid (str) – Filter Procedures by operation ID
    • identifier (str) – Return all Procedure(s) that match the provided identifier
    • status (Status) – Filter Procedures by status
    • execution_status (str) – Filter Procedures by execution status
    • region (str) – Filter Procedures by region
  • Returns: List of procedures

Example:

procedures = client.procedures.list_sync()
for procedure in procedures:
    print(procedure)

async publish(id: str) → Procedure

Publish a procedure

  • Parameters: id (str) – The id of the procedure to publish
  • Returns: The published procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.publish(id="8fad9689-c459-4fed-933a-acc5c3dec8bb")

async retire(id: str) → Procedure

Retire a procedure

  • Parameters: id (str) – The id of the procedure to retire
  • Returns: The retired procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.retire(id="8fad9689-c459-4fed-933a-acc5c3dec8bb")

async update(id: str, **kwargs: Any) → Procedure

Update a procedure

  • Parameters:
    • id (str) – The id of the procedure to update
    • **kwargs – Arbitrary keyword arguments. See below.
  • Keyword Arguments:
    • identifier (str) – Unique identifier string for the Procedure
    • version (int) – The version of the Procedure
    • name (str) – The name of the Procedure
    • description (str) – A description of the Procedure and its function
    • tags (str) – List of tags (as strings) associated with the Procedure
    • documentation_url (str) – Optional URL to reference external documentation for the Procedure
    • shared_with (list [SharedWithIdentity ]) – List of identities with whom this Procedure has been shared. Each entry contains an account_id and optionally a client_id. An entry with only account_id grants access to all clients in that account. An entry with both client_id and account_id grants access to that specific client only. Note: Sending an array replaces the existing list, not appends to it.
    • default_region (str) – Region name the Procedure should execute in by default
    • operations (dict *[*str , OperationChain ]) – Mapping of Procedure names and definitions
    • parameters (dict *[*str , ProcedureParameter ]) – Parameter mappings for the Procedures contained within the Procedure
  • Returns: The updated procedure
  • Return type: Procedure (TypedDict)

Example:

procedure = await client.procedures.update(
    id="8fad9689-c459-4fed-933a-acc5c3dec8bb",
    description= "Description Updated Partial Update - This Procedure tests the tzf_to_las operation."
)

TrimbleCloud.Processing.processing_client module

class TrimbleCloud.Processing.processing_client.ProcessingClient(token_provider: FixedTokenProvider | ClientCredentialTokenProvider, base_url: str = ‘https://cloud.api.trimble.com/Processing/api/1/api/’, **kwargs: Any)

Bases: object

A client for the Trimble Cloud Platform Processing Framework

Module contents

class TrimbleCloud.Processing.ProcessingClient(token_provider: FixedTokenProvider | ClientCredentialTokenProvider, base_url: str = ‘https://cloud.api.trimble.com/Processing/api/1/api/’, **kwargs: Any)

Bases: object

A client for the Trimble Cloud Platform Processing Framework