srcrr/translation-terrace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: srcrr:dca3987e18efcf477b40e4db0665f5bb489d8759
Branches Tags
srcrr:dev
srcrr:dev-whisper-android
srcrr:dev-whisper-assets
..
compare: srcrr:361659289610baceaff3c1d24f4cfc82f3971da7
Branches Tags
srcrr:dev-whisper-android
srcrr:dev-whisper-assets
srcrr:dev

No commits in common. "dca3987e18efcf477b40e4db0665f5bb489d8759" and "361659289610baceaff3c1d24f4cfc82f3971da7" have entirely different histories.
dca3987e18 ... 3616592896

15 changed files with 430 additions and 504 deletions
Show Stats Expand all files Collapse all files

3
__mocks__/db.ts
View File

@ -1,8 +1,7 @@
export default { export default {
getDb: jest.fn(() => { getDb: jest.fn(() => {
return { return {
runAsync: jest.fn((statement: string, ... values: string []) => {}), runAsync: jest.fn((statement: string, value: string) => {}),
runSync: jest.fn((statement: string, ... values : string []) => {}),
getFirstAsync: jest.fn((statement: string, value: string) => { getFirstAsync: jest.fn((statement: string, value: string) => {
return []; return [];
}), }),

222
app/i18n/api.ts
View File

@ -1,155 +1,123 @@
import { Cache } from "react-native-cache"; import { Cache } from "react-native-cache";
import { LIBRETRANSLATE_BASE_URL } from "@/constants/api"; import { LIBRETRANSLATE_BASE_URL } from "@/constants/api";
import AsyncStorage from "@react-native-async-storage/async-storage"; import AsyncStorage from '@react-native-async-storage/async-storage';
import { Settings } from "../lib/settings"; import { Settings } from "../lib/settings";
type language_t = string; type language_t = string;
const cache = new Cache({ const cache = new Cache({
namespace: "translation_terrace", namespace: "translation_terrace",
policy: { policy: {
maxEntries: 50000, // if unspecified, it can have unlimited entries maxEntries: 50000, // if unspecified, it can have unlimited entries
stdTTL: 0, // the standard ttl as number in seconds, default: 0 (unlimited) stdTTL: 0 // the standard ttl as number in seconds, default: 0 (unlimited)
}, },
backend: AsyncStorage, backend: AsyncStorage
}); });
export type language_matrix_entry = { export type language_matrix_entry = {
code: string; code: string,
name: string; name: string,
targets: string[]; targets: string []
}; }
export type language_matrix = { export type language_matrix = {
[key: string]: language_matrix_entry; [key:string] : language_matrix_entry
}; }
export async function fetchWithTimeout( export async function fetchWithTimeout(url : string, options : RequestInit, timeout = 5000) : Promise<Response> {
url: string, return Promise.race([
options: RequestInit, fetch(url, options),
timeout = 5000 new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout))
): Promise<Response> { ]);
return Promise.race([
fetch(url, options),
new Promise((_, reject) =>
setTimeout(() => reject(new Error("timeout")), timeout)
),
]);
} }
export class LanguageServer { export class LanguageServer {
constructor(public baseUrl: string) {} constructor(public baseUrl : string) {}
async fetchLanguages(timeout = 500): Promise<language_matrix> { async fetchLanguages(timeout = 500) : Promise<language_matrix> {
let data = {}; let data = {};
const res = await fetchWithTimeout( const res = await fetchWithTimeout(this.baseUrl + "/languages", {
this.baseUrl + "/languages", headers: {
{ "Content-Type": "application/json"
headers: { }
"Content-Type": "application/json", }, timeout);
}, try {
}, data = await res.json();
timeout } catch (e) {
); throw new Error(`Parsing data from ${await res.text()}: ${e}`)
try { }
data = await res.json(); try {
} catch (e) { return Object.fromEntries(
throw new Error(`Parsing data from ${await res.text()}: ${e}`); Object.values(data as language_matrix_entry []).map((obj : language_matrix_entry) => {
return [
obj["code"],
obj,
]
})
)
} catch(e) {
throw new Error(`Can't extract values from data: ${JSON.stringify(data)}`)
}
} }
try {
return Object.fromEntries(
Object.values(data as language_matrix_entry[]).map(
(obj: language_matrix_entry) => {
return [obj["code"], obj];
}
)
);
} catch (e) {
throw new Error(
`Can't extract values from data: ${JSON.stringify(data)}`
);
}
}
static async getDefault() { static async getDefault() {
const settings = await Settings.getDefault(); const settings = await Settings.getDefault();
return new LanguageServer( return new LanguageServer(await settings.getLibretranslateBaseUrl() || LIBRETRANSLATE_BASE_URL);
(await settings.getLibretranslateBaseUrl()) || LIBRETRANSLATE_BASE_URL }
);
}
} }
export class Translator { export class Translator {
constructor( constructor(public source : language_t, public defaultTarget : string = "en", private _languageServer : LanguageServer) {
public source: language_t,
public defaultTarget: string = "en",
private _languageServer: LanguageServer
) {}
get languageServer() {
return this._languageServer;
}
async translate(text: string, target: string | undefined = undefined) {
const url = this._languageServer.baseUrl + `/translate`;
console.log(url);
const postData = {
method: "POST",
body: JSON.stringify({
q: text,
source: this.source,
target: target || this.defaultTarget,
format: "text",
alternatives: 3,
api_key: "",
}),
headers: { "Content-Type": "application/json" },
};
console.debug("Requesting %s with %o", url, postData);
const res = await fetch(url, postData);
const data = await res.json();
if (res.status === 200) {
console.log(data);
return data.translatedText;
} else {
console.error(data);
} }
}
static async getDefault(defaultTarget: string | undefined = undefined) { get languageServer() {
const settings = await Settings.getDefault(); return this._languageServer;
const source = await settings.getHostLanguage(); }
return new Translator(
source, async translate(text : string, target : string|undefined = undefined) {
defaultTarget, const url = this._languageServer.baseUrl + `/translate`;
await LanguageServer.getDefault() const res = await fetch(url, {
); method: "POST",
} body: JSON.stringify({
q: text,
source: this.source,
target: target || this.defaultTarget,
format: "text",
alternatives: 3,
api_key: ""
}),
headers: { "Content-Type": "application/json" }
});
const data = await res.json();
console.log(data)
return data.translatedText
}
static async getDefault(defaultTarget: string | undefined = undefined) {
const settings = await Settings.getDefault();
const source = await settings.getHostLanguage();
return new Translator(source, defaultTarget, await LanguageServer.getDefault())
}
} }
export class CachedTranslator extends Translator { export class CachedTranslator extends Translator {
async translate(text: string, target: string | undefined = undefined) { async translate (text : string, target : string|undefined = undefined) {
const targetKey = target || this.defaultTarget; const targetKey = target || this.defaultTarget;
// console.debug(`Translating from ${this.source} -> ${targetKey}`) // console.debug(`Translating from ${this.source} -> ${targetKey}`)
const key1 = `${this.source}::${targetKey}::${text}`; const key1 = `${this.source}::${targetKey}::${text}`
const tr1 = await cache.get(key1); const tr1 = await cache.get(key1);
if (tr1) return tr1; if (tr1) return tr1;
const tr2 = await super.translate(text, target); const tr2 = await super.translate(text, target);
const key2 = `${this.source}::${targetKey}::${text}`; const key2 = `${this.source}::${targetKey}::${text}`
await cache.set(key2, tr2); await cache.set(key2, tr2);
return tr2; return tr2;
} }
static async getDefault(defaultTarget: string | undefined = undefined) { static async getDefault(defaultTarget: string | undefined = undefined) {
const settings = await Settings.getDefault(); const settings = await Settings.getDefault();
const source = await settings.getHostLanguage() || "en"; const source = await settings.getHostLanguage();
return new CachedTranslator( return new CachedTranslator(source, defaultTarget, await LanguageServer.getDefault())
source, }
defaultTarget, }
await LanguageServer.getDefault()
);
}
}

13
app/lib/__tests__/settings.spec.tsx
View File

@ -1,19 +1,18 @@
import { Settings } from '@/app/lib/settings'; import { Settings } from '@/app/lib/settings';
import { getDb, migrateDb } from '@/app/lib/db'; import { getDb } from '@/app/lib/db';
import { SQLiteDatabase } from 'expo-sqlite'; import { Knex } from 'knex';
describe('Settings', () => { describe('Settings', () => {
let settings: Settings; let settings : Settings;
let db: SQLiteDatabase; let db : Knex;
beforeEach(async () => { beforeEach(async () => {
db = await getDb("development"); db = await getDb("development");
await migrateDb("development"); settings = new Settings(db)
settings = new Settings(db);
}); });
afterEach(async () => { afterEach(async () => {
await migrateDb("development", "down"); await db.migrate.down();
}); });
it('should set the host language in the database', async () => { it('should set the host language in the database', async () => {

217
app/lib/__tests__/whisper.spec.tsx
View File

@ -1,170 +1,101 @@
// app/lib/__tests__/whisper.spec.tsx // components/ui/__tests__/WhisperFile.spec.tsx
import React from "react"; import React from "react";
import { getDb } from "@/app/lib/db"; import { render, act } from "@testing-library/react-native";
import { WhisperFile, WhisperModelTag } from "@/app/lib/whisper"; // Corrected to use WhisperFile and WhisperModelTag instead of WhisperDownloader import { WhisperFile } from "@/app/lib/whisper"; // Adjust the import path as necessary
import { Settings } from "@/app/lib/settings";
import { File } from "expo-file-system/next";
jest.mock('expo-file-system');
import * as FileSystem from 'expo-file-system';
jest.mock("@/app/lib/db", () => ({
getDb: jest.fn().mockResolvedValue({
runAsync: jest.fn(),
upsert: jest.fn(), // Mock the upsert method used in addToDatabase
}),
}));
jest.mock("@/app/lib/settings", () => ({
Settings: {
getDefault: jest.fn(() => ({
getValue: jest.fn((key) => {
switch (key) {
case "whisper_model":
return "base";
default:
throw new Error(`Invalid setting: '${key}'`);
}
}),
})),
},
}));
jest.mock("expo-file-system/next", () => {
const _next = jest.requireActual("expo-file-system/next");
return {
..._next,
File: jest.fn().mockImplementation(() => ({
..._next.File,
text: jest.fn(() => {
return new String("text");
}),
})),
};
});
describe("WhisperFile", () => { describe("WhisperFile", () => {
// Corrected to use WhisperFile instead of WhisperDownloader
let whisperFile: WhisperFile; let whisperFile: WhisperFile;
beforeEach(async () => { beforeEach(() => {
whisperFile = new WhisperFile("small"); whisperFile = new WhisperFile("small");
}); });
it("should create a download resumable with existing data if available", async () => { it("should initialize correctly", () => {
const mockExistingData = "mockExistingData"; expect(whisperFile).toBeInstanceOf(WhisperFile);
jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(true);
await whisperFile.createDownloadResumable();
// expect(whisperFile.targetFileName).toEqual("small.bin");
expect(whisperFile.targetPath).toContain("small.bin");
expect(FileSystem.createDownloadResumable).toHaveBeenCalledWith(
"https://huggingface.co/openai/whisper-small/resolve/main/pytorch_model.bin",
"file:///whisper/small.bin",
{},
expect.any(Function),
expect.anything(),
);
}); });
// it("should create a download resumable without existing data if not available", async () => { describe("getModelFileSize", () => {
// jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(false); it("should return the correct model file size", async () => {
expect(whisperFile.size).toBeUndefined();
await whisperFile.updateMetadata();
expect(whisperFile.size).toBeGreaterThan(1000);
});
});
// await whisperFile.createDownloadResumable(); // Updated to use createDownloadResumable instead of download describe("getWhisperDownloadStatus", () => {
it("should return the correct download status", async () => {
const mockStatus = {
doesTargetExist: true,
isDownloadComplete: false,
hasDownloadStarted: true,
progress: {
current: 100,
total: 200,
remaining: 100,
percentRemaining: 50.0,
},
};
jest
.spyOn(whisperFile, "getDownloadStatus")
.mockResolvedValue(mockStatus);
// expect(FileSystem.createDownloadResumable).toHaveBeenCalledWith( const result = await whisperFile.getDownloadStatus();
// "http://mock.model.com/model",
// "mockTargetPath",
// {},
// expect.any(Function),
// undefined
// );
// });
// it("should update the download status in the database", async () => { expect(result).toEqual(mockStatus);
// const mockRunAsync = jest.fn(); });
// (getDb as jest.Mock).mockResolvedValue({ runAsync: mockRunAsync }); });
// const downloadable = await whisperFile.createDownloadResumable(); // Updated to use createDownloadResumable instead of download describe("initiateWhisperDownload", () => {
// await downloadable.resumeAsync(); it("should initiate the download with default options", async () => {
const mockModelLabel = "small";
jest
.spyOn(whisperFile, "createDownloadResumable")
.mockResolvedValue(true);
// jest.advanceTimersByTime(1000); await whisperFile.initiateWhisperDownload(mockModelLabel);
// expect(mockRunAsync).toHaveBeenCalled(); expect(whisperFile.createDownloadResumable).toHaveBeenCalledWith(
// }); mockModelLabel
);
});
// it("should record the latest target hash after downloading", async () => { it("should initiate the download with custom options", async () => {
// const mockRecordLatestTargetHash = jest.spyOn( const mockModelLabel = "small";
// whisperFile, const mockOptions = { force_redownload: true };
// "recordLatestTargetHash" jest
// ); .spyOn(whisperFile, "createDownloadResumable")
.mockResolvedValue(true);
// await whisperFile.createDownloadResumable(); // Updated to use createDownloadResumable instead of download await whisperFile.initiateWhisperDownload(mockModelLabel, mockOptions);
// expect(mockRecordLatestTargetHash).toHaveBeenCalled(); expect(whisperFile.createDownloadResumable).toHaveBeenCalledWith(
// }); mockModelLabel,
mockOptions
);
});
// it("should call the onData callback if provided", async () => { it("should return the correct download status when target exists and is complete", async () => {
// const mockOnData = jest.fn(); jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(true);
// const options = { onData: mockOnData }; jest.spyOn(whisperFile, "isDownloadComplete").mockResolvedValue(true);
// await whisperFile.createDownloadResumable(options); // Updated to use createDownloadResumable instead of download expect(await whisperFile.doesTargetExist()).toEqual(true);
expect(await whisperFile.isDownloadComplete()).toEqual(true);
});
// expect(mockOnData).toHaveBeenCalledWith(expect.any(Object)); it("should return the correct download status when target does not exist", async () => {
// }); jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(false);
// describe("getDownloadStatus", () => { const result = await whisperFile.getDownloadStatus();
// it("should return the correct download status when model size is known and download has started", async () => {
// whisperFile.size = 1024;
// jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(true);
// jest.spyOn(whisperFile, "isDownloadComplete").mockResolvedValue(false);
// jest.spyOn(whisperFile, "targetFile").mockReturnValue({
// size: 512,
// });
// const status = await whisperFile.getDownloadStatus(); expect(result).toEqual({
doesTargetExist: false,
isDownloadComplete: false,
hasDownloadStarted: false,
progress: undefined,
});
});
});
// expect(status).toEqual({ // Add more tests as needed for other methods in WhisperFile
// doesTargetExist: true,
// isDownloadComplete: false,
// hasDownloadStarted: true,
// progress: {
// current: 512,
// total: 1024,
// remaining: 512,
// percentRemaining: 50.0,
// },
// });
// });
// it("should return the correct download status when model size is known and download is complete", async () => {
// whisperFile.size = 1024;
// jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(true);
// jest.spyOn(whisperFile, "isDownloadComplete").mockResolvedValue(true);
// const status = await whisperFile.getDownloadStatus();
// expect(status).toEqual({
// doesTargetExist: true,
// isDownloadComplete: true,
// hasDownloadStarted: false,
// progress: undefined,
// });
// });
// it("should return the correct download status when model size is unknown", async () => {
// jest.spyOn(whisperFile, "doesTargetExist").mockResolvedValue(false);
// const status = await whisperFile.getDownloadStatus();
// expect(status).toEqual({
// doesTargetExist: false,
// isDownloadComplete: false,
// hasDownloadStarted: false,
// progress: undefined,
// });
// });
// });
}); });

10
app/lib/db.ts
View File

@ -1,16 +1,14 @@
import * as SQLite from "expo-sqlite"; import * as SQLite from "expo-sqlite";
import { MIGRATE_UP, MIGRATE_DOWN } from "./migrations"; import { MIGRATE_UP, MIGRATE_DOWN } from "./migrations";
export type db_mode = "development" | "staging" | "production"; export async function getDb() {
return await SQLite.openDatabaseAsync("translation_terrace");
export async function getDb(mode : db_mode = "production") {
return await SQLite.openDatabaseAsync(`translation_terrace_${mode}`);
} }
export async function migrateDb(mode : db_mode = "production", direction: "up" | "down" = "up") { export async function migrateDb(direction: "up" | "down" = "up") {
const db = await getDb(mode); const db = await getDb();
const m = direction === "up" ? MIGRATE_UP : MIGRATE_DOWN; const m = direction === "up" ? MIGRATE_UP : MIGRATE_DOWN;

11
app/lib/migrations.ts
View File

@ -2,16 +2,15 @@
export const MIGRATE_UP = { export const MIGRATE_UP = {
1: [ 1: [
`CREATE TABLE IF NOT EXISTS settings ( `CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY, host_language TEXT,
value TEXT libretranslate_base_url TEXT,
)`, ui_direction INTEGER,
whisper_model TEXT
)`,
], ],
2: [ 2: [
`CREATE TABLE IF NOT EXISTS whisper_models ( `CREATE TABLE IF NOT EXISTS whisper_models (
model TEXT PRIMARY KEY, model TEXT PRIMARY KEY,
download_status STRING(255),
expected_size INTEGER,
last_hash STRING(1024),
bytes_done INTEGER, bytes_done INTEGER,
bytes_total INTEGER bytes_total INTEGER
)`, )`,

34
app/lib/settings.ts
View File

@ -1,6 +1,5 @@
import { SQLiteDatabase } from "expo-sqlite";
import { getDb } from "./db"; import { getDb } from "./db";
import { WhisperFile, whisper_model_tag_t } from "./whisper"; import { Knex } from "knex";
export class Settings { export class Settings {
@ -11,7 +10,7 @@ export class Settings {
"whisper_model", "whisper_model",
] ]
constructor(public db: SQLiteDatabase) { constructor(public db: Knex) {
} }
@ -21,9 +20,9 @@ export class Settings {
throw new Error(`Invalid setting: '${key}'`) throw new Error(`Invalid setting: '${key}'`)
} }
const row: { value: string } | null = this.db.getFirstSync(`SELECT value FROM settings WHERE key = ?`, key) const row = await this.db("settings").select(key).limit(1).first();
if (!(row && row[key])) return undefined;
return row?.value; return row[key];
} }
@ -33,11 +32,17 @@ export class Settings {
} }
// Check if the key already exists // Check if the key already exists
this.db.runSync(`INSERT OR REPLACE INTO const [exists] = await this.db("settings").select(1).whereNotNull(key).limit(1);
settings
(key, value) if (exists) {
VALUES // Update the existing column
(?, ?)`, key, value); await this.db("settings").update({ [key]: value });
} else {
// Insert a new value into the specified column
const insertData: { [key: string]: any } = {};
insertData[key] = value;
await this.db("settings").insert(insertData);
}
} }
async setHostLanguage(value: string) { async setHostLanguage(value: string) {
@ -48,7 +53,7 @@ export class Settings {
return await this.getValue("host_language") return await this.getValue("host_language")
} }
async setLibretranslateBaseUrl(value: string) { async setLibretranslateBaseUrl(value : string) {
await this.setValue("libretranslate_base_url", value) await this.setValue("libretranslate_base_url", value)
} }
@ -56,15 +61,16 @@ export class Settings {
return await this.getValue("libretranslate_base_url") return await this.getValue("libretranslate_base_url")
} }
async setWhisperModel(value: string) { async setWhisperModel(value : string) {
await this.setValue("whisper_model", value); await this.setValue("whisper_model", value);
} }
async getWhisperModel() { async getWhisperModel() {
return await this.getValue("whisper_model") as whisper_model_tag_t; return await this.getValue("whisper_model");
} }
static async getDefault() { static async getDefault() {
return new Settings(await getDb()) return new Settings(await getDb())
} }
} }

5
app/lib/util.ts
View File

@ -1,5 +0,0 @@
import { TextDecoder } from "util";
export async function arrbufToStr(arrayBuffer : ArrayBuffer) {
return new TextDecoder().decode(new Uint8Array(arrayBuffer));
}

190
app/lib/whisper.ts
View File

@ -3,7 +3,6 @@ import * as FileSystem from "expo-file-system";
import { File, Paths } from "expo-file-system/next"; import { File, Paths } from "expo-file-system/next";
import { getDb } from "./db"; import { getDb } from "./db";
import * as Crypto from "expo-crypto"; import * as Crypto from "expo-crypto";
import { arrbufToStr } from "./util";
export const WHISPER_MODEL_PATH = Paths.join( export const WHISPER_MODEL_PATH = Paths.join(
FileSystem.documentDirectory || "file:///", FileSystem.documentDirectory || "file:///",
@ -76,7 +75,7 @@ export const WHISPER_MODELS = {
size: 6173629930, size: 6173629930,
}, },
} as { } as {
[key: whisper_model_tag_t]: { [key:whisper_model_tag_t]: {
source: string; source: string;
target: string; target: string;
label: string; label: string;
@ -115,12 +114,6 @@ export type download_status_t = {
}; };
export class WhisperFile { export class WhisperFile {
hf_metadata: hf_metadata_t | undefined;
target_hash: string | undefined;
does_target_exist: boolean = false;
download_data: FileSystem.DownloadProgressData | undefined;
constructor( constructor(
public tag: whisper_model_tag_t, public tag: whisper_model_tag_t,
private targetFileName?: string, private targetFileName?: string,
@ -129,11 +122,11 @@ export class WhisperFile {
) { ) {
this.targetFileName = this.targetFileName || `${tag}.bin`; this.targetFileName = this.targetFileName || `${tag}.bin`;
this.label = this.label =
this.label || `${tag[0].toUpperCase()}${tag.substring(1).toLowerCase()}`; this.label || `${tag[0].toUpperCase}${tag.substring(1).toLowerCase()}`;
} }
get targetPath() { get targetPath() {
return Paths.join(WHISPER_MODEL_PATH, this.targetFileName as string); return Paths.join(WHISPER_MODEL_DIR, this.targetFileName as string);
} }
get targetFile() { get targetFile() {
@ -144,30 +137,78 @@ export class WhisperFile {
return await FileSystem.getInfoAsync(this.targetPath); return await FileSystem.getInfoAsync(this.targetPath);
} }
async updateTargetExistence() { async doesTargetExist() {
this.does_target_exist = (await this.getTargetInfo()).exists; return (await this.getTargetInfo()).exists;
} }
public async getTargetSha() { public async recordLatestTargetHash() {
await this.updateTargetExistence(); if (!(await this.doesTargetExist())) {
if (!this.does_target_exist) { console.debug("%s does not exist", this.targetPath);
}
const digest1Str = await this.getActualTargetHash();
if (!digest1Str) {
return;
}
const db = await getDb();
await db("whisper_models")
.upsert({
model: this.tag,
last_hash: digest1Str,
})
.where({ model: this.tag });
}
public async getRecordedTargetHash(): Promise<string> {
const db = await getDb();
const row = await db("whisper_models").select("last_hash").where({
model: this.tag,
}).first();
return row["last_hash"]
}
public async getActualTargetHash(): Promise<string | undefined> {
if (!(await this.doesTargetExist())) {
console.debug("%s does not exist", this.targetPath); console.debug("%s does not exist", this.targetPath);
return undefined; return undefined;
} }
return await Crypto.digest( const digest1 = await Crypto.digest(
Crypto.CryptoDigestAlgorithm.SHA256, Crypto.CryptoDigestAlgorithm.SHA256,
this.targetFile.bytes() this.targetFile.bytes()
); );
const digest1Str = new TextDecoder().decode(new Uint8Array(digest1));
return digest1Str;
} }
public async updateTargetHash() { async isTargetCorrupted() {
const targetSha = await this.getTargetSha(); const recordedTargetHash = await this.getRecordedTargetHash();
if (!targetSha) return; const actualTargetHash = await this.getActualTargetHash();
this.target_hash = await arrbufToStr(targetSha); if (!(actualTargetHash || recordedTargetHash)) return false;
return actualTargetHash !== recordedTargetHash;
} }
get isHashValid() { async isDownloadComplete() {
return this.target_hash === this.hf_metadata?.oid; if (!(await this.doesTargetExist())) {
console.debug("%s does not exist", this.targetPath);
return false;
}
const data = this.targetFile.bytes();
const meta = await this.fetchMetadata();
const expectedHash = meta.oid;
const digest1: ArrayBuffer = await Crypto.digest(
Crypto.CryptoDigestAlgorithm.SHA256,
data
);
const digest1Str = new TextDecoder().decode(new Uint8Array(digest1));
const doesMatch = digest1Str === expectedHash;
if (!doesMatch) {
console.debug(
"sha256 of '%s' does not match expected '%s'",
digest1Str,
expectedHash
);
return false;
}
return true;
} }
delete(ignoreErrors = true) { delete(ignoreErrors = true) {
@ -190,21 +231,7 @@ export class WhisperFile {
return create_hf_url(this.tag, "raw"); return create_hf_url(this.tag, "raw");
} }
get percentDone() { private async fetchMetadata(): Promise<hf_metadata_t> {
if (!this.download_data) return 0;
return (
(this.download_data.totalBytesWritten /
this.download_data.totalBytesExpectedToWrite) *
100
);
}
get percentLeft() {
if (!this.download_data) return 0;
return 100 - this.percentDone;
}
public async syncHfMetadata() {
try { try {
const resp = await fetch(this.metadataUrl, { const resp = await fetch(this.metadataUrl, {
credentials: "include", credentials: "include",
@ -226,7 +253,7 @@ export class WhisperFile {
mode: "cors", mode: "cors",
}); });
const text = await resp.text(); const text = await resp.text();
this.hf_metadata = Object.fromEntries( return Object.fromEntries(
text.split("\n").map((line) => line.split(" ")) text.split("\n").map((line) => line.split(" "))
) as hf_metadata_t; ) as hf_metadata_t;
} catch (err) { } catch (err) {
@ -235,6 +262,21 @@ export class WhisperFile {
} }
} }
async updateMetadata() {
const metadata = await this.fetchMetadata();
this.size = Number.parseInt(metadata.size);
}
async addToDatabase() {
const db = await getDb();
await db("whisper_models").upsert({
model: this.tag,
expected_size: this.size,
}).where({
model: this.tag,
});
}
async createDownloadResumable( async createDownloadResumable(
options: { options: {
onData?: DownloadCallback | undefined; onData?: DownloadCallback | undefined;
@ -242,43 +284,65 @@ export class WhisperFile {
onData: undefined, onData: undefined,
} }
) { ) {
await this.syncHfMetadata(); const existingData = (await this.doesTargetExist())
// If the whisper model dir doesn't exist, create it.
if (!WHISPER_MODEL_DIR.exists) {
FileSystem.makeDirectoryAsync(WHISPER_MODEL_PATH, {
intermediates: true,
});
}
// Check for the existence of the target file
// If it exists, load the existing data.
await this.updateTargetExistence();
const existingData = this.does_target_exist
? this.targetFile.text() ? this.targetFile.text()
: undefined; : undefined;
// Create the resumable. if (await this.doesTargetExist()) {
}
return FileSystem.createDownloadResumable( return FileSystem.createDownloadResumable(
this.modelUrl, this.modelUrl,
this.targetPath, this.targetPath,
{}, {},
async (data: FileSystem.DownloadProgressData) => { async (data: FileSystem.DownloadProgressData) => {
this.download_data = data; const db = await getDb();
await this.syncHfMetadata(); await db.upsert({
await this.updateTargetHash(); model: this.tag,
await this.updateTargetExistence(); download_status: "active",
if (options.onData) await options.onData(this); })
await this.recordLatestTargetHash();
if (options.onData) await options.onData(data);
}, },
existingData ? existingData : undefined existingData ? existingData : undefined
); );
} }
async getDownloadStatus() : Promise<download_status_t> {
const doesTargetExist = await this.doesTargetExist();
const isDownloadComplete = await this.isDownloadComplete();
const hasDownloadStarted = doesTargetExist && !isDownloadComplete;
if (!this.size) {
return {
doesTargetExist: false,
isDownloadComplete: false,
hasDownloadStarted: false,
progress: undefined,
}
}
const remaining = hasDownloadStarted
? this.size - (this.targetFile.size as number)
: 0;
const progress = hasDownloadStarted
? {
current: this.targetFile.size || 0,
total: this.size,
remaining: this.size - (this.targetFile.size as number),
percentRemaining: (remaining / this.size) * 100.0,
}
: undefined;
return {
doesTargetExist,
isDownloadComplete,
hasDownloadStarted,
progress,
};
}
} }
export type DownloadCallback = (arg0: WhisperFile) => any;
export const WHISPER_FILES = { export type DownloadCallback = (arg0: FileSystem.DownloadProgressData) => any;
small: new WhisperFile("small"),
medium: new WhisperFile("medium"),
large: new WhisperFile("large"),
};

22
components/LanguageSelection.tsx
View File

@ -8,7 +8,6 @@ import { SafeAreaProvider, SafeAreaView } from "react-native-safe-area-context";
import { Conversation, Speaker } from "@/app/lib/conversation"; import { Conversation, Speaker } from "@/app/lib/conversation";
import { NavigationProp, ParamListBase } from "@react-navigation/native"; import { NavigationProp, ParamListBase } from "@react-navigation/native";
import { Link, useNavigation } from "expo-router"; import { Link, useNavigation } from "expo-router";
import { migrateDb } from "@/app/lib/db";
export function LanguageSelection(props: { export function LanguageSelection(props: {
@ -31,7 +30,6 @@ export function LanguageSelection(props: {
useEffect(() => { useEffect(() => {
(async () => { (async () => {
await migrateDb();
try { try {
// Replace with your actual async data fetching logic // Replace with your actual async data fetching logic
setTranslator(await CachedTranslator.getDefault()); setTranslator(await CachedTranslator.getDefault());
@ -51,12 +49,12 @@ export function LanguageSelection(props: {
<Text>Settings</Text> <Text>Settings</Text>
</Pressable> </Pressable>
<ScrollView > <ScrollView >
<SafeAreaProvider> <SafeAreaProvider >
<SafeAreaView style={styles.table}> <SafeAreaView>
{(languages && languagesLoaded) ? Object.entries(languages).filter((l) => (LANG_FLAGS as any)[l[0]] !== undefined).map( {(languages && languagesLoaded) ? Object.entries(languages).filter((l) => (LANG_FLAGS as any)[l[0]] !== undefined).map(
([lang, lang_entry]) => { ([lang, lang_entry]) => {
return ( return (
<ISpeakButton language={lang_entry} key={lang_entry.code} onLangSelected={onLangSelected} translator={translator} /> <ISpeakButton language={lang_entry} key={lang_entry.code} onLangSelected={onLangSelected} translator={translator} />
); );
} }
) : <Text>Waiting...</Text> ) : <Text>Waiting...</Text>
@ -68,15 +66,11 @@ export function LanguageSelection(props: {
) )
} }
const DEBUG_BORDER = {
borderWidth: 3,
borderStyle: "dotted",
borderColor: "blue",
}
const styles = StyleSheet.create({ const styles = StyleSheet.create({
table: { column: {
flexDirection: "row", flex: 1,
flexWrap: "wrap", flexDirection: 'row',
flexWrap: 'wrap',
padding: 8,
}, },
}) })

97
components/Settings.tsx
View File

@ -1,7 +1,6 @@
import React, { useState, useEffect } from "react"; import React, { useState, useEffect } from "react";
import { View, Text, TextInput, Pressable, StyleSheet } from "react-native"; import { View, Text, TextInput, Pressable, StyleSheet } from "react-native";
import { import {
WHISPER_FILES,
WhisperFile, WhisperFile,
download_status_t, download_status_t,
whisper_tag_t, whisper_tag_t,
@ -35,36 +34,33 @@ const SettingsComponent = () => {
} | null>(null); } | null>(null);
const [whisperModel, setWhisperModel] = const [whisperModel, setWhisperModel] =
useState<keyof typeof WHISPER_MODELS>("small"); useState<keyof typeof WHISPER_MODELS>("small");
const [whisperFile, setWhisperFile] = useState<WhisperFile | undefined>();
const [whisperFileExists, setWhisperFileExists] = useState<boolean>(false);
const [isWhisperHashValid, setIsWhisperHashValid] = useState<boolean>(false);
const [downloader, setDownloader] = useState<any>(null); const [downloader, setDownloader] = useState<any>(null);
const [bytesDone, setBytesDone] = useState<number | undefined>(); const [whisperFile, setWhisperFile] = useState<WhisperFile | undefined>();
const [bytesRemaining, setBytesRemaining] = useState<number | undefined>(); const [downloadStatus, setDownloadStatus] = useState<
undefined | download_status_t
>();
const [statusTimeout, setStatusTimeout] = useState< const [statusTimeout, setStatusTimeout] = useState<
NodeJS.Timeout | undefined NodeJS.Timeout | undefined
>(); >();
useEffect(() => { useEffect(() => {
(async function () { loadSettings();
const settings = await Settings.getDefault(); }, []);
setHostLanguage((await settings.getHostLanguage()) || "en");
setLibretranslateBaseUrl(
(await settings.getLibretranslateBaseUrl()) || LIBRETRANSLATE_BASE_URL
);
setWhisperModel((await settings.getWhisperModel()) || "small");
setWhisperFile(WHISPER_FILES[whisperModel]);
await whisperFile?.syncHfMetadata();
await whisperFile?.updateTargetExistence();
await whisperFile?.updateTargetHash();
})();
}, [whisperFile]);
const getLanguageOptions = async () => { const getLanguageOptions = async () => {
const languageServer = await LanguageServer.getDefault(); const languageServer = await LanguageServer.getDefault();
setLanguageOptions(await languageServer.fetchLanguages()); setLanguageOptions(await languageServer.fetchLanguages());
}; };
const loadSettings = async () => {
const settings = await Settings.getDefault();
setHostLanguage((await settings.getHostLanguage()) || "en");
setLibretranslateBaseUrl(
(await settings.getLibretranslateBaseUrl()) || LIBRETRANSLATE_BASE_URL
);
setWhisperModel(await settings.getWhisperModel());
};
const handleHostLanguageChange = async (lang: string) => { const handleHostLanguageChange = async (lang: string) => {
const settings = await Settings.getDefault(); const settings = await Settings.getDefault();
setHostLanguage(lang); setHostLanguage(lang);
@ -87,24 +83,17 @@ const SettingsComponent = () => {
} }
}; };
const intervalUpdateDownloadStatus = async () => {
if (!whisperFile) return;
const status = await whisperFile.getDownloadStatus();
setDownloadStatus(status);
};
const handleWhisperModelChange = async (model: whisper_tag_t) => { const handleWhisperModelChange = async (model: whisper_tag_t) => {
const settings = await Settings.getDefault(); const settings = await Settings.getDefault();
await settings.setWhisperModel(model); await settings.setWhisperModel(model);
setWhisperModel(model); setWhisperModel(model);
const wFile = WHISPER_FILES[whisperModel]; setWhisperFile(new WhisperFile(model));
await wFile.syncHfMetadata();
await wFile.updateTargetExistence();
await wFile.updateTargetHash();
setIsWhisperHashValid(wFile.isHashValid);
setWhisperFile(wFile);
setWhisperFileExists(wFile.does_target_exist);
};
const doSetDownloadStatus = (arg0: WhisperFile) => {
console.log("Downloading ....")
setIsWhisperHashValid(arg0.isHashValid);
setBytesDone(arg0.download_data?.totalBytesWritten);
setBytesRemaining(arg0.download_data?.totalBytesExpectedToWrite);
}; };
const doDownload = async () => { const doDownload = async () => {
@ -112,16 +101,16 @@ const SettingsComponent = () => {
throw new Error("Could not start download because whisperModel not set."); throw new Error("Could not start download because whisperModel not set.");
} }
console.log("Starting download of %s", whisperModel); console.log("Starging download of %s", whisperModel)
if (!whisperFile) throw new Error("No whisper file"); const whisperFile = new WhisperFile(whisperModel);
const resumable = await whisperFile.createDownloadResumable();
setDownloader(resumable);
try { try {
const resumable = await whisperFile.createDownloadResumable({ await resumable.downloadAsync();
onData: doSetDownloadStatus, const statusTimeout = setInterval(intervalUpdateDownloadStatus, 200);
}); setStatusTimeout(statusTimeout);
setDownloader(resumable);
await resumable.resumeAsync();
} catch (error) { } catch (error) {
console.error("Failed to download whisper model:", error); console.error("Failed to download whisper model:", error);
} }
@ -185,22 +174,28 @@ const SettingsComponent = () => {
))} ))}
</Picker> </Picker>
<View> <View>
{/* <Text>whisper file: { whisperFile?.tag }</Text> */} {whisperModel &&
{whisperFile && (downloadStatus?.isDownloadComplete ? (
( whisperFileExists && (<Pressable onPress={doDelete} style={styles.deleteButton}> downloadStatus?.doesTargetExist ? (
<Text>DELETE {whisperModel.toUpperCase()}</Text> <Pressable onPress={doDelete}>
</Pressable>)) <Text>DELETE {whisperModel.toUpperCase()}</Text>
} </Pressable>
<Pressable onPress={doDownload} style={styles.pauseDownloadButton}> ) : (
<Pressable onPress={doStopDownload}>
<Text>PAUSE</Text>
</Pressable>
)
) : (
<Pressable onPress={doDownload}>
<Text>DOWNLOAD {whisperModel.toUpperCase()}</Text> <Text>DOWNLOAD {whisperModel.toUpperCase()}</Text>
</Pressable> </Pressable>
))} ))}
{bytesDone && bytesRemaining && ( {downloadStatus?.progress && (
<View> <View>
<Text> <Text>
{bytesDone} of{" "} {downloadStatus.progress.current} of{" "}
{bytesRemaining} ( {downloadStatus.progress.total} (
{bytesDone / bytesRemaining * 100} %){" "} {downloadStatus.progress.percentRemaining} %){" "}
</Text> </Text>
</View> </View>
)} )}

21
components/__tests__/index.spec.tsx
View File

@ -1,5 +1,5 @@
jest.mock("@/app/i18n/api", () => require("../../__mocks__/api.ts")); jest.mock("@/app/i18n/api", () => require("../../__mocks__/api.ts"));
import { renderRouter } from "expo-router/testing-library"; import { renderRouter} from 'expo-router/testing-library';
import React from "react"; import React from "react";
import { import {
act, act,
@ -13,19 +13,12 @@ import {
createNavigationContainerRef, createNavigationContainerRef,
} from "@react-navigation/native"; } from "@react-navigation/native";
import TTNavStack from "../TTNavStack"; import TTNavStack from "../TTNavStack";
import { migrateDb } from "@/app/lib/db";
describe("Navigation", () => { describe("Navigation", () => {
beforeEach(async () => { beforeEach(() => {
await migrateDb("development", "up");
// Reset the navigation state before each test // Reset the navigation state before each test
jest.useFakeTimers();
});
afterEach(async () => {
await migrateDb("development", "down");
jest.clearAllMocks(); jest.clearAllMocks();
jest.useRealTimers(); jest.useFakeTimers();
}); });
it("Navigates to ConversationThread on language selection", async () => { it("Navigates to ConversationThread on language selection", async () => {
@ -35,7 +28,7 @@ describe("Navigation", () => {
index: MockComponent, index: MockComponent,
}, },
{ {
initialUrl: "/", initialUrl: '/',
} }
); );
const languageSelectionText = await waitFor(() => const languageSelectionText = await waitFor(() =>
@ -54,16 +47,14 @@ describe("Navigation", () => {
index: MockComponent, index: MockComponent,
}, },
{ {
initialUrl: "/", initialUrl: '/',
} }
); );
const settingsButton = await waitFor(() => const settingsButton = await waitFor(() =>
screen.getByText(/.*Settings.*/i) screen.getByText(/.*Settings.*/i)
); );
fireEvent.press(settingsButton); fireEvent.press(settingsButton);
expect( expect(await waitFor(() => screen.getByText(/Settings/i))).toBeOnTheScreen();
await waitFor(() => screen.getByText(/Settings/i))
).toBeOnTheScreen();
// expect(waitFor(() => screen.getByText(/Settings/i))).toBeTruthy() // expect(waitFor(() => screen.getByText(/Settings/i))).toBeTruthy()
expect(screen.getByText("Settings")).toBeOnTheScreen(); expect(screen.getByText("Settings")).toBeOnTheScreen();
}); });

12
components/ui/ISpeakButton.tsx
View File

@ -106,12 +106,7 @@ const ISpeakButton = (props: ISpeakButtonProps) => {
<View style={styles.flag}> <View style={styles.flag}>
{countries && {countries &&
countries.map((c) => { countries.map((c) => {
return ( return <CountryFlag isoCode={c} size={25} key={c} />;
<View>
<Text>{c}</Text>
<CountryFlag isoCode={c} size={25} key={c} />
</View>
);
})} })}
</View> </View>
<View> <View>
@ -126,13 +121,14 @@ const ISpeakButton = (props: ISpeakButtonProps) => {
const styles = StyleSheet.create({ const styles = StyleSheet.create({
button: { button: {
width: "20%",
borderRadius: 10, borderRadius: 10,
borderColor: "white", borderColor: "white",
borderWidth: 1, borderWidth: 1,
borderStyle: "solid", borderStyle: "solid",
height: 110, height: 110,
width: 170, alignSelf: "flex-start",
margin: 10, margin: 8,
}, },
flag: {}, flag: {},
iSpeak: { iSpeak: {

9
components/ui/__tests__/Settings.spec.tsx
View File

@ -3,10 +3,9 @@ import { render, screen, fireEvent, act } from "@testing-library/react-native";
import SettingsComponent from "@/components/Settings"; import SettingsComponent from "@/components/Settings";
import { language_matrix } from "@/app/i18n/api"; import { language_matrix } from "@/app/i18n/api";
import { Settings } from "@/app/lib/settings"; import { Settings } from "@/app/lib/settings";
import { getDb, migrateDb } from "@/app/lib/db"; import { getDb } from "@/app/lib/db";
import { Knex } from "knex"; import { Knex } from "knex";
import { WhisperFile } from "@/app/lib/whisper"; import { WhisperFile } from "@/app/lib/whisper";
import { SQLiteDatabase } from "expo-sqlite";
const RENDER_TIME = 1000; const RENDER_TIME = 1000;
@ -78,12 +77,11 @@ jest.mock("@/app/i18n/api", () => {
describe("SettingsComponent", () => { describe("SettingsComponent", () => {
let db: SQLiteDatabase; let db: Knex;
let settings: Settings; let settings: Settings;
beforeEach(async () => { beforeEach(async () => {
db = await getDb("development"); db = await getDb("development");
await migrateDb("development");
settings = new Settings(db); settings = new Settings(db);
jest.spyOn(Settings, 'getDefault').mockResolvedValue(settings); jest.spyOn(Settings, 'getDefault').mockResolvedValue(settings);
await settings.setHostLanguage("en"); await settings.setHostLanguage("en");
@ -92,7 +90,8 @@ describe("SettingsComponent", () => {
afterEach(async () => { afterEach(async () => {
jest.restoreAllMocks(); jest.restoreAllMocks();
await migrateDb("development", "down"); await db.migrate.down();
await db.destroy();
}); });
beforeAll(async () => { beforeAll(async () => {

68
jestSetup.ts
View File

@ -9,37 +9,43 @@ jest.mock("expo-sqlite", () => {
const { MIGRATE_UP } = jest.requireActual("./app/lib/migrations"); const { MIGRATE_UP } = jest.requireActual("./app/lib/migrations");
const genericRun = (sql: string, ... params : string []) => {
// console.log("Running %s with %s", sql, params);
try {
const stmt = db.prepare(sql);
stmt.run(...params);
} catch (e) {
throw new Error(
`running ${sql} with params ${JSON.stringify(params)}: ${e}`
);
}
}
const genericGetFirst = (sql: string, params = []) => {
const stmt = db.prepare(sql);
// const result = stmt.run(...params);
return stmt.get(params);
};
const openDatabaseAsync = async (name: string) => { const openDatabaseAsync = async (name: string) => {
return { return {
closeAsync: jest.fn(() => db.close()), closeAsync: jest.fn(() => db.close()),
executeSql: jest.fn((sql: string) => db.exec(sql)), executeSql: jest.fn((sql: string) => db.exec(sql)),
runAsync: jest.fn(genericRun), runAsync: jest.fn(async (sql: string, params = []) => {
runSync: jest.fn(genericRun), for (let m of Object.values(MIGRATE_UP)) {
getFirstAsync: jest.fn(genericGetFirst), for (let stmt of m) {
getFirstSync: jest.fn(genericGetFirst), const s = db.prepare(stmt);
s.run();
}
}
const stmt = db.prepare(sql);
// console.log("Running %s with %s", sql, params);
try {
stmt.run(params);
} catch (e) {
throw new Error(
`running ${sql} with params ${JSON.stringify(params)}: ${e}`
);
}
}),
getFirstAsync: jest.fn(async (sql: string, params = []) => {
for (let m of Object.values(MIGRATE_UP)) {
for (let stmt of m) {
const s = db.prepare(stmt);
s.run();
}
}
const stmt = db.prepare(sql);
// const result = stmt.run(...params);
return stmt.get(params);
}),
}; };
}; };
return { return {
migrateDb: async (direction: "up" | "down" = "up") => { migrateDb: async (direction: "up" | "down" = "up") => {
const db = await openDatabaseAsync("translation_terrace_development"); const db = await openDatabaseAsync("translation_terrace");
for (let m of Object.values(MIGRATE_UP)) { for (let m of Object.values(MIGRATE_UP)) {
for (let stmt of m) { for (let stmt of m) {
await db.executeSql(stmt); await db.executeSql(stmt);
@ -113,18 +119,4 @@ jest.mock('@/app/lib/settings', () => {
...originalModule, ...originalModule,
default: MockSettings default: MockSettings
}; };
}); });
jest.mock('expo-file-system', () => ({
// ... other methods ...
createDownloadResumable: jest.fn(() => ({
downloadAsync: jest.fn(() => Promise.resolve({ uri: 'mocked-uri' })),
pauseAsync: jest.fn(() => Promise.resolve()),
resumeAsync: jest.fn(() => Promise.resolve()),
cancelAsync: jest.fn(() => Promise.resolve()),
})),
getInfoAsync: jest.fn(() => ({
exists: () => false,
}))
// ... other methods ...
}));