Release v1.24.3

Author: edge-impulse-firmware-uploader[bot]

cli-common/config.ts

@@ -47,6 +47,7 @@ export interface SerialConfig {
     camera: string | undefined;
     audio: string | undefined;
     runner: RunnerConfig;
+    apiKeysForProject: { [projectId: string]: string } | undefined;
 }
 
 export interface EdgeImpulseEndpoints {
@@ -174,6 +175,21 @@ export class Config {
         await this.store(config);
     }
 
+    async getApiKeyForProject(projectId: number): Promise<string | undefined> {
+        let config = await this.load();
+        if (!config) {
+            return undefined;
+        }
+        return (config.apiKeysForProject || { })[projectId.toString()];
+    }
+
+    async setApiKeyForProject(projectId: number, apiKey: string) {
+        let config = await this.load();
+        config.apiKeysForProject = config.apiKeysForProject || { };
+        config.apiKeysForProject[projectId.toString()] = apiKey;
+        await this.store(config);
+    }
+
     async getLastVersionCheck() {
         let config = await this.load();
         if (!config) {
@@ -310,12 +326,18 @@ export class Config {
 
         // fetch user...
         if (config.jwtToken) {
-            let user = await this._api.user.getCurrentUser();
-            // check if has developer profile...
-            if (!user.organizations.find(x => x.isDeveloperProfile)) {
-                console.log(PREFIX, 'Creating developer profile...');
-                await this._api.user.createDeveloperProfile();
-                console.log(PREFIX, 'Creating developer profile OK');
+            try {
+                let user = await this._api.user.getCurrentUser();
+                // check if has developer profile...
+                if (!user.organizations.find(x => x.isDeveloperProfile)) {
+                    console.log(PREFIX, 'Creating developer profile...');
+                    await this._api.user.createDeveloperProfile();
+                    console.log(PREFIX, 'Creating developer profile OK');
+                }
+            }
+            catch (ex) {
+                if (!apiKey) throw ex;
+                // Otherwise ok
             }
         }
 
@@ -543,7 +565,8 @@ export class Config {
                     modelVariantsForProjectId: undefined,
                     storageMaxSizeMb: undefined,
                     monitorSummaryIntervalMs: undefined,
-                }
+                },
+                apiKeysForProject: undefined,
             };
         }
 

cli-common/init-cli-app.ts

@@ -6,6 +6,10 @@ import checkNewVersions from './check-new-version';
 import { AWSSecretsManagerUtils } from "./aws-sm-utils";
 import { AWSIoTCoreConnector } from "./aws-iotcore-connector";
 import searchList from 'inquirer-search-list';
+import { EdgeImpulseApi } from '../sdk/studio';
+import os from 'node:os';
+
+const PREFIX = '\x1b[33m[INT]\x1b[0m';
 
 inquirer.registerPrompt('search-list', searchList);
 
@@ -164,6 +168,7 @@ export async function setupCliApp(configFactory: Config, config: EdgeImpulseConf
     apiKeyArgv: string | undefined,
     devArgv: boolean,
     hmacKeyArgv: string | undefined,
+    verboseArgv: boolean,
     connectProjectMsg: string,
     getProjectFromConfig?: (deviceId: string | undefined) => Promise<{ projectId: number } | undefined>
 }, deviceId: string | undefined) {
@@ -228,24 +233,63 @@ export async function setupCliApp(configFactory: Config, config: EdgeImpulseConf
         apiKey: opts.apiKeyArgv || '',
         hmacKey: opts.hmacKeyArgv || '0'
     };
-    if (!opts.apiKeyArgv) {
+
+    // get hmac dev key (if set)
+    if (!opts.hmacKeyArgv) {
         try {
-            let dk = (await config.api.projects.listDevkeys(projectId));
+            let dk = (await config.api.projects.getHmacDevkey(projectId));
+            if (dk.hmacKey) {
+                devKeys.hmacKey = dk.hmacKey;
+            }
+        }
+        catch (ex2) {
+            // noop, e.g. key with not enough permissions
+            if (opts.verboseArgv) {
+                const ex = <Error>ex2;
+                console.log(PREFIX, `Could not fetch development Hmac key: ` + (ex.message || ex.toString()));
+            }
+        }
+    }
 
-            if (!dk.apiKey) {
-                throw new Error('No API key set (via --api-key), and no development API keys configured for ' +
-                    'this project. Add a development API key from the Edge Impulse dashboard to continue.');
+    if (!opts.apiKeyArgv) {
+        // create API key
+        let apiKey = await configFactory.getApiKeyForProject(projectId);
+        if (apiKey) {
+            // validate API key...
+            const api = new EdgeImpulseApi({
+                endpoint: config.endpoints.internal.api,
+                extraHeaders: { 'User-Agent': 'EDGE_IMPULSE_CLI' },
+            });
+            api.authenticate({
+                method: 'apiKey',
+                apiKey: apiKey,
+            });
+            try {
+                await api.projects.getProjectInfo(projectId);
             }
+            catch (ex2) {
+                // noop, e.g. key with not enough permissions
+                if (opts.verboseArgv) {
+                    const ex = <Error>ex2;
+                    console.log(PREFIX, `Failed to do request with stored API key for project ${projectId} (ERR: ${ex.message || ex.toString()}). ` +
+                        `Creating new API key...`);
+                }
 
-            devKeys.apiKey = dk.apiKey;
-            if (!opts.hmacKeyArgv && dk.hmacKey) {
-                devKeys.hmacKey = dk.hmacKey;
+                apiKey = undefined;
             }
         }
-        catch (ex2) {
-            let ex = <Error>ex2;
-            throw new Error('Failed to load development keys: ' + (ex.message || ex.toString()));
+
+        if (!apiKey) {
+            const res = await config.api.projects.addProjectApiKey(projectId, {
+                name: `Edge Impulse CLI (${os.hostname()})`,
+                role: 'ingestion_deployment',
+                isDevelopmentKey: false,
+            });
+            apiKey = res.apiKey;
+            await configFactory.setApiKeyForProject(projectId, apiKey);
         }
+
+        devKeys.apiKey = apiKey;
     }
 
     return {

cli/linux/linux.ts

@@ -9,7 +9,7 @@ import program from 'commander';
 import Path from 'path';
 import fs from 'fs';
 import Websocket from 'ws';
-import { initCamera, initMicrophone, getCameraType } from '../../library/sensors/sensors-helper';
+import { initCamera, initMicrophone, getCameraType, CameraType } from '../../library/sensors/sensors-helper';
 import { LinuxDevice } from './linux-device';
 
 const packageVersion = (<{ version: string }>JSON.parse(fs.readFileSync(
@@ -39,6 +39,8 @@ program
     .option('--verbose', 'Enable debug logs')
     .option('--greengrass', 'Enable AWS IoT greengrass integration mode')
     .option('--gst-source <args>', 'Defines the gstreamer source. E.g --gst-source \"tcpserversrc host=0.0.0.0 port=5050 ! jpegdec\"')
+    .option('--fake-camera <path>', 'Create a fake camera instance')
+    .option('--dont-prompt-for-device-name', `Don't prompt for a device name`)
     .allowUnknownOption(true)
     .parse(process.argv);
 
@@ -60,6 +62,8 @@ const cameraArgv = <string | undefined>program.camera;
 const microphoneArgv = <string | undefined>program.microphone;
 const cameraColorFormatArgv = <string | undefined>program.cameraColorFormat;
 const gstSourceArgv = <string | undefined>program.gstSource;
+const fakeCameraArgv = <string | undefined>program.fakeCamera;
+const dontPromptForDeviceName = !!program.dontPromptForDeviceName;
 
 if ((program.width && !program.height) || (!program.width && program.height)) {
     console.error('--width and --height need to either be both specified or both omitted');
@@ -90,6 +94,7 @@ const cliOptions = {
     devArgv: devArgv,
     hmacKeyArgv: hmacKeyArgv,
     silentArgv: silentArgv,
+    verboseArgv: verboseArgv,
     connectProjectMsg: 'To which project do you want to connect this device?',
     getProjectFromConfig: async () => {
         let projectId = await configFactory.getLinuxProjectId();
@@ -107,7 +112,9 @@ let isExiting = false;
 // eslint-disable-next-line @typescript-eslint/no-floating-promises
 (async () => {
     try {
-        const cameraType = getCameraType();
+        const cameraType = fakeCameraArgv ?
+            CameraType.Fake :
+            getCameraType();
 
         const init = await initCliApp(cliOptions);
         const config = init.config;
@@ -128,6 +135,8 @@ let isExiting = false;
             undefined, // model monitoring object
             url => new Websocket(url),
             async (currName) => {
+                if (dontPromptForDeviceName) return currName;
+
                 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                 let nameDevice = <{ nameDevice: string }>await inquirer.prompt([{
                     type: 'input',
@@ -200,6 +209,7 @@ let isExiting = false;
                 dontOutputRgbBuffers: true,
                 preferJpegCaps: false,
                 gstSource: gstSourceArgv,
+                fakeImageCameraPath: fakeCameraArgv,
             });
             camera = await initedCamera.start();
             const cameraOpts = camera.getLastOptions();

cli/linux/runner.ts

@@ -114,6 +114,7 @@ program
         `Then you write to the server from another GStreamer pipeline via: ` +
         `"gst-launch-1.0 v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! jpegenc ! tcpclientsink host=localhost port=5050". ` +
         `Only "tcpserversrc" elements are currently supported.`)
+    .option('--fake-camera <path>', 'Create a fake camera instance')
     .option('--enable-gpu', 'Enable GPU acceleration for VLM models (removes CPU-only mode) on certain Qualcomm targets (RB3 Gen 2, IQ-9)')
     .option('--verbose', 'Enable debug logs')
     .allowUnknownOption(true)
@@ -178,6 +179,7 @@ const microphoneArgv = <string | undefined>program.microphone;
 const cameraColorFormatArgv = <string | undefined>program.cameraColorFormat;
 const experimentalGstPreferJpegArgv = !!program.experimentalGstPreferJpeg;
 let modeArgv = <'streaming' | 'http-server' | undefined>program.mode;
+const fakeCameraArgv = <string | undefined>program.fakeCamera;
 
 if (modeArgv === 'http-server' && typeof runHttpServerPort === 'undefined') {
     runHttpServerPort = 1337;
@@ -206,6 +208,7 @@ const cliOptions = {
     devArgv: devArgv,
     hmacKeyArgv: undefined,
     silentArgv: silentArgv,
+    verboseArgv: verboseArgv,
     connectProjectMsg: 'From which project do you want to load the model?',
     getProjectFromConfig: async () => {
         if (!configFactory) return undefined;
@@ -349,7 +352,9 @@ async function ensureVlmServer(opts: { serverPath: string,
         let devKeys: { apiKey: string, hmacKey: string };
         let runner: LinuxImpulseRunner;
         let model: ModelInformation;
-        const cameraType = getCameraType();
+        const cameraType = fakeCameraArgv ?
+            CameraType.Fake :
+            getCameraType();
 
         // AWS Support
         let awsSM: AWSSecretsManagerUtils | undefined;
@@ -1027,6 +1032,7 @@ async function ensureVlmServer(opts: { serverPath: string,
                     dontOutputRgbBuffers: dontOutputRgbBuffersArgv,
                     preferJpegCaps: experimentalGstPreferJpegArgv,
                     gstSource: gstSourceArgv,
+                    fakeImageCameraPath: fakeCameraArgv,
                 });
 
                 console.log(RUNNER_PREFIX, `Using camera "${cameraInit.cameraDevice}" (because --enable-camera, run with --clean to select another one)`);
@@ -1191,6 +1197,7 @@ async function ensureVlmServer(opts: { serverPath: string,
                 dontOutputRgbBuffers: dontOutputRgbBuffersArgv,
                 preferJpegCaps: experimentalGstPreferJpegArgv,
                 gstSource: gstSourceArgv,
+                fakeImageCameraPath: fakeCameraArgv,
             });
 
             await configFactory.storeCamera(cameraInit.cameraDevice);

library/sensors/fake-camera.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import { EventEmitter } from 'tsee';
+import { ICamera, ICameraProfilingInfoEvent, ICameraSnapshotForInferenceEvent, ICameraStartOptions } from './icamera';
+
+export class FakeCamera extends EventEmitter<{
+    snapshot: (buffer: Buffer, filename: string) => void,
+    snapshotForInference: (ev: ICameraSnapshotForInferenceEvent) => void,
+    error: (message: string) => void,
+    profilingInfo: (ev: ICameraProfilingInfoEvent) => void,
+}> implements ICamera {
+    private _imagePath: string;
+    private _image: Buffer | undefined;
+    private _timeout: NodeJS.Timeout | undefined;
+    private _lastOptions: ICameraStartOptions | undefined;
+
+    /**
+     * Instantiate the imagesnap backend (on macOS)
+     */
+    constructor(opts: {
+        imagePath: string,
+    }) {
+        super();
+
+        this._imagePath = opts.imagePath;
+    }
+
+    /**
+     * Verify that all dependencies are installed
+     */
+    async init() {
+        this._image = await fs.promises.readFile(this._imagePath);
+    }
+
+    /**
+     * List all available cameras
+     */
+    async listDevices() {
+        return [ `Fake camera` ];
+    }
+
+    /**
+     * Start the capture process
+     * @param options Specify the camera, and the required interval between snapshots
+     */
+    async start(options: ICameraStartOptions) {
+        if (!this._image) {
+            throw new Error(`Camera was not initialized`);
+        }
+        if (this._timeout) {
+            clearInterval(this._timeout);
+        }
+
+        this._lastOptions = options;
+
+        this._timeout = setInterval(() => {
+            this.emit('snapshot', this._image!, `fake.jpg`);
+            // snapshotForInference() sends out the resized image
+            this.emit('snapshotForInference', {
+                imageForInferenceJpg: this._image!,
+                filename: 'fake.jpg',
+                imageFromCameraJpg: this._image!,
+                imageForInferenceRgb: undefined,
+            });
+        }, options.intervalMs === 0 ? 100 : options.intervalMs);
+    }
+
+    async stop() {
+        if (this._timeout) {
+            clearInterval(this._timeout);
+        }
+    }
+
+    getLastOptions() {
+        return this._lastOptions;
+    }
+}

library/sensors/sensors-helper.ts

@@ -4,11 +4,13 @@ import { Prophesee } from './prophesee';
 import { GStreamer } from './gstreamer';
 import { Imagesnap } from './imagesnap';
 import { AudioRecorder } from './recorder';
+import { FakeCamera } from './fake-camera';
 
 export enum CameraType {
     PropheseeCamera = 'prophesee',
     ImagesnapCamera = 'imagesnap',
     GStreamerCamera = 'gstreamer',
+    Fake = 'fake',
     UnknownCamera = 'unknown',
 }
 
@@ -25,13 +27,20 @@ export async function initCamera(opts: {
     profiling: boolean,
     preferJpegCaps: boolean,
     gstSource: string | undefined,
+    fakeImageCameraPath: string | undefined,
 }) {
     const { cameraType, cameraDeviceNameInConfig, dimensions, inferenceDimensions,
         gstLaunchArgs, verboseOutput, cameraColorFormat, gstSource } = opts;
     let { cameraNameArgv } = opts;
 
     let camera: ICamera;
-    if (cameraType === CameraType.PropheseeCamera) {
+    if (cameraType === CameraType.Fake) {
+        if (!opts.fakeImageCameraPath) {
+            throw new Error(`opts.fakeImageCameraPath is required for FakeCamera`);
+        }
+        camera = new FakeCamera({ imagePath: opts.fakeImageCameraPath });
+    }
+    else if (cameraType === CameraType.PropheseeCamera) {
         camera = new Prophesee(verboseOutput);
     }
     else if (cameraType === CameraType.ImagesnapCamera) {