@mulingai-npm/redis 3.3.0 → 3.4.1

package/dist/loggers/mulingstream-chunk-logger.d.ts

@@ -7,6 +7,7 @@ export interface ChunkLogOptions {
     processLength?: boolean;
     finalTranscription?: boolean;
     sttStatus?: boolean;
+    audioFilePath?: boolean;
     stt?: boolean;
     translation?: boolean;
     tts?: boolean;

package/dist/loggers/mulingstream-chunk-logger.js

@@ -5,6 +5,7 @@ const mulingstream_chunk_manager_1 = require("../managers/mulingstream-chunk-man
 const defaults = {
     chunkId: false,
     chunkNumber: true,
+    audioFilePath: true,
     roomId: false,
     processLength: false,
     language: false,
@@ -61,6 +62,8 @@ class MulingstreamChunkLogger extends mulingstream_chunk_manager_1.MulingstreamC
             out.roomId = chunk.roomId;
         if (o.chunkNumber)
             out.chunkNumber = chunk.chunkNumber;
+        if (o.audioFilePath)
+            out.audioFilePath = chunk.audioChunk.audioFilePath;
         if (o.processLength)
             out.processLength = Date.now() - chunk.createdAt + 'ms';
         if (o.language)

package/dist/managers/mulingstream-chunk-manager.d.ts

@@ -42,7 +42,6 @@ export type MulingstreamChunkData = {
             ttsAudioPath: string;
             status: StepStatus;
             isEmitted: boolean;
-            totalCheck: number;
         };
     };
 };
@@ -72,43 +71,42 @@ export declare class MulingstreamChunkManager {
         sttProviders: SttProvider[];
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
-    }): Promise<void>;
+    }): Promise<MulingstreamChunkData>;
     private getChunkId;
     getMulingstreamChunkById(roomId: string, n: number): Promise<MulingstreamChunkData>;
     private withChunk;
-    updateAudioFilePath(roomId: string, n: number, audioFilePath: string): Promise<boolean>;
+    updateAudioFilePath(roomId: string, chunkNumber: number, audioFilePath: string): Promise<MulingstreamChunkData | null>;
     updateStt(roomId: string, n: number, service: SttService, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
-    }): Promise<boolean>;
+    }): Promise<MulingstreamChunkData | null>;
     updateSttObject(roomId: string, n: number, newStt: Record<string, {
         transcription: string;
         model?: string;
         status: StepStatus;
-    }>): Promise<boolean>;
-    discardStt(roomId: string, n: number): Promise<boolean>;
+    }>): Promise<MulingstreamChunkData | null>;
+    discardStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    updateSttAsUsed(roomId: string, chunkNumber: number): Promise<MulingstreamChunkData | null>;
     updateFinalTranscription(roomId: string, n: number, opt: {
         transcription?: string;
         sttStatus?: StepStatus;
-    }): Promise<MulingstreamChunkData>;
-    discardPostStt(roomId: string, n: number): Promise<boolean>;
-    discardLanguage(roomId: string, n: number, lang: string): Promise<boolean>;
+    }): Promise<MulingstreamChunkData | null>;
+    discardPostStt(roomId: string, n: number): Promise<MulingstreamChunkData | null>;
+    discardLanguage(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData | null>;
     discardLanguages(roomId: string, n: number, opt: {
         translation?: string[];
         tts?: string[];
-    }): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
     updateTranslation(roomId: string, n: number, lang: string, opt: {
         translation?: string;
         status?: StepStatus;
-    }): Promise<MulingstreamChunkData>;
-    updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
+    updateTranslationInBulk(roomId: string, n: number, dict: Record<string, string>, status?: StepStatus): Promise<MulingstreamChunkData | null>;
     updateTts(roomId: string, n: number, lang: string, opt: {
         ttsAudioPath?: string;
         status?: StepStatus;
         isEmitted?: boolean;
-        totalCheck?: number;
-    }): Promise<MulingstreamChunkData>;
-    increaseTotalCheck(roomId: string, n: number, lang: string): Promise<MulingstreamChunkData>;
+    }): Promise<MulingstreamChunkData | null>;
     areTranslationsProcessed(roomId: string, n: number): Promise<boolean>;
     getAllReadyTts(roomId: string, lang: string): Promise<MulingstreamChunkData[]>;
 }

package/dist/managers/mulingstream-chunk-manager.js

@@ -42,7 +42,7 @@ class MulingstreamChunkManager {
         };
     }
     getTimeout(start, end) {
-        return 30000;
+        return 25000;
     }
     async initRoom(roomId) {
         const exists = await this.redisClient.exists(this.roomZsetKey(roomId));
@@ -98,8 +98,25 @@ class MulingstreamChunkManager {
         const tts = {};
         shortCodeTargetLanguages.forEach((l) => {
             translation[l] = { translation: '', status: 'INIT' };
-            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false, totalCheck: 0 };
+            tts[l] = { ttsAudioPath: '', status: 'INIT', isEmitted: false };
         });
+        const createdAt = Date.now();
+        const chunk = {
+            chunkId,
+            roomId,
+            chunkNumber,
+            language,
+            sttProviders,
+            targetLanguages,
+            shortCodeTargetLanguages,
+            finalTranscription: '',
+            sttStatus: 'INIT',
+            createdAt,
+            audioChunk,
+            stt,
+            translation,
+            tts
+        };
         const hash = {
             chunkId,
             roomId,
@@ -110,7 +127,7 @@ class MulingstreamChunkManager {
             shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
             finalTranscription: '',
             sttStatus: 'INIT',
-            createdAt: String(Date.now()),
+            createdAt: String(createdAt),
             audioChunk: this.serialize(audioChunk),
             stt: this.serialize(stt),
             translation: this.serialize(translation),
@@ -133,6 +150,7 @@ class MulingstreamChunkManager {
             oldIds.forEach((cid) => trim.unlink(this.chunkHashKey(cid)));
             await trim.exec();
         }
+        return chunk;
     }
     async getChunkId(roomId, n) {
         const ids = await this.redisClient.zrangebyscore(this.roomZsetKey(roomId), n, n);
@@ -154,7 +172,7 @@ class MulingstreamChunkManager {
         if (!raw.chunkId)
             return null;
         const chunk = this.hashToChunk(raw);
-        const out = await fn(chunk);
+        await fn(chunk);
         const p = this.redisClient.pipeline();
         p.hset(key, {
             finalTranscription: chunk.finalTranscription,
@@ -166,41 +184,44 @@ class MulingstreamChunkManager {
         });
         p.expire(key, EXPIRATION);
         await p.exec();
-        return out;
+        return chunk;
     }
-    async updateAudioFilePath(roomId, n, audioFilePath) {
-        return ((await this.withChunk(roomId, n, (c) => {
-            c.audioChunk.audioFilePath = audioFilePath;
-            return true;
-        })) === true);
+    async updateAudioFilePath(roomId, chunkNumber, audioFilePath) {
+        return this.withChunk(roomId, chunkNumber, (chunk) => {
+            chunk.audioChunk.audioFilePath = audioFilePath;
+        });
     }
     async updateStt(roomId, n, service, opt) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             if (!c.stt[service])
-                return false;
+                return;
             if (opt.transcription !== undefined)
                 c.stt[service].transcription = opt.transcription;
             if (opt.sttStatus !== undefined)
                 c.stt[service].status = opt.sttStatus;
-            return true;
-        })) === true);
+        });
     }
     async updateSttObject(roomId, n, newStt) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             c.stt = newStt;
-            return true;
-        })) === true);
+        });
     }
     async discardStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             Object.keys(c.stt).forEach((p) => {
                 c.stt[p].transcription = '';
                 c.stt[p].status = 'DISCARDED';
             });
             c.finalTranscription = '';
             c.sttStatus = 'DISCARDED';
-            return true;
-        })) === true);
+        });
+    }
+    async updateSttAsUsed(roomId, chunkNumber) {
+        return this.withChunk(roomId, chunkNumber, (chunk) => {
+            Object.keys(chunk.stt).forEach((sttProvider) => {
+                chunk.stt[sttProvider].status = 'USED';
+            });
+        });
     }
     async updateFinalTranscription(roomId, n, opt) {
         return this.withChunk(roomId, n, (c) => {
@@ -208,24 +229,21 @@ class MulingstreamChunkManager {
                 c.finalTranscription = opt.transcription;
             if (opt.sttStatus !== undefined)
                 c.sttStatus = opt.sttStatus;
-            return c;
         });
     }
     async discardPostStt(roomId, n) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             Object.values(c.translation).forEach((t) => (t.status = 'DISCARDED'));
             Object.values(c.tts).forEach((t) => (t.status = 'DISCARDED'));
-            return true;
-        })) === true);
+        });
     }
     async discardLanguage(roomId, n, lang) {
-        return ((await this.withChunk(roomId, n, (c) => {
+        return this.withChunk(roomId, n, (c) => {
             if (c.translation[lang])
                 c.translation[lang].status = 'DISCARDED';
             if (c.tts[lang])
                 c.tts[lang].status = 'DISCARDED';
-            return true;
-        })) === true);
+        });
     }
     async discardLanguages(roomId, n, opt) {
         return this.withChunk(roomId, n, (c) => {
@@ -240,19 +258,17 @@ class MulingstreamChunkManager {
                 if (e && e.status === 'INIT')
                     e.status = 'DISCARDED';
             });
-            return c;
         });
     }
     async updateTranslation(roomId, n, lang, opt) {
         return this.withChunk(roomId, n, (c) => {
             const e = c.translation[lang];
             if (!e)
-                return null;
+                return;
             if (opt.translation !== undefined)
                 e.translation = opt.translation;
             if (opt.status !== undefined)
                 e.status = opt.status;
-            return c;
         });
     }
     async updateTranslationInBulk(roomId, n, dict, status = 'READY') {
@@ -263,31 +279,19 @@ class MulingstreamChunkManager {
                 c.translation[l].translation = txt;
                 c.translation[l].status = status;
             });
-            return c;
         });
     }
     async updateTts(roomId, n, lang, opt) {
         return this.withChunk(roomId, n, (c) => {
             const e = c.tts[lang];
             if (!e)
-                return null;
+                return;
             if (opt.ttsAudioPath !== undefined)
                 e.ttsAudioPath = opt.ttsAudioPath;
             if (opt.status !== undefined)
                 e.status = opt.status;
             if (opt.isEmitted !== undefined)
                 e.isEmitted = opt.isEmitted;
-            if (opt.totalCheck !== undefined)
-                e.totalCheck = opt.totalCheck;
-            return c;
-        });
-    }
-    async increaseTotalCheck(roomId, n, lang) {
-        return this.withChunk(roomId, n, (c) => {
-            if (!c.tts[lang])
-                return null;
-            c.tts[lang].totalCheck += 1;
-            return c;
         });
     }
     async areTranslationsProcessed(roomId, n) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mulingai-npm/redis",
-    "version": "3.3.0",
+    "version": "3.4.1",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {