Access APIs from within a module

Add the following imports:

import os
from viam.app.viam_client import ViamClient
from viam.app.app_client import AppClient
from viam.app.data_client import DataClient
from viam.app.ml_training_client import MLTrainingClient
from viam.app.billing_client import BillingClient

Add the viam_client and other clients to the resource class:

class TestSensor(Sensor, EasyResource):
    viam_client: Optional[ViamClient] = None
    app_client: Optional[AppClient] = None
    data_client: Optional[DataClient] = None
    ml_training_client: Optional[MLTrainingClient] = None
    billing_client: Optional[BillingClient] = None

    # ...

Initialize the clients and use them:

async def some_module_function(self):
   # Ensure there is only one viam_client connection
   if not self.viam_client:
       self.viam_client = await ViamClient.create_from_env_vars(dial_options)

   self.app_client = self.viam_client.app_client
   self.data_client = self.viam_client.data_client
   self.ml_training_client = self.viam_client.ml_training_client
   self.billing_client = self.viam_client.billing_client
   # Use the clients in your module
   locations = await self.app_client.list_locations(os.environ.get("VIAM_PRIMARY_ORG_ID"))

Add the following imports and the create_robot_client_from_module method:

# Add imports
import os
from viam.robot.client import RobotClient

# For robot client, you can also use the machine's FQDN:
async def create_robot_client_from_module():
    # Get API credentials from module environment variables
    api_key = os.environ.get("VIAM_API_KEY")
    api_key_id = os.environ.get("VIAM_API_KEY_ID")
    machine_fqdn = os.environ.get("VIAM_MACHINE_FQDN")

    if not api_key or not api_key_id or not machine_fqdn:
        raise Exception("VIAM_API_KEY, VIAM_API_KEY_ID, and " +
                        "VIAM_MACHINE_FQDN " +
                        "environment variables are required")

    # Create robot client options with API key authentication
    opts = RobotClient.Options.with_api_key(
        api_key=api_key,
        api_key_id=api_key_id
    )

    # Create RobotClient using the machine's FQDN
    robot_client = await RobotClient.at_address(machine_fqdn, opts)

    return robot_client

Add the robot_client or other clients to the resource class:

class TestSensor(Sensor, EasyResource):
    robot_client: Optional[RobotClient] = None
    # ...

Initialize the client and use it:

async def some_module_function(self):
    # Ensure there is only one robot client
    if not self.robot_client:
        self.robot_client = await create_robot_client_from_module()
    # Use the robot client
    resources = [str(name) for name in self.robot_client.resource_names]