Spaces:
Running
Running
| import Row from "./Row"; | |
| import { statusMessage } from "./store"; | |
| const baseURL = "https://dylanebert-research-tracker-backend.hf.space"; | |
| // const baseURL = "http://localhost:8000"; | |
| export const fetchRows = async (): Promise<Row[] | null> => { | |
| statusMessage.set(`<span>Fetching data from https://dylanebert-research-tracker-backend.hf.space/data</span>`); | |
| try { | |
| const response = await fetch(baseURL + "/data", { | |
| method: "GET", | |
| headers: { | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| "Cache-Control": "no-cache", | |
| }, | |
| }); | |
| const rows = await response.json(); | |
| statusMessage.reset(); | |
| return rows; | |
| } catch (e) { | |
| console.error(e); | |
| statusMessage.set( | |
| `<span style="color: red;">Error: Failed to fetch data from https://dylanebert-research-tracker-backend.hf.space/data</span>` | |
| ); | |
| return null; | |
| } | |
| }; | |
| export const addEntry = async (selection: Record<string | number, any>): Promise<Row | null> => { | |
| if (!("Name" in selection)) return null; | |
| const value = selection["Name"] as string; | |
| let row: Row | null = new Row(); | |
| const field = await inferFieldType(row, value); | |
| if (!field) return null; | |
| if (field === "Name") { | |
| row.Name = value; | |
| } else if (field === "Paper") { | |
| row.Paper = value; | |
| } else if (field === "Code") { | |
| row.Code = value; | |
| } else if (field === "Space") { | |
| row.Space = value; | |
| } else if (field === "Model") { | |
| row.Model = value; | |
| } else if (field === "Dataset") { | |
| row.Dataset = value; | |
| } else if (field === "Project") { | |
| row.Project = value; | |
| } else { | |
| statusMessage.set(`<span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>`); | |
| return null; | |
| } | |
| row = await inferFields(row); | |
| if (!row) { | |
| return null; | |
| } | |
| const response = await fetch(baseURL + "/add-entry", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| const data = await response.json(); | |
| if (data.error || !data.success) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to add entry</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Added entry for "${row.Name}"</span>`); | |
| return row; | |
| }; | |
| export const editEntry = async (row: Row): Promise<Row | null> => { | |
| row.Orgs = Array.isArray(row.Orgs) ? row.Orgs : (row.Orgs as any).split(",").map((org: string) => org.trim()); | |
| row.Authors = Array.isArray(row.Authors) | |
| ? row.Authors | |
| : (row.Authors as any).split(",").map((author: string) => author.trim()); | |
| row.Tags = Array.isArray(row.Tags) ? row.Tags : (row.Tags as any).split(",").map((tag: string) => tag.trim()); | |
| const response = await fetch(baseURL + "/edit-entry", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| const data = await response.json(); | |
| if (data.error || !data.success) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to edit entry</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Edited entry for "${row.Name}"</span>`); | |
| return row; | |
| }; | |
| export const deleteEntry = async (row: Row): Promise<Row | null> => { | |
| row.Orgs = Array.isArray(row.Orgs) ? row.Orgs : (row.Orgs as any).split(",").map((org: string) => org.trim()); | |
| row.Authors = Array.isArray(row.Authors) | |
| ? row.Authors | |
| : (row.Authors as any).split(",").map((author: string) => author.trim()); | |
| row.Tags = Array.isArray(row.Tags) ? row.Tags : (row.Tags as any).split(",").map((tag: string) => tag.trim()); | |
| const response = await fetch(baseURL + "/delete-entry", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| const data = await response.json(); | |
| if (data.error || !data.success) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to delete entry</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Deleted entry for "${row.Name}"</span>`); | |
| return row; | |
| }; | |
| export const inferFields = async (row: Row): Promise<Row | null> => { | |
| const key = row.Name || row.Paper || row.Code || row.Space || row.Model || row.Dataset || row.Project; | |
| statusMessage.set(`<span>Inferring fields for <b>${key}</b></span>`); | |
| const paper = row.Paper || (await inferPaper(row)); | |
| const code = row.Code || (await inferCode(row)); | |
| const name = row.Name || (await inferName(row)); | |
| if (!name) { | |
| return null; | |
| } | |
| row.Name = name; | |
| const authors = row.Authors.length == 0 ? await inferAuthors(row) : row.Authors; | |
| const orgs = row.Orgs.length == 0 ? await inferOrgs(row) : row.Orgs; | |
| const date = row.Date || (await inferDate(row)); | |
| const model = row.Model || (await inferModel(row)); | |
| const dataset = row.Dataset || (await inferDataset(row)); | |
| const space = row.Space || (await inferSpace(row)); | |
| const license = row.License || (await inferLicense(row)); | |
| if (paper) { | |
| row.Paper = paper; | |
| } | |
| if (code) { | |
| row.Code = code; | |
| } | |
| if (authors) { | |
| row.Authors = Array.isArray(authors) ? authors : authors.split(",").map((author: string) => author.trim()); | |
| } | |
| if (orgs) { | |
| row.Orgs = Array.isArray(orgs) ? orgs : orgs.split(",").map((org: string) => org.trim()); | |
| } | |
| if (date) { | |
| row.Date = date; | |
| } | |
| if (model) { | |
| row.Model = model; | |
| } | |
| if (dataset) { | |
| row.Dataset = dataset; | |
| } | |
| if (space) { | |
| row.Space = space; | |
| } | |
| if (license) { | |
| row.License = license; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Finished inferring fields for <b>${row.Name}</b></span>`); | |
| return row; | |
| }; | |
| const inferFieldType = async (row: Row, value: string): Promise<string | null> => { | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-field", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify({ value }), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.append( | |
| `<br><span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>` | |
| ); | |
| return null; | |
| } | |
| if (data.error || !data.field || !(data.field in row)) { | |
| statusMessage.set(`<span style="color: red;">Error: Failed to infer field type for <b>${value}</b></span>`); | |
| return null; | |
| } | |
| statusMessage.set(`<span style="color: green;">Inferred field type: ${data.field}</span>`); | |
| return data.field; | |
| }; | |
| const inferPaper = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring paper...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-paper", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring paper...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer paper</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring paper...</span>"); | |
| if (data.error || !data.paper) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer paper</span>`); | |
| } | |
| return null; | |
| } | |
| const link = `<a href="${data.paper}" target="_blank">${data.paper}</a>`; | |
| statusMessage.append(`<br><span style="color: green;">Inferred paper: ${link}</span>`); | |
| return data.paper; | |
| }; | |
| const inferCode = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring code...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-code", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring code...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer code</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring code...</span>"); | |
| if (data.error || !data.code) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer code</span>`); | |
| } | |
| return null; | |
| } | |
| const link = `<a href="${data.code}" target="_blank">${data.code}</a>`; | |
| statusMessage.append(`<br><span style="color: green;">Inferred code: ${link}</span>`); | |
| return data.code; | |
| }; | |
| const inferName = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring name...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-name", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring name...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer name</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring name...</span>"); | |
| if (data.error || !data.name) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer name</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred name: <b>${data.name}</b></span>`); | |
| return data.name; | |
| }; | |
| const inferAuthors = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring authors...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-authors", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring authors...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer authors</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring authors...</span>"); | |
| if (data.error || !data.authors) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer authors</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred authors: ${data.authors}</span>`); | |
| return data.authors; | |
| }; | |
| const inferOrgs = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring orgs...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-orgs", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring orgs...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer orgs</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring orgs...</span>"); | |
| if (data.error || !data.orgs) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer orgs</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred orgs: ${data.orgs}</span>`); | |
| return data.orgs; | |
| }; | |
| const inferDate = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring date...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-date", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring date...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer date</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring date...</span>"); | |
| if (data.error || !data.date) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer date</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred date: ${data.date}</span>`); | |
| return data.date; | |
| }; | |
| const inferModel = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring model...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-model", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring model...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer model</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring model...</span>"); | |
| if (data.error || !data.model) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer model</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred model: ${data.model}</span>`); | |
| return data.model; | |
| }; | |
| const inferDataset = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring dataset...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-dataset", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring dataset...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer dataset</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring dataset...</span>"); | |
| if (data.error || !data.dataset) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer dataset</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred dataset: ${data.dataset}</span>`); | |
| return data.dataset; | |
| }; | |
| const inferSpace = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring space...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-space", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring space...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer space</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring space...</span>"); | |
| if (data.error || !data.space) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer space</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred space: ${data.space}</span>`); | |
| return data.space; | |
| }; | |
| const inferLicense = async (row: Row) => { | |
| statusMessage.append(`<br><span>Inferring license...</span>`); | |
| let data; | |
| try { | |
| const response = await fetch(baseURL + "/infer-license", { | |
| method: "POST", | |
| headers: { | |
| "Content-Type": "application/json", | |
| Authorization: "Bearer " + import.meta.env.VITE_HF_TOKEN, | |
| }, | |
| body: JSON.stringify(row), | |
| }); | |
| data = await response.json(); | |
| } catch (e) { | |
| statusMessage.remove("<br><span>Inferring license...</span>"); | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer license</span>`); | |
| return null; | |
| } | |
| statusMessage.remove("<br><span>Inferring license...</span>"); | |
| if (data.error || !data.license) { | |
| if (data.error) { | |
| statusMessage.append(`<br><span style="color: red;">Error: ${data.error}</span>`); | |
| } else if (data.message) { | |
| statusMessage.append(`<br><span>${data.message}</span>`); | |
| } else { | |
| statusMessage.append(`<br><span style="color: red;">Error: Failed to infer license</span>`); | |
| } | |
| return null; | |
| } | |
| statusMessage.append(`<br><span style="color: green;">Inferred license: ${data.license}</span>`); | |
| return data.license; | |
| }; | |