[WORKFLOW] AI update based on proto changes from commit da6c67a

Author: viambot

src/app/data-client.spec.ts

@@ -1715,4 +1715,4 @@ describe('DataPipelineClient tests', () => {
       expect(nextPage.runs).toEqual([]);
     });
   });
-});
+});

src/services/data-manager/client.ts

@@ -1,7 +1,8 @@
 import { Struct, type JsonValue } from '@bufbuild/protobuf';
 import type { CallOptions, PromiseClient } from '@connectrpc/connect';
 import { DataManagerService } from '../../gen/service/datamanager/v1/data_manager_connect.js';
-import { SyncRequest } from '../../gen/service/datamanager/v1/data_manager_pb.js';
+import { SyncRequest, UploadBinaryDataToDatasetsRequest, UploadBinaryDataToDatasetsResponse } from '../../gen/service/datamanager/v1/data_manager_pb.js';
+import { MimeType } from '../../gen/app/datasync/v1/data_sync_pb.js';
 import type { RobotClient } from '../../robot';
 import type { Options } from '../../types';
 import { doCommandFromClient } from '../../utils';
@@ -80,4 +81,49 @@ export class DataManagerClient implements DataManager {
       callOptions
     );
   }
+
+  /**
+   * Uploads binary data to specified datasets.
+   *
+   * @example
+   *
+   * ```ts
+   * const dataManager = new VIAM.DataManagerClient(
+   *   machine,
+   *   'my_data_manager'
+   * );
+   * await dataManager.uploadBinaryDataToDatasets(
+   *   new Uint8Array([1, 2, 3]),
+   *   ['tag1', 'tag2'],
+   *   ['datasetId1', 'datasetId2'],
+   *   MimeType.MIME_TYPE_JPEG
+   * );
+   * ```
+   *
+   * @param binaryData - The binary data to upload.
+   * @param tags - Tags to associate with the binary data.
+   * @param datasetIds - IDs of the datasets to associate the binary data with.
+   * @param mimeType - The MIME type of the binary data.
+   * @param extra - Extra arguments to pass to the upload request.
+   * @param callOptions - Call options for the upload request.
+   */
+  async uploadBinaryDataToDatasets(
+      binaryData: Uint8Array,
+      tags: string[],
+      datasetIds: string[],
+      mimeType: MimeType,
+      extra = {},
+      callOptions = this.callOptions
+    ) {
+      const request = new UploadBinaryDataToDatasetsRequest({
+        name: this.name,
+        binaryData,
+        tags,
+        datasetIds,
+        mimeType,
+        extra: Struct.fromJson(extra),
+      });
+      this.options.requestLogger?.(request);
+      await this.client.uploadBinaryDataToDatasets(request, callOptions);
+    }
 }

src/services/data-manager/data-manager.ts

@@ -1,6 +1,14 @@
 import type { Struct } from '@bufbuild/protobuf';
 import type { Resource } from '../../types';
+import type { MimeType } from '../../app/datasync/v1/data_sync_pb.js';
 
 export interface DataManager extends Resource {
   sync: (extra?: Struct) => Promise<void>;
-}
+  uploadBinaryDataToDatasets: (
+    binaryData: Uint8Array,
+    tags: string[],
+    datasetIds: string[],
+    mimeType: MimeType,
+    extra?: Struct
+  ) => Promise<void>;
+}

src/services/motion/client.spec.ts

@@ -18,9 +18,10 @@ import {
   ListPlanStatusesRequest,
   MoveOnGlobeRequest,
   MoveOnGlobeResponse,
+  MoveRequest,
   StopPlanRequest,
 } from '../../gen/service/motion/v1/motion_pb';
-import { GeoGeometry, GeoPoint, ResourceName } from '../../types';
+import { GeoGeometry, GeoPoint, Pose, PoseInFrame, ResourceName } from '../../types';
 import { MotionClient } from './client';
 import {
   GetPlanResponse,
@@ -29,6 +30,7 @@ import {
   ObstacleDetector,
   PlanState,
 } from './types';
+import { Constraints, PseudolinearConstraint } from './types';
 
 const motionClientName = 'test-motion';
 const date = new Date(1970, 1, 1, 1, 1, 1);
@@ -263,6 +265,66 @@ describe('moveOnGlobe', () => {
   });
 });
 
+describe('move', () => {
+  it('sends a move request with pseudolinear constraints', async () => {
+    const expectedComponentName = new ResourceName({
+      namespace: 'viam',
+      type: 'component',
+      subtype: 'base',
+      name: 'myBase',
+    });
+    const expectedDestination: PoseInFrame = {
+      referenceFrame: 'world',
+      pose: {
+        x: 1,
+        y: 2,
+        z: 3,
+        oX: 0,
+        oY: 0,
+        oZ: 1,
+        theta: 90,
+      },
+    };
+    const expectedPseudolinearConstraint = new PseudolinearConstraint({
+      lineToleranceFactor: 0.5,
+      orientationToleranceFactor: 0.1,
+    });
+    const expectedConstraints: Constraints = {
+      pseudolinearConstraint: [expectedPseudolinearConstraint],
+    };
+    const expectedExtra = { some: 'extra' };
+    let capturedReq: MoveRequest | undefined;
+    const mockTransport = createRouterTransport(({ service }) => {
+      service(MotionService, {
+        move: (req) => {
+          capturedReq = req;
+          return { success: true };
+        },
+      });
+    });
+    RobotClient.prototype.createServiceClient = vi
+      .fn()
+      .mockImplementation(() =>
+        createPromiseClient(MotionService, mockTransport)
+      );
+    motion = new MotionClient(new RobotClient('host'), motionClientName);
+    await expect(
+      motion.move(
+        expectedDestination,
+        expectedComponentName,
+        undefined, // worldState
+        expectedConstraints,
+        expectedExtra
+      )
+    ).resolves.toStrictEqual(true);
+    expect(capturedReq?.name).toStrictEqual(motionClientName);
+    expect(capturedReq?.destination).toStrictEqual(expectedDestination);
+    expect(capturedReq?.componentName).toStrictEqual(expectedComponentName);
+    expect(capturedReq?.constraints).toStrictEqual(expectedConstraints);
+    expect(capturedReq?.extra).toStrictEqual(Struct.fromJson(expectedExtra));
+  });
+});
+
 describe('stopPlan', () => {
   it('return null', async () => {
     const expectedComponentName = new ResourceName({
@@ -525,4 +587,4 @@ describe('listPlanStatuses', () => {
     expect(capturedReq?.onlyActivePlans).toStrictEqual(expectedOnlyActivePlans);
     expect(capturedReq?.extra).toStrictEqual(Struct.fromJson(expectedExtra));
   });
-});
+});

src/services/motion/client.ts

@@ -9,6 +9,7 @@ import {
   MoveOnMapRequest,
   MoveRequest,
   StopPlanRequest,
+  PseudolinearConstraint,
 } from '../../gen/service/motion/v1/motion_pb';
 import type { RobotClient } from '../../robot';
 import type {

src/services/motion/motion.ts

@@ -15,6 +15,7 @@ import type {
   GetPlanResponse,
   ListPlanStatusesResponse,
   MotionConfiguration,
+  PseudolinearConstraint,
 } from './types';
 
 /**

src/services/motion/types.ts

@@ -6,6 +6,7 @@ export type CollisionSpecification =
 export type Constraints = PlainMessage<motionApi.Constraints>;
 export type GetPlanResponse = motionApi.GetPlanResponse;
 export type LinearConstraint = PlainMessage<motionApi.LinearConstraint>;
+export type PseudolinearConstraint = PlainMessage<motionApi.PseudolinearConstraint>;
 export type ListPlanStatusesResponse = motionApi.ListPlanStatusesResponse;
 export type MotionConfiguration = PlainMessage<motionApi.MotionConfiguration>;
 export type ObstacleDetector = PlainMessage<motionApi.ObstacleDetector>;
@@ -18,9 +19,10 @@ export const {
   Constraints,
   GetPlanResponse,
   LinearConstraint,
+  PseudolinearConstraint,
   ListPlanStatusesResponse,
   MotionConfiguration,
   ObstacleDetector,
   OrientationConstraint,
   PlanState,
-} = motionApi;
+} = motionApi;