@eyepop.ai/eyepop 0.20.1 → 0.21.0

package/dist/eyepop.index.d.ts

@@ -1,50 +1,18 @@
 import { Logger } from 'pino';
+import { Prediction as Prediction$1 } from '@eyepop.ai/eyepop';
 
 interface Session {
     readonly eyepopUrl: string;
-    readonly popId: string;
     readonly accessToken: string;
     readonly validUntil: number;
 }
-interface SessionPlus extends Session {
-    readonly baseUrl: string;
-    readonly pipelineId: string;
-    readonly sandboxId: string | undefined;
-}
 declare enum EndpointState {
     Idle = "Idle",
     Busy = "Busy",
     Authenticating = "Authenticating",
     FetchConfig = "FetchConfig",
-    StartingPop = "StartingPop",
     Error = "Error"
 }
-interface LiveMedia {
-    ingressId(): string;
-    stream(): Promise<MediaStream>;
-    close(): Promise<void>;
-}
-interface IngressEvent {
-    readonly ingressId: string;
-    readonly event: "stream-ready" | "stream-ready";
-}
-interface FileSource {
-    readonly file: File;
-}
-interface StreamSource {
-    readonly stream: ReadableStream<Uint8Array>;
-    readonly mimeType: string;
-}
-interface PathSource {
-    readonly path: string;
-}
-interface LiveSource {
-    readonly ingressId: string;
-}
-interface UrlSource {
-    readonly url: string;
-}
-type Source = FileSource | StreamSource | PathSource | LiveSource | UrlSource;
 interface Box {
     readonly topLeft: Point2d;
     readonly bottomRight: Point2d;
@@ -57,19 +25,19 @@ interface SourceParams {
     readonly roi: Roi | undefined;
 }
 interface StreamTime {
-    timestamp: number;
-    seconds: number;
-    offset: number;
+    timestamp?: number;
+    seconds?: number;
+    offset?: number;
 }
 interface Prediction extends StreamTime {
     source_width: number;
     source_height: number;
-    source_id: string;
-    objects: Array<PredictedObject>;
-    classes: Array<PredictedClass>;
-    labels: Array<PredictedLabel>;
-    meshs: Array<PredictedMesh>;
-    keyPoints: Array<PredictedKeyPoints>;
+    source_id?: string;
+    objects?: Array<PredictedObject>;
+    classes?: Array<PredictedClass>;
+    labels?: Array<PredictedLabel>;
+    meshs?: Array<PredictedMesh>;
+    keyPoints?: Array<PredictedKeyPoints>;
 }
 interface PredictedClass {
     id: number;
@@ -130,9 +98,6 @@ interface PredictedKeyPoints {
 interface PredictedKeyPoint extends Point3d, PredictedClass {
     visible: boolean | undefined;
 }
-interface ResultStream extends AsyncIterable<Prediction> {
-    cancel(): void;
-}
 
 interface Auth0Options {
     domain: string;
@@ -160,59 +125,222 @@ interface OAuth2Auth {
     oAuth2: true | Auth0Options;
 }
 type Authentication = undefined | SecretKeyAuth | SessionAuth | OAuth2Auth;
-declare enum TransientPopId {
-    Transient = "transient"
-}
 interface Options {
     auth?: Authentication | undefined;
-    /**
-     * Defaults to process.env['EYEPOP_POP_ID'].
-     */
-    popId?: string | TransientPopId | undefined;
     /**
      * Override the default base URL for the API, e.g., "https://api.eyepop.ai/"
      *
      * Defaults to process.env['EYEPOP_URL'].
      */
     eyepopUrl?: string;
-    autoStart?: boolean;
-    stopJobs?: boolean;
     jobQueueLength?: number;
     logger?: Logger | undefined;
 }
 
-declare class Endpoint {
-    private _options;
+interface HttpClient {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+}
+
+/** Semaphores are initialized with a number of permits that get aquired and released
+ * over the lifecycle of the semaphore. These permits limit the number of simultaneous
+ * executions of the code that the semaphore synchronizes. Functions can wait on a semaphore
+ * and stop executing until a permit becomes available.
+ *
+ * Locks are a special case of semaphores that only allow one execution of a critical section.
+ * If you need a lock, you can import the Lock class from this package.
+ *
+ * This Semaphore class is implemented with the help of promises that get returned
+ * by functions that wait for permits to become available. This makes it possible
+ * to use async/await to synchronize your code.
+ */
+declare class Semaphore {
+    private permits;
+    private promiseResolverQueue;
+    /**
+     * Creates a semaphore.
+     * @param permits  The number of permits, i.e. strands of execution being allowed
+     * to run in parallel.
+     * This number can be initialized with a negative integer.
+     */
+    constructor(permits: number);
+    /**
+     * Returns the number of available permits.
+     * @returns  The number of available permits.
+     */
+    getPermits(): number;
+    /**
+     * Returns a promise used to wait for a permit to become available. This method should be awaited on.
+     * @returns  A promise that gets resolved when execution is allowed to proceed.
+     */
+    wait(): Promise<boolean>;
+    /**
+     * Alias for {@linkcode Semaphore.wait}.
+     * @returns  A promise that gets resolved when execution is allowed to proceed.
+     */
+    acquire(): Promise<boolean>;
+    /**
+     * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
+     * permit becomes available in time.
+     * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
+     * you shouldn't rely on it being precise.
+     * @returns  A promise that gets resolved to true when execution is allowed to proceed or
+     * false if the time given elapses before a permit becomes available.
+     */
+    waitFor(milliseconds: number): Promise<boolean>;
+    /**
+     * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
+     * @returns  Whether a permit could be acquired.
+     */
+    tryAcquire(): boolean;
+    /**
+     * Acquires all permits that are currently available and returns the number of acquired permits.
+     * @returns  Number of acquired permits.
+     */
+    drainPermits(): number;
+    /**
+     * Increases the number of permits by one. If there are other functions waiting, one of them will
+     * continue to execute in a future iteration of the event loop.
+     */
+    signal(): void;
+    /**
+     * Alias for {@linkcode Semaphore.signal}.
+     */
+    release(): void;
+    /**
+     * Schedules func to be called once a permit becomes available.
+     * Returns a promise that resolves to the return value of func.
+     * @typeparam T  The return type of func.
+     * @param func  The function to be executed.
+     * @return  A promise that gets resolved with the return value of the function.
+     */
+    execute<T>(func: () => T | PromiseLike<T>): Promise<T>;
+}
+
+declare class Endpoint<T extends Endpoint<T>> {
+    protected _options: Options;
     private _token;
     private _expire_token_time;
+    protected _client: HttpClient | null;
+    private _statusRetryHandlers;
+    protected _limit: Semaphore;
+    private _state;
+    private _stateChangeHandler;
+    protected _logger: Logger;
+    protected readonly _requestLogger: Logger;
+    constructor(options: Options);
+    protected setStatusRetryHandlers(statusRetryHandlers?: Map<number, Function> | undefined): void;
+    eyepopUrl(): string;
+    pendingJobs(): number;
+    state(): EndpointState;
+    onStateChanged(handler: (fromState: EndpointState, toState: EndpointState) => void): T;
+    protected updateState(newState?: EndpointState | undefined): void;
+    connect(): Promise<T>;
+    disconnect(wait?: boolean): Promise<void>;
+    session(): Promise<Session>;
+    protected statusHandler401(statusCode: number): void;
+    protected fetchWithRetry(fetcher: () => Promise<Response>, retries?: number): Promise<Response>;
+    protected reconnect(): Promise<T>;
+    protected authorizationHeader(): Promise<string>;
+    private currentAccessToken;
+}
+
+declare enum TransientPopId {
+    Transient = "transient"
+}
+interface WorkerOptions extends Options {
+    /**
+     * Defaults to process.env['EYEPOP_POP_ID'].
+     */
+    popId?: string | TransientPopId | undefined;
+    isSandbox?: boolean;
+    autoStart?: boolean;
+    stopJobs?: boolean;
+}
+
+interface WorkerSession extends Session {
+    readonly popId: string;
+    readonly baseUrl: string | undefined;
+    readonly pipelineId: string | undefined;
+    readonly sandboxId: string | undefined;
+}
+interface LiveMedia {
+    ingressId(): string;
+    stream(): Promise<MediaStream>;
+    close(): Promise<void>;
+}
+interface IngressEvent {
+    readonly ingressId: string;
+    readonly event: "stream-ready" | "stream-ready";
+}
+interface FileSource {
+    readonly file: File;
+}
+interface StreamSource {
+    readonly stream: ReadableStream<Uint8Array>;
+    readonly mimeType: string;
+}
+interface PathSource {
+    readonly path: string;
+}
+interface LiveSource {
+    readonly ingressId: string;
+}
+interface UrlSource {
+    readonly url: string;
+}
+type Source = FileSource | StreamSource | PathSource | LiveSource | UrlSource;
+interface ResultStream extends AsyncIterable<Prediction> {
+    cancel(): void;
+}
+type SourcesEntry = {
+    readonly authority: string;
+    readonly manifest: string;
+};
+declare enum ModelFormat {
+    TensorFlowLite = "TensorFlowLite",
+    TensorFlowGraphDef = "TensorFlowGraphDef",
+    ONNX = "ONNX",
+    TorchScript = "TorchScript",
+    TorchScriptCpu = "TorchScriptCpu",
+    TorchScriptCuda = "TorchScriptCuda"
+}
+declare enum ModelPrecisionType {
+    float32 = "float32",
+    float16 = "float16",
+    int32 = "int32",
+    int8 = "int8",
+    uint8 = "uint8"
+}
+interface ModelInstanceDef {
+    id?: string;
+    model_id: string;
+    dataset: string;
+    version: string | undefined;
+    format: ModelFormat;
+    type: ModelPrecisionType;
+}
+
+declare class WorkerEndpoint extends Endpoint<WorkerEndpoint> {
     private _baseUrl;
     private _pipelineId;
     private _sandboxId;
     private _popName;
     private _pipeline;
-    private _client;
-    private _limit;
-    private _state;
-    private _stateChangeHandler;
     private _ingressEventHandler;
     private _ingressEventWs;
-    private _logger;
-    private readonly _requestLogger;
-    constructor(options: Options);
-    eyepopUrl(): string;
-    state(): EndpointState;
-    pendingJobs(): number;
+    constructor(options: WorkerOptions);
+    private options;
+    disconnect(wait?: boolean): Promise<void>;
+    protected statusHandler404(statusCode: number): void;
+    session(): Promise<WorkerSession>;
     popName(): string | null;
     popComp(): string | null;
     postTransform(): string | null;
     changePopComp(popComp: string): Promise<void>;
     changePostTransform(postTransform: string | null): Promise<void>;
     popId(): string | null;
-    onStateChanged(handler: (fromState: EndpointState, toState: EndpointState) => void): Endpoint;
-    onIngressEvent(handler: (event: IngressEvent) => void): Endpoint;
-    connect(): Promise<Endpoint>;
-    disconnect(wait?: boolean): Promise<void>;
-    session(): Promise<SessionPlus>;
+    onIngressEvent(handler: (event: IngressEvent) => void): WorkerEndpoint;
     liveIngress(stream: MediaStream): Promise<LiveMedia>;
     liveEgress(ingressId: string): Promise<LiveMedia>;
     process(source: Source, params?: SourceParams | undefined): Promise<ResultStream>;
@@ -223,17 +351,208 @@ declare class Endpoint {
     private loadFrom;
     private loadLiveIngress;
     private jobDone;
-    private updateState;
     private jobStatus;
-    private fetchWithRetry;
-    private reconnect;
-    private authorizationHeader;
-    private currentAccessToken;
+    protected reconnect(): Promise<WorkerEndpoint>;
     private startPopLessPipeline;
+    manifest(): Promise<SourcesEntry[]>;
+    models(): Promise<ModelInstanceDef[]>;
+    changeManifest(manifests: SourcesEntry[]): Promise<void>;
+    loadModel(model: ModelInstanceDef): Promise<ModelInstanceDef>;
+    unloadModel(modelId: string): Promise<void>;
+}
+
+interface DataOptions extends Options {
+    /**
+     * Defaults to process.env['EYEPOP_ACCOUNT_ID'].
+     */
+    accountId?: string | undefined;
+    disableWs?: boolean | undefined;
+}
+
+interface DataSession extends Session {
+    readonly accountId: string;
+    readonly baseUrl: string | undefined;
+}
+interface DatasetVersion {
+    version: number;
+    modifiable: boolean;
+    created_at: Date;
+    updated_at: Date;
+    asset_count: number;
+}
+interface Dataset {
+    uuid: string;
+    name: string;
+    description?: string;
+    auto_annotates: string[];
+    tags: string[];
+    account_uuid: string;
+    created_at: Date;
+    updated_at: Date;
+    versions: DatasetVersion[];
+}
+interface DatasetCreate {
+    name: string;
+    description?: string;
+    tags?: string[];
+    auto_annotates?: string[];
+}
+interface DatasetUpdate {
+    name: string;
+    description?: string;
+    tags?: string[];
+    auto_annotates?: string[];
+}
+declare enum AssetStatus {
+    rejected = "rejected",
+    upload_in_progress = "upload_in_progress",
+    upload_failed = "upload_failed",
+    transform_failed = "transform_failed",
+    transform_in_progress = "transform_in_progress",
+    accepted = "accepted"
+}
+declare enum AnnotationType {
+    manual = "manual",
+    prediction = "prediction",
+    auto = "auto"
+}
+declare enum UserReview {
+    approved = "approved",
+    rejected = "rejected",
+    unknown = "unknown"
+}
+interface Annotation {
+    type: AnnotationType;
+    user_review: UserReview;
+    auto_annotate?: string;
+    uncertainty_score?: number;
+    annotation: Prediction;
+}
+declare enum TranscodeMode {
+    original = "original",
+    image_original_size = "image_original_size",
+    image_fit_1024 = "image_fit_1024",
+    image_fit_640 = "image_fit_640",
+    image_fit_224 = "image_fit_224",
+    image_cover_1024 = "image_cover_1024",
+    image_cover_640 = "image_cover_640",
+    image_cover_224 = "image_cover_224"
+}
+interface Asset {
+    uuid: string;
+    mime_type: string;
+    file_size_bytes: number;
+    status: AssetStatus;
+    created_at: Date;
+    updated_at: Date;
+    annotations: Annotation[];
+}
+declare enum ModelType {
+    epdet_b1 = "epdet_b1"
+}
+declare enum ModelStatus {
+    error = "error",
+    draft = "draft",
+    requested = "requested",
+    in_progress = "in_progress",
+    available = "available",
+    published = "published"
+}
+interface Model {
+    uuid: string;
+    name: string;
+    description?: string;
+    type: ModelType;
+    status: ModelStatus;
+    account_uuid: string;
+    created_at: Date;
+    updated_at: Date;
+    dataset_uuid: string;
+    dataset_version: number;
+}
+interface ModelCreate {
+    name: string;
+    description?: string;
+    type: ModelType;
+}
+interface ModelUpdate {
+    name: string;
+    description?: string;
+}
+declare enum ChangeType {
+    dataset_added = "dataset_added",
+    dataset_removed = "dataset_removed",
+    dataset_modified = "dataset_modified",
+    dataset_version_modified = "dataset_version_modified",
+    asset_added = "asset_added",
+    asset_removed = "asset_removed",
+    asset_status_modified = "asset_status_modified",
+    asset_annotation_modified = "asset_annotation_modified",
+    model_added = "model_added",
+    model_removed = "model_removed",
+    model_modified = "model_modified",
+    model_status_modified = "model_status_modified"
+}
+interface ChangeEvent {
+    change_type: ChangeType;
+    account_uuid: string;
+    dataset_uuid: string;
+    dataset_version?: number;
+    asset_uuid?: string;
+    mdl_uuid?: string;
+}
+type OnChangeEvent = (event: ChangeEvent) => Promise<void>;
+
+declare class DataEndpoint extends Endpoint<DataEndpoint> {
+    private _baseUrl;
+    private _accountId;
+    private _ws;
+    private _ws_current_reconnect_delay;
+    private _account_event_handlers;
+    private _dataset_uuid_to_event_handlers;
+    constructor(options: DataOptions);
+    session(): Promise<DataSession>;
+    disconnect(wait?: boolean): Promise<void>;
+    protected reconnect(): Promise<DataEndpoint>;
+    private reconnect_ws;
+    private options;
+    private request;
+    listDatasets(): Promise<any>;
+    createDataset(data: DatasetCreate): Promise<Dataset>;
+    getDataset(dataset_uuid: string): Promise<Dataset>;
+    updateDataset(dataset_uuid: string, data: DatasetUpdate): Promise<Dataset>;
+    deleteDataset(dataset_uuid: string): Promise<void>;
+    freezeDatasetVersion(dataset_uuid: string, dataset_version?: number): Promise<Dataset>;
+    deleteDatasetVersion(dataset_uuid: string, dataset_version: number): Promise<Dataset>;
+    uploadAsset(dataset_uuid: string, dataset_version: number | undefined, blob: Blob): Promise<Asset>;
+    listAssets(dataset_uuid: string, dataset_version?: number, include_annotations?: boolean): Promise<Asset[]>;
+    getAsset(asset_uuid: string, dataset_uuid?: string, dataset_version?: number, include_annotations?: boolean): Promise<Asset>;
+    deleteAsset(asset_uuid: string, dataset_uuid?: string, dataset_version?: number): Promise<void>;
+    resurrectAsset(asset_uuid: string, dataset_uuid: string, from_dataset_version: number, into_dataset_version?: number): Promise<void>;
+    updateAssetManualAnnotation(asset_uuid: string, dataset_uuid?: string, dataset_version?: number, prediction?: Prediction$1): Promise<void>;
+    updateAutoAnnotationStatus(asset_uuid: string, auto_annotate: string, user_review: UserReview): Promise<void>;
+    downloadAsset(asset_uuid: string, dataset_uuid?: string, dataset_version?: number, transcode_mode?: TranscodeMode): Promise<Blob>;
+    listModels(): Promise<Model[]>;
+    createModel(dataset_uuid: string, dataset_version: number, data: ModelCreate): Promise<Model>;
+    getModel(model_uuid: string): Promise<Model>;
+    updateModel(model_uuid: string, data: ModelUpdate): Promise<Model>;
+    deleteModel(model_uuid: string): Promise<void>;
+    publishModel(model_uuid: string): Promise<Model>;
+    addAccountEventHandler(eventHandler: OnChangeEvent): void;
+    removeAccountEventHandler(eventHandler: OnChangeEvent): void;
+    addDatasetEventHandler(dataset_uuid: string, eventHandler: OnChangeEvent): void;
+    removeDatasetEventHandler(dataset_uuid: string, eventHandler: OnChangeEvent): void;
+    removeAllDatasetEventHandlers(dataset_uuid: string): void;
+    private dispatchChangeEvent;
 }
 
 declare namespace EyePop {
-    function endpoint(opts?: Options): Endpoint;
+    /**
+     * @deprecated use workerEndpoint() instead
+     */
+    const endpoint: typeof workerEndpoint;
+    function workerEndpoint(opts?: WorkerOptions): WorkerEndpoint;
+    function dataEndpoint(opts?: DataOptions): DataEndpoint;
 }
 
-export { type Contour, EndpointState, EyePop, type FileSource, type IngressEvent, type LiveMedia, type LiveSource, type PathSource, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type Session, type Source, type StreamSource, type StreamTime, type UrlSource, EyePop as default };
+export { type Annotation, AnnotationType, type Asset, AssetStatus, type Auth0Options, type Authentication, type ChangeEvent, ChangeType, type Contour, DataEndpoint, type DataOptions, type DataSession, type Dataset, type DatasetCreate, type DatasetUpdate, type DatasetVersion, EndpointState, EyePop, type FileSource, type IngressEvent, type LiveMedia, type LiveSource, type Model, type ModelCreate, ModelFormat, type ModelInstanceDef, ModelPrecisionType, ModelStatus, ModelType, type ModelUpdate, type OAuth2Auth, type OnChangeEvent, type Options, type PathSource, type Point2d, type Point3d, type PredictedClass, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedObject, type Prediction, type ResultStream, type SecretKeyAuth, type Session, type SessionAuth, type Source, type SourcesEntry, type StreamSource, type StreamTime, TranscodeMode, TransientPopId, type UrlSource, UserReview, WorkerEndpoint, type WorkerOptions, type WorkerSession, EyePop as default };