edge-impulse-api 1.22.1 → 1.22.2

package/build/library/sdk/api/dSPApi.d.ts

@@ -0,0 +1,306 @@
+/**
+ * Edge Impulse API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/// <reference types="node" />
+import { DSPConfigRequest } from '../model/dSPConfigRequest';
+import { DSPConfigResponse } from '../model/dSPConfigResponse';
+import { DSPMetadataResponse } from '../model/dSPMetadataResponse';
+import { DspAutotunerResults } from '../model/dspAutotunerResults';
+import { DspFeatureImportanceResponse } from '../model/dspFeatureImportanceResponse';
+import { DspFeatureLabelsResponse } from '../model/dspFeatureLabelsResponse';
+import { DspPerformanceAllVariantsResponse } from '../model/dspPerformanceAllVariantsResponse';
+import { DspRunRequestWithFeatures } from '../model/dspRunRequestWithFeatures';
+import { DspRunRequestWithoutFeatures } from '../model/dspRunRequestWithoutFeatures';
+import { DspRunRequestWithoutFeaturesReadOnly } from '../model/dspRunRequestWithoutFeaturesReadOnly';
+import { DspRunResponse } from '../model/dspRunResponse';
+import { DspRunResponseWithSample } from '../model/dspRunResponseWithSample';
+import { DspSampleFeaturesResponse } from '../model/dspSampleFeaturesResponse';
+import { DspTrainedFeaturesResponse } from '../model/dspTrainedFeaturesResponse';
+import { GenericApiResponse } from '../model/genericApiResponse';
+import { GetSampleResponse } from '../model/getSampleResponse';
+import { StartJobResponse } from '../model/startJobResponse';
+import { Authentication } from '../model/models';
+import { ApiKeyAuth } from '../model/models';
+export declare enum DSPApiApiKeys {
+    ApiKeyAuthentication = 0,
+    JWTAuthentication = 1,
+    JWTHttpHeaderAuthentication = 2
+}
+declare type downloadDspDataQueryParams = {
+    raw?: boolean;
+};
+declare type dspSampleTrainedFeaturesQueryParams = {
+    featureAx1: number;
+    featureAx2: number;
+    featureAx3: number;
+};
+declare type getDspRawSampleQueryParams = {
+    limitPayloadValues?: number;
+};
+declare type getDspSampleSliceQueryParams = {
+    sliceStart: number;
+    sliceEnd: number;
+};
+declare type runDspSampleSliceQueryParams = {
+    sliceStart: number;
+    sliceEnd: number;
+};
+declare type runDspSampleSliceReadOnlyQueryParams = {
+    sliceStart: number;
+    sliceEnd: number;
+};
+export declare type DSPApiOpts = {
+    extraHeaders?: {
+        [name: string]: string;
+    };
+};
+export declare class DSPApi {
+    protected _basePath: string;
+    protected defaultHeaders: any;
+    protected _useQuerystring: boolean;
+    protected _opts: DSPApiOpts;
+    protected authentications: {
+        default: Authentication;
+        ApiKeyAuthentication: ApiKeyAuth;
+        JWTAuthentication: ApiKeyAuth;
+        JWTHttpHeaderAuthentication: ApiKeyAuth;
+    };
+    constructor(basePath?: string, opts?: DSPApiOpts);
+    set useQuerystring(value: boolean);
+    set basePath(basePath: string);
+    get basePath(): string;
+    set opts(opts: DSPApiOpts);
+    get opts(): DSPApiOpts;
+    setDefaultAuthentication(auth: Authentication): void;
+    setApiKey(key: DSPApiApiKeys, value: string | undefined): void;
+    /**
+     * Clear generated features for a DSP block (used in tests).
+     * @summary Clear DSP block
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    clearDspBlock(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<GenericApiResponse>;
+    /**
+     * Download output from a DSP block over all data in the training set, already sliced in windows. In Numpy binary format.
+     * @summary Download DSP data
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param category Which of the three acquisition categories to download data from
+     * @param raw Whether to download raw data or processed data. Processed data is the default.
+     */
+    downloadDspData(projectId: number, dspId: number, category: 'training' | 'testing' | 'anomaly', queryParams: downloadDspDataQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<Buffer>;
+    /**
+     * Download labels for a DSP block over all data in the training set, already sliced in windows.
+     * @summary Download DSP labels
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param category Which of the three acquisition categories to download data from
+     */
+    downloadDspLabels(projectId: number, dspId: number, category: 'training' | 'testing' | 'anomaly', options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<Buffer>;
+    /**
+     * Runs the DSP block against a sample. This will move the sliding window (dependent on the sliding window length and the sliding window increase parameters in the impulse) over the complete file, and run the DSP function for every window that is extracted.
+     * @summary Features for sample
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param sampleId Sample ID
+     */
+    dspGetFeaturesForSample(projectId: number, dspId: number, sampleId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspSampleFeaturesResponse>;
+    /**
+     * Get a sample of trained features, this extracts a number of samples and their labels. Used to visualize the current training set.
+     * @summary Sample of trained features
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param featureAx1 Feature axis 1
+     * @param featureAx2 Feature axis 2
+     * @param featureAx3 Feature axis 3
+     * @param category Which of the three acquisition categories to download data from
+     */
+    dspSampleTrainedFeatures(projectId: number, dspId: number, category: 'training' | 'testing' | 'anomaly', queryParams: dspSampleTrainedFeaturesQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspTrainedFeaturesResponse>;
+    /**
+     * Get a set of parameters, found as a result of running the DSP autotuner.
+     * @summary Get results from DSP autotuner
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getAutotunerResults(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspAutotunerResults>;
+    /**
+     * Retrieve the configuration parameters for the DSP block. Use the impulse functions to retrieve all DSP blocks.
+     * @summary Get config
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getDspConfig(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DSPConfigResponse>;
+    /**
+     * Retrieve the feature importance for a DSP block (only available for blocks where dimensionalityReduction is not enabled)
+     * @summary Feature importance
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getDspFeatureImportance(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspFeatureImportanceResponse>;
+    /**
+     * Retrieve the names of the features the DSP block generates
+     * @summary Feature labels
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getDspFeatureLabels(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspFeatureLabelsResponse>;
+    /**
+     * Retrieve the metadata from a generated DSP block.
+     * @summary Get metadata
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getDspMetadata(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DSPMetadataResponse>;
+    /**
+     * Get raw sample data, but with only the axes selected by the DSP block. E.g. if you have selected only accX and accY as inputs for the DSP block, but the raw sample also contains accZ, accZ is filtered out. If you pass dspId = 0 this will return a raw graph without any processing.
+     * @summary Get raw sample
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param sampleId Sample ID
+     * @param limitPayloadValues Limit the number of payload values in the response
+     */
+    getDspRawSample(projectId: number, dspId: number, sampleId: number, queryParams: getDspRawSampleQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<GetSampleResponse>;
+    /**
+     * Get slice of raw sample data, but with only the axes selected by the DSP block. E.g. if you have selected only accX and accY as inputs for the DSP block, but the raw sample also contains accZ, accZ is filtered out.
+     * @summary Get raw sample (slice)
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param sampleId Sample ID
+     * @param sliceStart Begin index of the slice
+     * @param sliceEnd End index of the slice
+     */
+    getDspSampleSlice(projectId: number, dspId: number, sampleId: number, queryParams: getDspSampleSliceQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<GetSampleResponse>;
+    /**
+     * Get estimated performance (latency and RAM) for the DSP block, for all supported project latency devices.
+     * @summary Get DSP block performance for all latency devices
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     */
+    getPerformanceAllVariants(projectId: number, dspId: number, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspPerformanceAllVariantsResponse>;
+    /**
+     * Takes in a features array and runs it through the DSP block. This data should have the same frequency as set in the input block in your impulse.
+     * @summary Get processed sample (from features array)
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param dspRunRequestWithFeatures
+     */
+    runDspOnFeaturesArray(projectId: number, dspId: number, dspRunRequestWithFeatures: DspRunRequestWithFeatures, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspRunResponse>;
+    /**
+     * Get slice of sample data, and run it through the DSP block. This only the axes selected by the DSP block. E.g. if you have selected only accX and accY as inputs for the DSP block, but the raw sample also contains accZ, accZ is filtered out.
+     * @summary Get processed sample (slice)
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param sampleId Sample ID
+     * @param sliceStart Begin index of the slice
+     * @param sliceEnd End index of the slice
+     * @param dspRunRequestWithoutFeatures
+     */
+    runDspSampleSlice(projectId: number, dspId: number, sampleId: number, dspRunRequestWithoutFeatures: DspRunRequestWithoutFeatures, queryParams: runDspSampleSliceQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspRunResponseWithSample>;
+    /**
+     * Get slice of sample data, and run it through the DSP block. This only the axes selected by the DSP block. E.g. if you have selected only accX and accY as inputs for the DSP block, but the raw sample also contains accZ, accZ is filtered out.
+     * @summary Get processed sample (slice)
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param sampleId Sample ID
+     * @param sliceStart Begin index of the slice
+     * @param sliceEnd End index of the slice
+     */
+    runDspSampleSliceReadOnly(projectId: number, dspId: number, sampleId: number, queryParams: runDspSampleSliceReadOnlyQueryParams, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<DspRunResponseWithSample>;
+    /**
+     * Set configuration parameters for the DSP block. Only values set in the body will be overwritten.
+     * @summary Set config
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param dSPConfigRequest
+     */
+    setDspConfig(projectId: number, dspId: number, dSPConfigRequest: DSPConfigRequest, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<GenericApiResponse>;
+    /**
+     * Returns performance characteristics for a custom DSP block (needs `hasTfliteImplementation`). Updates are streamed over the websocket API (or can be retrieved through the /stdout endpoint). Use getProfileTfliteJobResult to get the results when the job is completed.
+     * @summary Profile custom DSP block
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param dspRunRequestWithoutFeaturesReadOnly
+     */
+    startProfileCustomDspBlock(projectId: number, dspId: number, dspRunRequestWithoutFeaturesReadOnly: DspRunRequestWithoutFeaturesReadOnly, options?: {
+        headers: {
+            [name: string]: string;
+        };
+    }): Promise<StartJobResponse>;
+}
+export {};

package/build/library/sdk/api/dSPApi.js

@@ -1185,6 +1185,91 @@ class DSPApi {
             });
         });
     }
+    /**
+     * Takes in a features array and runs it through the DSP block. This data should have the same frequency as set in the input block in your impulse.
+     * @summary Get processed sample (from features array)
+     * @param projectId Project ID
+     * @param dspId DSP Block ID, use the impulse functions to retrieve the ID
+     * @param dspRunRequestWithFeatures
+     */
+    async runDspOnFeaturesArray(projectId, dspId, dspRunRequestWithFeatures, options = { headers: {} }) {
+        const localVarPath = this.basePath + '/api/{projectId}/dsp/{dspId}/run'
+            .replace('{' + 'projectId' + '}', encodeURIComponent(String(projectId)))
+            .replace('{' + 'dspId' + '}', encodeURIComponent(String(dspId)));
+        let localVarQueryParameters = {};
+        let localVarHeaderParams = Object.assign({
+            'User-Agent': 'edgeimpulse-api nodejs'
+        }, this.defaultHeaders);
+        const produces = ['application/json'];
+        // give precedence to 'application/json'
+        if (produces.indexOf('application/json') >= 0) {
+            localVarHeaderParams.Accept = 'application/json';
+        }
+        else {
+            localVarHeaderParams.Accept = produces.join(',');
+        }
+        let localVarFormParams = {};
+        // verify required parameter 'projectId' is not null or undefined
+        if (projectId === null || projectId === undefined) {
+            throw new Error('Required parameter projectId was null or undefined when calling runDspOnFeaturesArray.');
+        }
+        // verify required parameter 'dspId' is not null or undefined
+        if (dspId === null || dspId === undefined) {
+            throw new Error('Required parameter dspId was null or undefined when calling runDspOnFeaturesArray.');
+        }
+        // verify required parameter 'dspRunRequestWithFeatures' is not null or undefined
+        if (dspRunRequestWithFeatures === null || dspRunRequestWithFeatures === undefined) {
+            throw new Error('Required parameter dspRunRequestWithFeatures was null or undefined when calling runDspOnFeaturesArray.');
+        }
+        Object.assign(localVarHeaderParams, options.headers);
+        Object.assign(localVarHeaderParams, this.opts.extraHeaders);
+        let localVarUseFormData = false;
+        let localVarRequestOptions = {
+            method: 'POST',
+            qs: localVarQueryParameters,
+            headers: localVarHeaderParams,
+            uri: localVarPath,
+            useQuerystring: this._useQuerystring,
+            agentOptions: { keepAlive: false },
+            json: true,
+            body: models_1.ObjectSerializer.serialize(dspRunRequestWithFeatures, "DspRunRequestWithFeatures")
+        };
+        let authenticationPromise = Promise.resolve();
+        authenticationPromise = authenticationPromise.then(() => this.authentications.ApiKeyAuthentication.applyToRequest(localVarRequestOptions));
+        authenticationPromise = authenticationPromise.then(() => this.authentications.JWTAuthentication.applyToRequest(localVarRequestOptions));
+        authenticationPromise = authenticationPromise.then(() => this.authentications.JWTHttpHeaderAuthentication.applyToRequest(localVarRequestOptions));
+        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
+        return authenticationPromise.then(() => {
+            if (Object.keys(localVarFormParams).length) {
+                if (localVarUseFormData) {
+                    localVarRequestOptions.formData = localVarFormParams;
+                }
+                else {
+                    localVarRequestOptions.form = localVarFormParams;
+                }
+            }
+            return new Promise((resolve, reject) => {
+                localVarRequest(localVarRequestOptions, (error, response, body) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        body = models_1.ObjectSerializer.deserialize(body, "DspRunResponse");
+                        const errString = `Failed to call "${localVarPath}", returned ${response.statusCode}: ` + response.body;
+                        if (typeof body.success === 'boolean' && !body.success) {
+                            reject(new Error(body.error || errString));
+                        }
+                        else if (response.statusCode && response.statusCode >= 200 && response.statusCode <= 299) {
+                            resolve(body);
+                        }
+                        else {
+                            reject(errString);
+                        }
+                    }
+                });
+            });
+        });
+    }
     /**
      * Get slice of sample data, and run it through the DSP block. This only the axes selected by the DSP block. E.g. if you have selected only accX and accY as inputs for the DSP block, but the raw sample also contains accZ, accZ is filtered out.
      * @summary Get processed sample (slice)