Generic xml stream reader and "contains() -> in" refactor

Author: PrinsINT

server/src/main/kotlin/org/ivdnt/galahad/annotations/AnnotationReader.kt

@@ -1,10 +1,6 @@
 package org.ivdnt.galahad.annotations
 
-import java.io.File
-
-abstract class AnnotationReader(
-    protected val file: File
-) {
+abstract class AnnotationReader {
     val layer: Layer by lazy { read() }
 
     protected val documents: MutableList<DocumentLayer> = mutableListOf()

server/src/main/kotlin/org/ivdnt/galahad/annotations/LayerAligner.kt

@@ -0,0 +1,28 @@
+package org.ivdnt.galahad.annotations
+
+import org.ivdnt.galahad.evaluation.comparison.nextOrNull
+
+class LayerAligner(
+    val hypothesis: Layer,
+    val reference: Layer,
+): AnnotationReader() {
+    override fun read(): Layer {
+        val hypoIter = hypothesis.terms.iterator()
+
+        reference.documents.forEach { doc ->
+            doc.paragraphs.forEach { paragraph ->
+                paragraph.sentences.forEach { sentence ->
+                    sentence.terms.forEach { refTerm ->
+                        // TODO: implement alignment logic
+                        hypoIter.nextOrNull()?.also { hypoTerm ->
+                            if (hypoTerm.token == refTerm.token) {
+                                terms += hypoTerm.alignedTo(refTerm)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return Layer(documents.toTypedArray())
+    }
+}

server/src/main/kotlin/org/ivdnt/galahad/annotations/Term.kt

@@ -32,6 +32,10 @@ class Term(
     @get:JsonIgnore
     val ner: String? = annotations[Annotation.NER]
 
+    /**
+     * Returns a term with the same data, except its offset is aligned to that of [refTerm].
+     */
+    fun alignedTo(refTerm: Term): Term = Term(id, refTerm.offset, annotations, spaceAfter)
 
     fun isMulti(annotation: Annotation): Boolean = annotations[annotation]?.contains("+") == true
 
@@ -56,15 +60,15 @@ class Term(
         val annotation = annotations[annotationType] ?: return null
         // for NER
         if (annotationType == Annotation.NER) {
-            if (annotation.contains('-')) {
+            if ('-' in annotation) {
                 return annotation.split('-')[1]
             }
         }
         // for POS & UPOS
-        else if (listOf(Annotation.POS, Annotation.UPOS).contains(annotationType)) {
+        else if (annotationType in posAnnotations) {
             return if (isMulti(annotationType)) {
                 // Split on + and transform each part
-                annotation.split("+").map { singlePosToHead(it) }.joinToString("+")
+                annotation.split("+").joinToString("+") { singlePosToHead(it) }
             } else {
                 singlePosToHead(annotation)
             }
@@ -75,10 +79,11 @@ class Term(
 
     companion object {
         val EMPTY: Term = Term("", 0, mapOf(Annotation.TOKEN to ""))
+        private val posAnnotations: Array<Annotation> = arrayOf(Annotation.POS, Annotation.UPOS)
+        private val posHeadSeparators: Array<Char> = arrayOf('(', '|')
 
-        fun missingName(annotation: Annotation): String =
-            // simply uppercase and prepend "NO_"
-            "NO_${annotation.value.uppercase()}"
+        // simply uppercase and prepend "NO_"
+        fun missingName(annotation: Annotation): String = "NO_${annotation.value.uppercase()}"
 
         /** The features of [pos]. E.g. "num=sg" for "NOU(num=sg)". Does not support multi-pos. */
         fun features(pos: String?): String? {
@@ -91,9 +96,8 @@ class Term(
         }
 
         fun singlePosToHead(pos: String): String {
-            val separators = listOf('(', '|')
-            for (separator in separators) {
-                if (pos.contains(separator)) {
+            for (separator in posHeadSeparators) {
+                if (separator in pos) {
                     val head = pos.split(separator)[0]
                     // presumably head won't be empty, but this way we could
                     // parse something like (VRB) if anyone would ever use that

server/src/main/kotlin/org/ivdnt/galahad/app/Galahad.kt

@@ -91,7 +91,7 @@ class Galahad {
                     .description("Generating Linguistic Annotations for Historical Dutch")
                     .contact(Contact().name("GaLAHaD GitHub").url("https://github.com/instituutnederlandsetaal/galahad"))
             )
-        if (application_profile.contains("prod")) {
+        if ("prod" in application_profile) {
             api = api.servers(listOf(Server().url("/galahad/api").description("GaLAHaD API")))
         }
         return api

server/src/main/kotlin/org/ivdnt/galahad/app/User.kt

@@ -12,10 +12,9 @@ class User(
         private val ADMIN_FILE: File = File("data/admins/admins.txt")
         private val DEFAULT_USER: User get() = User(id = USERNAME, isAdmin = isAdmin(USERNAME))
 
-        private fun isAdmin(string: String): Boolean {
+        private fun isAdmin(username: String): Boolean {
             if (!ADMIN_FILE.exists()) return false // When no admins are set, no one is admin by default
-            return ADMIN_FILE.readLines().map { it.trim() }
-                .contains(string) // Otherwise only declared admins are admins
+            return username in ADMIN_FILE.readLines().map { it.trim() } // Otherwise only declared admins are admins
         }
 
         fun fromRequest(request: HttpServletRequest?): User {

server/src/main/kotlin/org/ivdnt/galahad/corpora/MutableCorpusMetadata.kt

@@ -38,13 +38,13 @@ open class MutableCorpusMetadata(
      * Whether the user is in the list of collaborators of this corpus.
      * Note that this is not the same as having write access: use [hasWriteAccess].
      */
-    fun isCollaborator(user: User): Boolean = collaborators.contains(user.id) == true
+    fun isCollaborator(user: User): Boolean = user.id in collaborators
 
     /**
      * Whether the user is in the list of viewers of this corpus.
      * Note that this is not the same as having read access: use [hasReadAccess].
      */
-    fun isViewer(user: User): Boolean = viewers.contains(user.id) == true
+    fun isViewer(user: User): Boolean = user.id in viewers
 
     /** To have write access, you need to be an owner, collaborator or admin. */
     fun hasWriteAccess(user: User): Boolean {
@@ -165,7 +165,7 @@ open class MutableCorpusMetadata(
             newMeta.viewers.remove(newMeta.owner)
 
             // Remove collaborators from list of viewers
-            newMeta.viewers.removeIf { newMeta.collaborators.contains(it) }
+            newMeta.viewers.removeIf { it in newMeta.collaborators }
 
             return newMeta
         }

server/src/main/kotlin/org/ivdnt/galahad/evaluation/comparison/LayerComparison.kt

@@ -8,7 +8,7 @@ import org.ivdnt.galahad.export.DocumentExport
 fun Iterator<Term>.nextOrNull(): Term? = if (hasNext()) next() else null
 
 // Some hardcoded punctuation
-val PUNCTUATION: List<String> = listOf(",", ".", "?", "!", ":", ";", ")", "(", "'", "\"")
+val PUNCTUATION: Array<Char> = arrayOf(',', '.', '?', '!', ':', ';', ')', '(', '\'', '"')
 
 /**
  * Match the [Layer.terms] of two layers based on their [WordForm] position (offset and length)
@@ -148,7 +148,7 @@ open class LayerComparison(
         }
 
         fun truncatePC(str: String): String {
-            return if (str.isNotEmpty() && PUNCTUATION.contains(str.last().toString())) {
+            return if (str.isNotEmpty() && str.last() in PUNCTUATION) {
                 str.slice(0 until str.lastIndex)
             } else {
                 str

server/src/main/kotlin/org/ivdnt/galahad/evaluation/confusion/Confusion.kt

@@ -100,11 +100,11 @@ open class Confusion(private val truncate: Boolean = true, val annotation: Annot
     private fun add(pos1: String, pos2: String, evaluationEntry: EvaluationEntry) {
         when {
             // Complex pos are mapped to a single category
-            pos1.contains('+') -> add(MULTIPLE_POS, pos2, evaluationEntry)
-            pos2.contains('+') -> add(pos1, MULTIPLE_POS, evaluationEntry)
+            '+' in pos1 -> add(MULTIPLE_POS, pos2, evaluationEntry)
+            '+' in pos2 -> add(pos1, MULTIPLE_POS, evaluationEntry)
             // Non-alphabetical pos are mapped to a single category "other"
-            pos1.contains(Regex(OTHER_POS_REGEX)) -> add(OTHER_POS, pos2, evaluationEntry)
-            pos2.contains(Regex(OTHER_POS_REGEX)) -> add(pos1, OTHER_POS, evaluationEntry)
+            Regex(OTHER_POS_REGEX) in pos1 -> add(OTHER_POS, pos2, evaluationEntry)
+            Regex(OTHER_POS_REGEX) in pos2 -> add(pos1, OTHER_POS, evaluationEntry)
             // Otherwise a simple merge
             else -> matrix.merge(Pair(pos1, pos2), evaluationEntry) { a, b -> EvaluationEntry.add(a, b, truncate) }
         }

server/src/main/kotlin/org/ivdnt/galahad/export/CorpusExport.kt

@@ -12,10 +12,7 @@ import org.ivdnt.galahad.exceptions.MergeNotImplementedException
 import org.ivdnt.galahad.taggers.Tagger
 import org.ivdnt.galahad.util.FileMapper
 import org.ivdnt.galahad.util.createZipFile
-import java.io.File
 import java.io.OutputStream
-import java.nio.file.Files
-import kotlin.io.path.createTempDirectory
 
 class CorpusExport private constructor(
     val corpus: Corpus,
@@ -26,7 +23,6 @@ class CorpusExport private constructor(
     val tagger: Tagger,
     val shouldMerge: Boolean,
 ) : Logging {
-
     private fun mergeFormatMatches(
         it: Document, format: DocumentFormat,
     ): Boolean {
@@ -38,7 +34,6 @@ class CorpusExport private constructor(
         return otherFormat == format
     }
 
-
     private fun formatMapper(doc: Document, out: OutputStream) {
         try {
             // Document conversions.
@@ -64,8 +59,16 @@ class CorpusExport private constructor(
         out: OutputStream,
     ) {
         val documents = corpus.documents.readAll().filter { DocumentExport.create(this, it).layer != Layer.EMPTY }
-        val seq: Sequence<FileMapper> = documents.asSequence().map { doc -> doc.name to { out -> formatMapper(doc, out) } }
-        val seqCmdi: Sequence<FileMapper> = documents.asSequence().map { doc -> "metadata/CMDI-${doc.uploadedFile.nameWithoutExtension}.xml" to { out -> DocumentExport.create(this, doc).cmdi(out) } }
+        val seq: Sequence<FileMapper> =
+            documents.asSequence().map { doc -> doc.name to { out -> formatMapper(doc, out) } }
+        val seqCmdi: Sequence<FileMapper> = documents.asSequence().map { doc ->
+            "metadata/CMDI-${doc.uploadedFile.nameWithoutExtension}.xml" to { out ->
+                DocumentExport.create(
+                    this,
+                    doc
+                ).cmdi(out)
+            }
+        }
         createZipFile(seq + seqCmdi, out, includeCMDI = true)
     }
 

server/src/main/kotlin/org/ivdnt/galahad/export/LayerConverter.kt

@@ -11,7 +11,7 @@ import org.ivdnt.galahad.formats.tsv.TsvConverter
 import org.ivdnt.galahad.formats.txt.TxtConverter
 import java.io.OutputStream
 
-abstract class LayerConverter(protected val export: DocumentExport) {
+abstract class LayerConverter protected constructor(protected val export: DocumentExport) {
     abstract fun convert(out: OutputStream)
 
     companion object {