Cache Confusion Evaluation

Author: PrinsINT

client/src/api/evaluation.ts

@@ -5,10 +5,10 @@
 import axios, { type AxiosResponse } from "axios"
 import { getBlob, type BlobResponse } from "@/api/utils"
 import type { UUID } from "@/types/corpora"
-import type { ConfusionWrapper, DistributionWrapper, Metrics, TermComparison } from "@/types/evaluation"
+import type { Confusion, DistributionWrapper, Metrics, TermComparison } from "@/types/evaluation"
 import type { DocumentEntities, JobEntities, JobsEntities } from "@/types/evaluation/entities"
 
-type ConfusionResponse = AxiosResponse<ConfusionWrapper>
+type ConfusionResponse = AxiosResponse<Confusion>
 type DistributionResponse = AxiosResponse<DistributionWrapper>
 type MetricsResponse = AxiosResponse<Metrics>
 type DocumentEntitiesResponse = AxiosResponse<DocumentEntities>

client/src/components/modals/ComparisonModal.vue

@@ -32,7 +32,7 @@
 import * as API from "@/api/evaluation"
 import * as Utils from "@/api/utils"
 import stores from "@/stores"
-import { literalsForTermComparison } from "@/stores/evaluation"
+import { literalsForTermComparison } from "@/ts/termcomparison"
 import type { TermComparison } from "@/types/evaluation"
 
 // Stores
@@ -57,8 +57,8 @@ const title = computed<string>(() => {
 })
 const annotations = computed(() => {
     const firstSample = props.samples.samples[0]
-    const hypoAnnotations = Object.keys(firstSample.hypoTerm.annotations)
-    const refAnnotations = Object.keys(firstSample.refTerm.annotations)
+    const hypoAnnotations = Object.keys(firstSample.hyp.annotations)
+    const refAnnotations = Object.keys(firstSample.ref.annotations)
     return [...new Set([...hypoAnnotations, ...refAnnotations])].filter((i) => !ignorableAnnotations.includes(i))
 })
 
@@ -93,10 +93,10 @@ const filteredColumns = computed(() => {
 const items = computed(() => {
     if (!props.samples.samples) return []
     return props.samples.samples.map((sample: TermComparison) => {
-        const hypoAnnotations = Object.entries(sample.hypoTerm.annotations).map((i) => ({
+        const hypoAnnotations = Object.entries(sample.hyp.annotations).map((i) => ({
             [`${props.hypothesisJob}-${i[0]}`]: i[1],
         }))
-        const refAnnotations = Object.entries(sample.refTerm.annotations).map((i) => ({
+        const refAnnotations = Object.entries(sample.ref.annotations).map((i) => ({
             [`${props.referenceJob}-${i[0]}`]: i[1],
         }))
 

client/src/components/tables/DocumentsTable.vue

@@ -31,9 +31,9 @@
 
         <template #cell-actions="data: TableData<DocumentMetadata>">
             <GForm gap=".25rem">
-                <DownloadButton @click="downloadRaw(data.item.name)" />
+                <DownloadButton @click="download(data.item.name)" />
 
-                <GButton red title="Delete" @click="deleteDocumentData = data.item">
+                <GButton red title="Delete" @click="deleteDocument = data.item">
                     <i class="fa fa-trash"></i>
                 </GButton>
             </GForm>
@@ -45,10 +45,10 @@
     </GModal>
 
     <DeleteModal
-        v-if="deleteDocumentData"
-        :itemName="`${deleteDocumentData.name} and associated results`"
-        @hide="deleteDocumentData = undefined"
-        @delete="deleteDocument(deleteDocumentData.name)"
+        v-if="deleteDocument"
+        :itemName="`${deleteDocument.name} and associated results`"
+        @hide="deleteDocument = undefined"
+        @delete="remove(deleteDocument.name)"
     />
 </template>
 
@@ -60,7 +60,7 @@ import type { DocumentMetadata } from "@/types/documents"
 import { type Column, type TableData, DocsTableType } from "@/types/ui/table"
 
 // Stores
-const { deleteDocument, downloadRaw } = stores.useDocuments()
+const { remove, download } = stores.useDocuments()
 const { canWrite } = storeToRefs(stores.useUser())
 
 // --- props ---
@@ -72,7 +72,7 @@ const { type, corpus, documents, loading } = defineProps<{
 }>()
 
 // --- data ---
-const deleteDocumentData = ref<DocumentMetadata>()
+const deleteDocument = ref<DocumentMetadata>()
 const previewDocument = ref<DocumentMetadata>()
 
 // --- computed ---

client/src/stores/corpora.ts

@@ -53,8 +53,6 @@ const useCorpora = defineStore("corpora", () => {
         API.patchCorpus(metadata.uuid, metadata).finally(reload)
     }
 
-    reload()
-
     return {
         corpora,
         loading,

client/src/stores/documents.ts

@@ -1,12 +1,9 @@
-// Libraries & stores
 import { plausible } from "@/ts/plausible"
 import * as API from "@/api/documents"
-import { documentsPath } from "@/api/documents"
 import * as Utils from "@/api/utils"
 import stores from "@/stores"
-// Types & API
-import { type DocumentMetadata, Format } from "@/types/documents"
-import { useAxios } from "@/api/useAxios"
+import { type DocumentMetadata } from "@/types/documents"
+import { addContentTypeHeader, fileExtension } from "@/ts/file"
 
 // Custom types
 type FileStatus = { status: "busy" | "success" | "error"; message?: string }
@@ -17,20 +14,12 @@ type FileStatus = { status: "busy" | "success" | "error"; message?: string }
  */
 const documents = defineStore("documents", () => {
     // Stores
-    const errors = stores.useErrors()
     const { corpusId, corpus } = storeToRefs(stores.useCorpora())
     const { reload: reloadCorpora } = stores.useCorpora()
 
     // Fields
-    const {
-        data: documents,
-        loading,
-        reload,
-    } = useAxios<DocumentMetadata[]>(
-        (): string | undefined => (corpusId.value ? documentsPath(corpusId.value) : undefined),
-        [],
-    )
-
+    const loading = ref<boolean>(false)
+    const documents = ref<DocumentMetadata[]>([])
     const numSourceAnnotations = computed(() => documents.value.filter((i) => i.summary?.annotations.token > 0).length)
     const uploading: Record<string, FileStatus> = reactive({})
     const uploadBusyCount = computed(() => Object.values(uploading).filter((i) => i.status === "busy").length)
@@ -43,36 +32,34 @@ const documents = defineStore("documents", () => {
         })
     })
 
-    /**
-     * Delete a document.
-     * @param name Document name.
-     */
-    function deleteDocument(name: string): void {
+    /** Reload documents and corpora (number of docs in corpusmetadata can change). */
+    function reload(): void {
+        reloadCorpora()
+        loading.value = true
+        API.getDocuments(corpusId.value)
+            .then((res) => (documents.value = res.data))
+            .finally(() => (loading.value = false))
+    }
+
+    /** Delete a document. */
+    function remove(name: string): void {
         plausible.documentDeleted(corpus.value, getDocument(name))
         API.deleteDocument(corpusId.value, name)
-            .catch((error) => errors.handle(error))
             .finally(reload)
     }
 
-    /**
-     * Download original source document.
-     * @param name Document name.
-     */
-    function downloadRaw(name: string): void {
+    /** Download original source document. */
+    function download(name: string): void {
         plausible.documentDownloaded(corpus.value, getDocument(name))
         API.getRawDocument(corpusId.value, name)
             .then(Utils.browserDownloadResponseFile)
-            .catch((res) => Utils.handleBlobError(res, "download raw document", errors))
     }
 
     function getDocument(name: string): DocumentMetadata {
         return documents.value.find((d: DocumentMetadata) => d.name === name) as DocumentMetadata
     }
 
-    /**
-     * Upload all files in filesToUpload.
-     * Creates timeouts to spread load.
-     */
+    /** Upload all files in filesToUpload. Creates timeouts to spread load. */
     function uploadAll(): void {
         for (let i = 0; i < filesToUpload.value.length; i++) {
             const formData = new FormData()
@@ -86,45 +73,13 @@ const documents = defineStore("documents", () => {
         filesToUpload.value = []
     }
 
-    /**
-     * Clear errors from not yet uploaded files.
-     */
+    /** Clear errors from not yet uploaded files. */
     function clearUploadErrors(): void {
         Object.keys(uploading).forEach((key) => {
             if (uploading[key].status === "error") delete uploading[key]
         })
     }
 
-    /**
-     * Add content type header.
-     * @param fd FormData with file to upload.
-     * @param contentType Content type header.
-     * @param exts File extensions to apply the content type header to.
-     */
-    function addContentTypeHeader(fd: FormData): Record<string, string> | null {
-        const exts_and_headers = {
-            tsv: "text/tab-separated-values",
-            conllu: "text/tab-separated-values",
-            naf: "text/xml",
-        }
-
-        let file = fd.get("file") as File
-        const extension = fileExtension(file)
-        let header = null
-
-        if (Object.keys(exts_and_headers).includes(extension)) {
-            const contentType = exts_and_headers[extension]
-            file = new File([file], file.name, { type: contentType })
-            header = { "Content-Type": contentType }
-            fd.set("file", file)
-        }
-        return header
-    }
-
-    function fileExtension(file: File): string {
-        return file.name.split(".").at(-1)
-    }
-
     /**
      * Upload a single file. Takes http content type header into account.
      * @param formData FormData with file to upload.
@@ -147,25 +102,10 @@ const documents = defineStore("documents", () => {
             .finally(() => {
                 if (uploadBusyCount.value === 0) {
                     reload()
-                    reloadCorpora()
                 }
             })
     }
 
-    /**
-     * Checks if the documentsStore.documents contains at least one file of the given format.
-     */
-    function containsFormat(format: Format): boolean {
-        return documents.value.some((i) => {
-            // Overwrite the format for legacy formats.
-            let otherFormat = i.format
-            if (otherFormat === Format.TEI_P5_LEGACY) {
-                otherFormat = Format.TEI_P5
-            }
-            return otherFormat === format
-        })
-    }
-
     // Exports
     return {
         // Fields
@@ -178,11 +118,11 @@ const documents = defineStore("documents", () => {
         uploadErrorCount,
         numSourceAnnotations,
         // Methods
-        deleteDocument,
-        downloadRaw,
+        reload,
+        remove,
+        download,
         uploadAll,
         clearUploadErrors,
-        containsFormat,
     }
 })
 

client/src/stores/errors.ts

@@ -16,7 +16,7 @@ const useErrors = defineStore("errors", () => {
     }
 
     setupErrorHandler()
-    
+
     return { errors }
 })
 

client/src/stores/evaluation.ts

@@ -1,61 +1,22 @@
-// Libraries & stores
-
-// API & types
+import stores from "@/stores"
 import * as API from "@/api/evaluation"
 import * as Utils from "@/api/utils"
-import stores from "@/stores"
-import type { UUID } from "@/types/corpora"
-import type { Term, TermComparison } from "@/types/evaluation"
-
-// For some reason the terms are undefined sometimes
-// We handle it here
-export function literalsForTerm(term: Term): string {
-    return term.annotations.token
-}
-
-export function literalsForTermComparison(termComparison: TermComparison): string {
-    // the literals could be different for term1 and term2
-    if (
-        literalsForTerm(termComparison.hypoTerm) === literalsForTerm(termComparison.refTerm) ||
-        literalsForTerm(termComparison.refTerm) === ""
-    ) {
-        return literalsForTerm(termComparison.hypoTerm)
-    }
-    if (literalsForTerm(termComparison.hypoTerm) === "") {
-        return literalsForTerm(termComparison.refTerm)
-    }
-    return `MISMATCH: [${literalsForTerm(termComparison.hypoTerm)} — ${literalsForTerm(termComparison.refTerm)}]`
-}
 
-/**
- * Used to download the evaluation CSV zip.
- */
+/** Used to download the evaluation CSV zip. */
 const useEvaluation = defineStore("evaluation", () => {
-    // Stores
-    const errors = stores.useErrors()
-    const corporaStore = stores.useCorpora()
-    const jobSelection = stores.useJobSelection()
+    const { corpusId } = storeToRefs(stores.useCorpora())
+    const { hypothesisId, referenceId } = storeToRefs(stores.useJobSelection())
 
-    // Fields
     const loading = ref<boolean>()
-    /** Hypothesis, reference and corpusUUID for which the current evaluations are loaded. */
-    const hypothesis = ref<string>()
-    const reference = ref<string>()
-    const corpusUUID = ref<UUID>()
 
-    // Methods
     function downloadCSV(): void {
         loading.value = true
-        API.getDownloadEvaluation(corporaStore.corpusId, jobSelection.hypothesisId, jobSelection.referenceId)
+        API.getDownloadEvaluation(corpusId.value, hypothesisId.value, referenceId.value)
             .then(Utils.browserDownloadResponseFile)
-            .catch((error) => Utils.handleBlobError(error, "download evaluation", errors))
-            .finally(() => {
-                loading.value = false
-            })
+            .finally(() => loading.value = false)
     }
 
-    // Exports
-    return { downloadCSV, loading, hypothesis, reference, corpusUUID }
+    return { downloadCSV, loading }
 })
 
 export default useEvaluation

client/src/stores/evaluation/confusion.ts

@@ -1,23 +1,23 @@
-import { confusionPath } from "@/api/evaluation"
-import { useAxios } from "@/api/useAxios"
 import stores from "@/stores"
-import type { ConfusionWrapper } from "@/types/evaluation"
+import type { Confusion } from "@/types/evaluation"
+import * as API from "@/api/evaluation"
 
 /** Stores and fetches the confusion matrix. */
 const useConfusion = defineStore("confusion", () => {
     const { hypothesisId, referenceId } = storeToRefs(stores.useJobSelection())
     const { corpusId } = storeToRefs(stores.useCorpora())
-    const url = computed<string>(() => {
-        if (!(hypothesisId.value && referenceId.value)) return undefined
-        return confusionPath(corpusId.value)
-    })
-    const { loading, data: confusion } = useAxios<ConfusionWrapper>(
-        url,
-        {},
-        { hypothesis: hypothesisId.value, reference: referenceId.value },
-    )
+    const loading = ref<boolean>(false)
+    const confusions = ref<Record<string, Confusion>>()
 
-    return { confusion, loading }
+    function reload(): void {
+        if (!corpusId.value || !hypothesisId.value || !referenceId.value) return
+        loading.value = true
+        API.getConfusion(corpusId.value, hypothesisId.value, referenceId.value)
+            .then((res) => (confusions.value = res.data))
+            .finally(() => (loading.value = false))
+    }
+
+    return { reload, confusions, loading }
 })
 
 export default useConfusion