react-native-executorch 0.4.8 → 0.5.0

package/src/constants/ocr/symbols.ts

@@ -19,130 +19,130 @@ export const alphabets = {
 };
 
 export const symbols = {
-  //Abaza
+  // Abaza
   abq: alphabets.cyrillic,
-  //Adyghe
+  // Adyghe
   ady: alphabets.cyrillic,
-  //Africans
+  // Africans
   af: alphabets.latin,
-  //Avar
+  // Avar
   ava: alphabets.cyrillic,
-  //Azerbaijani
+  // Azerbaijani
   az: alphabets.latin,
-  //Belarusian
+  // Belarusian
   be: alphabets.cyrillic,
-  //Bulgarian
+  // Bulgarian
   bg: alphabets.cyrillic,
-  //Bosnian
+  // Bosnian
   bs: alphabets.latin,
-  //Simplified Chinese
+  // Simplified Chinese
   chSim: alphabets.zhSim,
-  //Chechen
+  // Chechen
   che: alphabets.cyrillic,
-  //Czech
+  // Czech
   cs: alphabets.latin,
-  //Welsh
+  // Welsh
   cy: alphabets.latin,
-  //Danish
+  // Danish
   da: alphabets.latin,
-  //Dargwa
+  // Dargwa
   dar: alphabets.cyrillic,
-  //German
+  // German
   de: alphabets.latin,
-  //English
+  // English
   en: alphabets.english,
-  //Spanish
+  // Spanish
   es: alphabets.latin,
-  //Estonian
+  // Estonian
   et: alphabets.latin,
-  //French
+  // French
   fr: alphabets.latin,
-  //Irish
+  // Irish
   ga: alphabets.latin,
-  //Croatian
+  // Croatian
   hr: alphabets.latin,
-  //Hungarian
+  // Hungarian
   hu: alphabets.latin,
-  //Indonesian
+  // Indonesian
   id: alphabets.latin,
-  //Ingush
+  // Ingush
   inh: alphabets.cyrillic,
-  //Icelandic
+  // Icelandic
   ic: alphabets.latin,
-  //Italian
+  // Italian
   it: alphabets.latin,
-  //Japanese
+  // Japanese
   ja: alphabets.japanese,
-  //Karbadian
+  // Karbadian
   kbd: alphabets.cyrillic,
-  //Kannada
+  // Kannada
   kn: alphabets.kannada,
-  //Korean
+  // Korean
   ko: alphabets.korean,
-  //Kurdish
+  // Kurdish
   ku: alphabets.latin,
-  //Latin
+  // Latin
   la: alphabets.latin,
-  //Lak
+  // Lak
   lbe: alphabets.cyrillic,
-  //Lezghian
+  // Lezghian
   lez: alphabets.cyrillic,
-  //Lithuanian
+  // Lithuanian
   lt: alphabets.latin,
-  //Latvian
+  // Latvian
   lv: alphabets.latin,
-  //Maori
+  // Maori
   mi: alphabets.latin,
-  //Mongolian
+  // Mongolian
   mn: alphabets.cyrillic,
-  //Malay
+  // Malay
   ms: alphabets.latin,
-  //Maltese
+  // Maltese
   mt: alphabets.latin,
-  //Dutch
+  // Dutch
   nl: alphabets.latin,
-  //Norwegian
+  // Norwegian
   no: alphabets.latin,
-  //Occitan
+  // Occitan
   oc: alphabets.latin,
-  //Pali
+  // Pali
   pi: alphabets.latin,
-  //Polish
+  // Polish
   pl: alphabets.latin,
-  //Portuguese
+  // Portuguese
   pt: alphabets.latin,
-  //Romanian
+  // Romanian
   ro: alphabets.latin,
-  //Russian
+  // Russian
   ru: alphabets.cyrillic,
-  //Serbian (cyrillic)
+  // Serbian (cyrillic)
   rsCyrillic: alphabets.cyrillic,
-  //Serbian (latin)
+  // Serbian (latin)
   rsLatin: alphabets.latin,
-  //Slovak
+  // Slovak
   sk: alphabets.latin,
-  //Slovenian
+  // Slovenian
   sl: alphabets.latin,
-  //Albanian
+  // Albanian
   sq: alphabets.latin,
-  //Swedish
+  // Swedish
   sv: alphabets.latin,
-  //Swahili
+  // Swahili
   sw: alphabets.latin,
-  //Tabassaran
+  // Tabassaran
   tab: alphabets.cyrillic,
-  //Telugu
+  // Telugu
   te: alphabets.telugu,
-  //Tajik
+  // Tajik
   tjk: alphabets.cyrillic,
-  //Tagalog
+  // Tagalog
   tl: alphabets.latin,
-  //Turkish:
+  // Turkish
   tr: alphabets.latin,
-  //Ukrainian
+  // Ukrainian
   uk: alphabets.cyrillic,
-  //Uzbek
+  // Uzbek
   uz: alphabets.latin,
-  //Vietnamese
+  // Vietnamese
   vi: alphabets.latin,
 };

package/src/controllers/LLMController.ts

@@ -14,6 +14,7 @@ import {
 } from '../types/llm';
 import { LLMNativeModule } from '../native/RnExecutorchModules';
 import { parseToolCall } from '../utils/llm';
+import { Logger } from '../common/Logger';
 
 export class LLMController {
   private nativeModule: typeof LLMNativeModule;
@@ -32,9 +33,6 @@ export class LLMController {
   private messageHistoryCallback: (messageHistory: Message[]) => void;
   private isReadyCallback: (isReady: boolean) => void;
   private isGeneratingCallback: (isGenerating: boolean) => void;
-  private onDownloadProgressCallback:
-    | ((downloadProgress: number) => void)
-    | undefined;
 
   constructor({
     tokenCallback,
@@ -42,17 +40,15 @@ export class LLMController {
     messageHistoryCallback,
     isReadyCallback,
     isGeneratingCallback,
-    onDownloadProgressCallback,
   }: {
     tokenCallback?: (token: string) => void;
     responseCallback?: (response: string) => void;
     messageHistoryCallback?: (messageHistory: Message[]) => void;
     isReadyCallback?: (isReady: boolean) => void;
     isGeneratingCallback?: (isGenerating: boolean) => void;
-    onDownloadProgressCallback?: (downloadProgress: number) => void;
   }) {
     if (responseCallback !== undefined) {
-      console.warn(
+      Logger.warn(
         'Passing response callback is deprecated and will be removed in 0.6.0'
       );
     }
@@ -75,9 +71,6 @@ export class LLMController {
       this._isGenerating = isGenerating;
       isGeneratingCallback?.(isGenerating);
     };
-
-    this.onDownloadProgressCallback = onDownloadProgressCallback;
-
     this.nativeModule = LLMNativeModule;
   }
 
@@ -98,10 +91,12 @@ export class LLMController {
     modelSource,
     tokenizerSource,
     tokenizerConfigSource,
+    onDownloadProgressCallback,
   }: {
     modelSource: ResourceSource;
     tokenizerSource: ResourceSource;
     tokenizerConfigSource: ResourceSource;
+    onDownloadProgressCallback?: (downloadProgress: number) => void;
   }) {
     // reset inner state when loading new model
     this.responseCallback('');
@@ -110,20 +105,35 @@ export class LLMController {
     this.isReadyCallback(false);
 
     try {
-      const tokenizerFileUri = await ResourceFetcher.fetch(tokenizerSource);
-      const tokenizerConfigFileUri = await ResourceFetcher.fetch(
+      const tokenizersPromise = ResourceFetcher.fetch(
+        undefined,
+        tokenizerSource,
         tokenizerConfigSource
       );
-      this.tokenizerConfig = JSON.parse(
-        await readAsStringAsync('file://' + tokenizerConfigFileUri)
+
+      const modelPromise = ResourceFetcher.fetch(
+        onDownloadProgressCallback,
+        modelSource
       );
 
-      const modelFileUri = await ResourceFetcher.fetch(
-        modelSource,
-        this.onDownloadProgressCallback
+      const [tokenizersResults, modelResult] = await Promise.all([
+        tokenizersPromise,
+        modelPromise,
+      ]);
+
+      const tokenizerPath = tokenizersResults?.[0];
+      const tokenizerConfigPath = tokenizersResults?.[1];
+      const modelPath = modelResult?.[0];
+
+      if (!tokenizerPath || !tokenizerConfigPath || !modelPath) {
+        throw new Error('Download interrupted!');
+      }
+
+      this.tokenizerConfig = JSON.parse(
+        await readAsStringAsync('file://' + tokenizerConfigPath!)
       );
 
-      await this.nativeModule.loadLLM(modelFileUri, tokenizerFileUri);
+      await this.nativeModule.loadLLM(modelPath, tokenizerPath);
       this.isReadyCallback(true);
       this.onToken = this.nativeModule.onToken((data: string) => {
         if (
@@ -209,7 +219,7 @@ export class LLMController {
       throw new Error(`Empty 'messages' array!`);
     }
     if (messages[0] && messages[0].role !== 'system') {
-      console.warn(
+      Logger.warn(
         `You are not providing system prompt. You can pass it in the first message using { role: 'system', content: YOUR_PROMPT }. Otherwise prompt from your model's chat template will be used.`
       );
     }

package/src/controllers/OCRController.ts

@@ -1,41 +1,37 @@
 import { symbols } from '../constants/ocr/symbols';
 import { ETError, getError } from '../Error';
-import { OCRNativeModule } from '../native/RnExecutorchModules';
 import { ResourceSource } from '../types/common';
 import { OCRLanguage } from '../types/ocr';
 import { ResourceFetcher } from '../utils/ResourceFetcher';
 
 export class OCRController {
-  private nativeModule: typeof OCRNativeModule;
+  private nativeModule: any;
   public isReady: boolean = false;
   public isGenerating: boolean = false;
   public error: string | null = null;
-  private modelDownloadProgressCallback: (downloadProgress: number) => void;
   private isReadyCallback: (isReady: boolean) => void;
   private isGeneratingCallback: (isGenerating: boolean) => void;
   private errorCallback: (error: string) => void;
 
   constructor({
-    modelDownloadProgressCallback = (_downloadProgress: number) => {},
     isReadyCallback = (_isReady: boolean) => {},
     isGeneratingCallback = (_isGenerating: boolean) => {},
     errorCallback = (_error: string) => {},
-  }) {
-    this.nativeModule = OCRNativeModule;
-    this.modelDownloadProgressCallback = modelDownloadProgressCallback;
+  } = {}) {
     this.isReadyCallback = isReadyCallback;
     this.isGeneratingCallback = isGeneratingCallback;
     this.errorCallback = errorCallback;
   }
 
-  public loadModel = async (
+  public load = async (
     detectorSource: ResourceSource,
     recognizerSources: {
       recognizerLarge: ResourceSource;
       recognizerMedium: ResourceSource;
       recognizerSmall: ResourceSource;
     },
-    language: OCRLanguage
+    language: OCRLanguage,
+    onDownloadProgressCallback?: (downloadProgress: number) => void
   ) => {
     try {
       if (!detectorSource || Object.keys(recognizerSources).length !== 3)
@@ -48,22 +44,23 @@ export class OCRController {
       this.isReady = false;
       this.isReadyCallback(false);
 
-      const paths = await ResourceFetcher.fetchMultipleResources(
-        this.modelDownloadProgressCallback,
+      const paths = await ResourceFetcher.fetch(
+        onDownloadProgressCallback,
         detectorSource,
         recognizerSources.recognizerLarge,
         recognizerSources.recognizerMedium,
         recognizerSources.recognizerSmall
       );
-
-      await this.nativeModule.loadModule(
+      if (paths === null || paths?.length < 4) {
+        throw new Error('Download interrupted!');
+      }
+      this.nativeModule = global.loadOCR(
         paths[0]!,
         paths[1]!,
         paths[2]!,
         paths[3]!,
         symbols[language]
       );
-
       this.isReady = true;
       this.isReadyCallback(this.isReady);
     } catch (e) {
@@ -86,7 +83,7 @@ export class OCRController {
     try {
       this.isGenerating = true;
       this.isGeneratingCallback(this.isGenerating);
-      return await this.nativeModule.forward(input);
+      return await this.nativeModule.generate(input);
     } catch (e) {
       throw new Error(getError(e));
     } finally {
@@ -94,4 +91,16 @@ export class OCRController {
       this.isGeneratingCallback(this.isGenerating);
     }
   };
+
+  public delete() {
+    if (this.isGenerating) {
+      throw new Error(
+        getError(ETError.ModelGenerating) +
+          'You cannot delete the model. You must wait until the generating is finished.'
+      );
+    }
+    this.nativeModule.unload();
+    this.isReadyCallback(false);
+    this.isGeneratingCallback(false);
+  }
 }

package/src/controllers/VerticalOCRController.ts

@@ -1,34 +1,29 @@
 import { symbols } from '../constants/ocr/symbols';
 import { ETError, getError } from '../Error';
-import { VerticalOCRNativeModule } from '../native/RnExecutorchModules';
 import { ResourceSource } from '../types/common';
 import { OCRLanguage } from '../types/ocr';
 import { ResourceFetcher } from '../utils/ResourceFetcher';
 
 export class VerticalOCRController {
-  private ocrNativeModule: typeof VerticalOCRNativeModule;
+  private ocrNativeModule: any;
   public isReady: boolean = false;
   public isGenerating: boolean = false;
   public error: string | null = null;
-  private modelDownloadProgressCallback: (downloadProgress: number) => void;
   private isReadyCallback: (isReady: boolean) => void;
   private isGeneratingCallback: (isGenerating: boolean) => void;
   private errorCallback: (error: string) => void;
 
   constructor({
-    modelDownloadProgressCallback = (_downloadProgress: number) => {},
     isReadyCallback = (_isReady: boolean) => {},
     isGeneratingCallback = (_isGenerating: boolean) => {},
     errorCallback = (_error: string) => {},
-  }) {
-    this.ocrNativeModule = VerticalOCRNativeModule;
-    this.modelDownloadProgressCallback = modelDownloadProgressCallback;
+  } = {}) {
     this.isReadyCallback = isReadyCallback;
     this.isGeneratingCallback = isGeneratingCallback;
     this.errorCallback = errorCallback;
   }
 
-  public loadModel = async (
+  public load = async (
     detectorSources: {
       detectorLarge: ResourceSource;
       detectorNarrow: ResourceSource;
@@ -38,7 +33,8 @@ export class VerticalOCRController {
       recognizerSmall: ResourceSource;
     },
     language: OCRLanguage,
-    independentCharacters: boolean
+    independentCharacters: boolean,
+    onDownloadProgressCallback: (downloadProgress: number) => void
   ) => {
     try {
       if (
@@ -54,16 +50,18 @@ export class VerticalOCRController {
       this.isReady = false;
       this.isReadyCallback(this.isReady);
 
-      const paths = await ResourceFetcher.fetchMultipleResources(
-        this.modelDownloadProgressCallback,
+      const paths = await ResourceFetcher.fetch(
+        onDownloadProgressCallback,
         detectorSources.detectorLarge,
         detectorSources.detectorNarrow,
         independentCharacters
           ? recognizerSources.recognizerSmall
           : recognizerSources.recognizerLarge
       );
-
-      await this.ocrNativeModule.loadModule(
+      if (paths === null || paths.length < 3) {
+        throw new Error('Download interrupted');
+      }
+      this.ocrNativeModule = global.loadVerticalOCR(
         paths[0]!,
         paths[1]!,
         paths[2]!,
@@ -93,7 +91,7 @@ export class VerticalOCRController {
     try {
       this.isGenerating = true;
       this.isGeneratingCallback(this.isGenerating);
-      return await this.ocrNativeModule.forward(input);
+      return await this.ocrNativeModule.generate(input);
     } catch (e) {
       throw new Error(getError(e));
     } finally {
@@ -101,4 +99,16 @@ export class VerticalOCRController {
       this.isGeneratingCallback(this.isGenerating);
     }
   };
+
+  public delete() {
+    if (this.isGenerating) {
+      throw new Error(
+        getError(ETError.ModelGenerating) +
+          'You cannot delete the model. You must wait until the generating is finished.'
+      );
+    }
+    this.ocrNativeModule.unload();
+    this.isReadyCallback(false);
+    this.isGeneratingCallback(false);
+  }
 }

package/src/hooks/computer_vision/useClassification.ts

@@ -1,16 +1,15 @@
-import { ClassificationModule } from '../../modules/computer_vision/ClassificationModule';
 import { ResourceSource } from '../../types/common';
-import { useModule } from '../useModule';
+import { useNonStaticModule } from '../useNonStaticModule';
+import { ClassificationModule } from '../../modules/computer_vision/ClassificationModule';
 
-export const useClassification = ({
-  modelSource,
-  preventLoad = false,
-}: {
-  modelSource: ResourceSource;
+interface Props {
+  model: { modelSource: ResourceSource };
   preventLoad?: boolean;
-}) =>
-  useModule({
+}
+
+export const useClassification = ({ model, preventLoad = false }: Props) =>
+  useNonStaticModule({
     module: ClassificationModule,
-    loadArgs: [modelSource],
-    preventLoad,
+    model,
+    preventLoad: preventLoad,
   });

package/src/hooks/computer_vision/useImageEmbeddings.ts

@@ -0,0 +1,15 @@
+import { ImageEmbeddingsModule } from '../../modules/computer_vision/ImageEmbeddingsModule';
+import { ResourceSource } from '../../types/common';
+import { useNonStaticModule } from '../useNonStaticModule';
+
+interface Props {
+  model: { modelSource: ResourceSource };
+  preventLoad?: boolean;
+}
+
+export const useImageEmbeddings = ({ model, preventLoad = false }: Props) =>
+  useNonStaticModule({
+    module: ImageEmbeddingsModule,
+    model,
+    preventLoad,
+  });

package/src/hooks/computer_vision/useImageSegmentation.ts

@@ -1,18 +1,15 @@
-import { useModule } from '../useModule';
+import { useNonStaticModule } from '../useNonStaticModule';
 import { ImageSegmentationModule } from '../../modules/computer_vision/ImageSegmentationModule';
 import { ResourceSource } from '../../types/common';
 
 interface Props {
-  modelSource: ResourceSource;
+  model: { modelSource: ResourceSource };
   preventLoad?: boolean;
 }
 
-export const useImageSegmentation = ({
-  modelSource,
-  preventLoad = false,
-}: Props) =>
-  useModule({
+export const useImageSegmentation = ({ model, preventLoad = false }: Props) =>
+  useNonStaticModule({
     module: ImageSegmentationModule,
-    loadArgs: [modelSource],
+    model,
     preventLoad,
   });

package/src/hooks/computer_vision/useOCR.ts

@@ -12,18 +12,16 @@ interface OCRModule {
 }
 
 export const useOCR = ({
-  detectorSource,
-  recognizerSources,
-  language = 'en',
+  model,
   preventLoad = false,
 }: {
-  detectorSource: ResourceSource;
-  recognizerSources: {
+  model: {
+    detectorSource: ResourceSource;
     recognizerLarge: ResourceSource;
     recognizerMedium: ResourceSource;
     recognizerSmall: ResourceSource;
+    language: OCRLanguage;
   };
-  language?: OCRLanguage;
   preventLoad?: boolean;
 }): OCRModule => {
   const [error, setError] = useState<string | null>(null);
@@ -31,10 +29,9 @@ export const useOCR = ({
   const [isGenerating, setIsGenerating] = useState(false);
   const [downloadProgress, setDownloadProgress] = useState(0);
 
-  const model = useMemo(
+  const controllerInstance = useMemo(
     () =>
       new OCRController({
-        modelDownloadProgressCallback: setDownloadProgress,
         isReadyCallback: setIsReady,
         isGeneratingCallback: setIsGenerating,
         errorCallback: setError,
@@ -43,20 +40,31 @@ export const useOCR = ({
   );
 
   useEffect(() => {
-    const loadModel = async () => {
-      await model.loadModel(detectorSource, recognizerSources, language);
-    };
+    if (preventLoad) return;
+
+    (async () => {
+      await controllerInstance.load(
+        model.detectorSource,
+        {
+          recognizerLarge: model.recognizerLarge,
+          recognizerMedium: model.recognizerMedium,
+          recognizerSmall: model.recognizerSmall,
+        },
+        model.language,
+        setDownloadProgress
+      );
+    })();
 
-    if (!preventLoad) {
-      loadModel();
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    return () => {
+      controllerInstance.delete();
+    };
   }, [
-    model,
-    detectorSource,
-    language,
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    JSON.stringify(recognizerSources),
+    controllerInstance,
+    model.detectorSource,
+    model.recognizerLarge,
+    model.recognizerMedium,
+    model.recognizerSmall,
+    model.language,
     preventLoad,
   ]);
 
@@ -64,7 +72,7 @@ export const useOCR = ({
     error,
     isReady,
     isGenerating,
-    forward: model.forward,
+    forward: controllerInstance.forward,
     downloadProgress,
   };
 };

package/src/hooks/computer_vision/useObjectDetection.ts

@@ -1,18 +1,15 @@
 import { ResourceSource } from '../../types/common';
-import { useModule } from '../useModule';
+import { useNonStaticModule } from '../useNonStaticModule';
 import { ObjectDetectionModule } from '../../modules/computer_vision/ObjectDetectionModule';
 
 interface Props {
-  modelSource: ResourceSource;
+  model: { modelSource: ResourceSource };
   preventLoad?: boolean;
 }
 
-export const useObjectDetection = ({
-  modelSource,
-  preventLoad = false,
-}: Props) =>
-  useModule({
+export const useObjectDetection = ({ model, preventLoad = false }: Props) =>
+  useNonStaticModule({
     module: ObjectDetectionModule,
-    loadArgs: [modelSource],
-    preventLoad,
+    model,
+    preventLoad: preventLoad,
   });