bids-validator-deno 2.0.11__tar.gz → 2.1.0__tar.gz

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bids-validator-deno
-Version: 2.0.11
+Version: 2.1.0
 Summary: Typescript implementation of the BIDS validator
 Keywords: BIDS,BIDS validator
 Author: bids-standard developers

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@bids/validator",
-  "version": "2.0.11",
+  "version": "2.1.0",
   "exports": {
     ".": "./src/bids-validator.ts",
     "./main": "./src/main.ts",
@@ -28,7 +28,7 @@
   },
   "imports": {
     "@ajv": "npm:ajv@8.17.1",
-    "@bids/schema": "jsr:@bids/schema@~1.0.14",
+    "@bids/schema": "jsr:@bids/schema@~1.1.0",
     "@cliffy/command": "jsr:@effigies/cliffy-command@1.0.0-dev.8",
     "@cliffy/table": "jsr:@effigies/cliffy-table@1.0.0-dev.5",
     "@hed/validator": "npm:hed-validator@4.0.1",

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/pyproject.toml

@@ -18,7 +18,7 @@ keywords = [
     "BIDS validator",
 ]
 dynamic = []
-version = "2.0.11"
+version = "2.1.0"
 
 [project.license]
 text = "MIT"

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/bids-validator.ts

@@ -6,3 +6,4 @@ const errors = result.issues.get({ severity: 'error' })
 if (errors.length) {
   Deno.exit(16)
 }
+Deno.exit(0)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/files/nifti.test.ts

@@ -1,8 +1,8 @@
-import { assert, assertObjectMatch } from '@std/assert'
+import { assert, assertEquals, assertObjectMatch } from '@std/assert'
 import { FileIgnoreRules } from './ignore.ts'
 import { BIDSFileDeno } from './deno.ts'
 
-import { loadHeader } from './nifti.ts'
+import { loadHeader, axisCodes } from './nifti.ts'
 
 Deno.test('Test loading nifti header', async (t) => {
   const ignore = new FileIgnoreRules([])
@@ -73,3 +73,26 @@ Deno.test('Test loading nifti header', async (t) => {
     })
   })
 })
+
+Deno.test('Test extracting axis codes', async (t) => {
+  await t.step('Identify RAS', async () => {
+    const affine = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['R', 'A', 'S'])
+  })
+  await t.step('Identify LPS (flips)', async () => {
+    const affine = [[-1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['L', 'P', 'S'])
+  })
+  await t.step('Identify SPL (flips + swap)', async () => {
+    const affine = [[0, 0, -1, 0], [0, -1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['S', 'P', 'L'])
+  })
+  await t.step('Identify SLP (flips + rotate)', async () => {
+    const affine = [[0, -1, 0, 0], [0, 0, -1, 0], [1, 0, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['S', 'L', 'P'])
+  })
+  await t.step('Identify ASR (rotate)', async () => {
+    const affine = [[0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1]]
+    assertEquals(axisCodes(affine), ['A', 'S', 'R'])
+  })
+})

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/files/nifti.ts

@@ -65,8 +65,91 @@ export async function loadHeader(file: BIDSFile): Promise<NiftiHeader> {
       },
       qform_code: header.qform_code,
       sform_code: header.sform_code,
+      axis_codes: axisCodes(header.affine),
     } as NiftiHeader
   } catch (err) {
     throw { code: 'NIFTI_HEADER_UNREADABLE' }
   }
 }
+
+/** Vector addition */
+function add(a: number[], b: number[]): number[] {
+  return a.map((x, i) => x + b[i])
+}
+
+/** Vector subtraction */
+function sub(a: number[], b: number[]): number[] {
+  return a.map((x, i) => x - b[i])
+}
+
+/** Scalar multiplication */
+function scale(vec: number[], scalar: number): number[] {
+  return vec.map((x) => x * scalar)
+}
+
+/** Dot product */
+function dot(a: number[], b: number[]): number {
+  return a.map((x, i) => x * b[i]).reduce((acc, x) => acc + x, 0)
+}
+
+function argMax(arr: number[]): number {
+  return arr.reduce((acc, x, i) => (x > arr[acc] ? i : acc), 0)
+}
+
+/**
+ * Identify the nearest principle axes of an image affine.
+ *
+ * Affines transform indices in a data array into mm right, anterior and superior of
+ * an origin in "world coordinates". If moving along an axis in the positive direction
+ * predominantly moves right, that axis is labeled "R".
+ *
+ * @example The identity matrix is in "RAS" orientation:
+ *
+ * # Usage
+ *
+ * ```ts
+ * const affine = [[1, 0, 0, 0],
+ *                 [0, 1, 0, 0],
+ *                 [0, 0, 1, 0],
+ *                 [0, 0, 0, 1]]
+ *
+ * axisCodes(affine)
+ * ```
+ *
+ * # Result
+ * ```ts
+ * ['R', 'A', 'S']
+ * ```
+ *
+ * @returns character codes describing the orientation of an image affine.
+ */
+export function axisCodes(affine: number[][]): string[] {
+  // This function is an extract of the Python function transforms3d.affines.decompose44
+  // (https://github.com/matthew-brett/transforms3d/blob/6a43a98/transforms3d/affines.py#L10-L153)
+  //
+  // As an optimization, this only orthogonalizes the basis,
+  // and does not normalize to unit vectors.
+
+  // Operate on columns, which are the cosines that project input coordinates onto output axes
+  const [cosX, cosY, cosZ] = [0, 1, 2].map((j) => [0, 1, 2].map((i) => affine[i][j]))
+
+  // Orthogonalize cosY with respect to cosX
+  const orthY = sub(cosY, scale(cosX, dot(cosX, cosY)))
+
+  // Orthogonalize cosZ with respect to cosX and orthY
+  const orthZ = sub(
+    cosZ, add(scale(cosX, dot(cosX, cosZ)), scale(orthY, dot(orthY, cosZ)))
+  )
+
+  const basis = [cosX, orthY, orthZ]
+  const maxIndices = basis.map((row) => argMax(row.map(Math.abs)))
+
+  // Check that indices are 0, 1 and 2 in some order
+  if (maxIndices.toSorted().some((idx, i) => idx !== i)) {
+    throw { key: 'AMBIGUOUS_AFFINE' }
+  }
+
+  // Positive/negative codes for each world axis
+  const codes = ['RL', 'AP', 'SI']
+  return maxIndices.map((idx, i) => codes[idx][basis[i][idx] > 0 ? 0 : 1])
+}

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/files/tsv.test.ts

@@ -6,7 +6,7 @@ import {
   assertStrictEquals,
 } from '@std/assert'
 import { pathToFile } from './filetree.ts'
-import { loadTSV } from './tsv.ts'
+import { loadTSV, loadTSVGZ } from './tsv.ts'
 import { streamFromString } from '../tests/utils.ts'
 import { ColumnsMap } from '../types/columns.ts'
 
@@ -64,7 +64,7 @@ Deno.test('TSV loading', async (t) => {
     try {
       await loadTSV(file)
     } catch (e: any) {
-      assertObjectMatch(e, { code: 'TSV_EQUAL_ROWS', location: '/mismatched_row.tsv', line: 3 })
+      assertObjectMatch(e, { code: 'TSV_EQUAL_ROWS', line: 3 })
     }
   })
 
@@ -178,3 +178,112 @@ Deno.test('TSV loading', async (t) => {
   // Tests will have populated the memoization cache
   loadTSV.cache.clear()
 })
+
+Deno.test('TSVGZ loading', async (t) => {
+  await t.step('No header and empty file produces empty map', async () => {
+    const file = pathToFile('/empty.tsv.gz')
+    file.stream = streamFromString('').pipeThrough(new CompressionStream('gzip'))
+
+    const map = await loadTSVGZ(file, [])
+    // map.size looks for a column called map, so work around it
+    assertEquals(Object.keys(map).length, 0)
+  })
+
+  await t.step('Empty file produces header-only map', async () => {
+    const file = pathToFile('/empty.tsv.gz')
+    file.stream = streamFromString('').pipeThrough(new CompressionStream('gzip'))
+
+    const map = await loadTSVGZ(file, ['a', 'b', 'c'])
+    assertEquals(map.a, [])
+    assertEquals(map.b, [])
+    assertEquals(map.c, [])
+  })
+
+  await t.step('Single column file produces single column maps', async () => {
+    const file = pathToFile('/single_column.tsv')
+    file.stream = streamFromString('1\n2\n3\n').pipeThrough(new CompressionStream('gzip'))
+
+    const map = await loadTSVGZ(file, ['a'])
+    assertEquals(map.a, ['1', '2', '3'])
+  })
+
+  await t.step('Mismatched header length throws issue', async () => {
+    const file = pathToFile('/single_column.tsv.gz')
+    file.stream = streamFromString('1\n2\n3\n').pipeThrough(new CompressionStream('gzip'))
+
+    try {
+      await loadTSVGZ(file, ['a', 'b'])
+    } catch (e: any) {
+      assertObjectMatch(e, { code: 'TSV_EQUAL_ROWS', line: 1 })
+    }
+  })
+
+  await t.step('Missing final newline is ignored', async () => {
+    const file = pathToFile('/missing_newline.tsv.gz')
+    file.stream = streamFromString('1\n2\n3').pipeThrough(new CompressionStream('gzip'))
+
+    const map = await loadTSVGZ(file, ['a'])
+    assertEquals(map.a, ['1', '2', '3'])
+  })
+
+  await t.step('Empty row throws issue', async () => {
+    const file = pathToFile('/empty_row.tsv.gz')
+    file.stream = streamFromString('1\t2\t3\n\n4\t5\t6\n').pipeThrough(new CompressionStream('gzip'))
+
+    try {
+      await loadTSVGZ(file, ['a', 'b', 'c'])
+    } catch (e: any) {
+      assertObjectMatch(e, { code: 'TSV_EMPTY_LINE', line: 2 })
+    }
+  })
+
+  await t.step('Mislabeled TSV throws issue', async () => {
+    const file = pathToFile('/mismatched_row.tsv.gz')
+    file.stream = streamFromString('a\tb\tc\n1\t2\t3\n4\t5\n')
+
+    try {
+      await loadTSVGZ(file, ['a', 'b', 'c'])
+    } catch (e: any) {
+      assertObjectMatch(e, { code: 'INVALID_GZIP' })
+    }
+  })
+
+  await t.step('maxRows limits the number of rows read', async () => {
+    const file = pathToFile('/long.tsv.gz')
+    // Use 1500 to avoid overlap with default initial capacity
+    const headers = ['a', 'b', 'c']
+    const text = '1\t2\t3\n'.repeat(1500)
+    file.stream = streamFromString(text).pipeThrough(new CompressionStream('gzip'))
+
+    let map = await loadTSVGZ(file, headers, 0)
+    assertEquals(map.a, [])
+    assertEquals(map.b, [])
+    assertEquals(map.c, [])
+
+    file.stream = streamFromString(text).pipeThrough(new CompressionStream('gzip'))
+    map = await loadTSVGZ(file, headers, 1)
+    assertEquals(map.a, ['1'])
+    assertEquals(map.b, ['2'])
+    assertEquals(map.c, ['3'])
+
+    file.stream = streamFromString(text).pipeThrough(new CompressionStream('gzip'))
+    map = await loadTSVGZ(file, headers, 2)
+    assertEquals(map.a, ['1', '1'])
+    assertEquals(map.b, ['2', '2'])
+    assertEquals(map.c, ['3', '3'])
+
+    file.stream = streamFromString(text).pipeThrough(new CompressionStream('gzip'))
+    map = await loadTSVGZ(file, headers, -1)
+    assertEquals(map.a, Array(1500).fill('1'))
+    assertEquals(map.b, Array(1500).fill('2'))
+    assertEquals(map.c, Array(1500).fill('3'))
+
+    // Check that maxRows does not truncate shorter files
+    file.stream = streamFromString('1\t2\t3\n4\t5\t6\n7\t8\t9\n').pipeThrough(new CompressionStream('gzip'))
+    map = await loadTSVGZ(file, headers, 4)
+    assertEquals(map.a, ['1', '4', '7'])
+    assertEquals(map.b, ['2', '5', '8'])
+    assertEquals(map.c, ['3', '6', '9'])
+  })
+
+})

bids_validator_deno-2.1.0/src/files/tsv.ts

@@ -0,0 +1,101 @@
+/*
+ * TSV
+ * Module for parsing TSV
+ */
+import { TextLineStream } from '@std/streams'
+import { ColumnsMap } from '../types/columns.ts'
+import type { BIDSFile } from '../types/filetree.ts'
+import { filememoizeAsync } from '../utils/memoize.ts'
+import { createUTF8Stream } from './streams.ts'
+
+async function loadColumns(
+  reader: ReadableStreamDefaultReader<string>,
+  headers: string[],
+  maxRows: number,
+  startRow: number = 0,
+): Promise<ColumnsMap> {
+  // Initialize columns in array for construction efficiency
+  const initialCapacity = maxRows >= 0 ? maxRows : 1000
+  const columns: string[][] = headers.map(() => new Array<string>(initialCapacity))
+
+  maxRows = maxRows >= 0 ? maxRows : Infinity
+  let rowIndex = 0 // Keep in scope after loop
+  for (; rowIndex < maxRows; rowIndex++) {
+    const { done, value } = await reader.read()
+    if (done) break
+
+    // Expect a newline at the end of the file, but otherwise error on empty lines
+    if (!value) {
+      const nextRow = await reader.read()
+      if (nextRow.done) break
+      throw { code: 'TSV_EMPTY_LINE', line: rowIndex + startRow + 1 }
+    }
+
+    const values = value.split('\t')
+    if (values.length !== headers.length) {
+      throw { code: 'TSV_EQUAL_ROWS', line: rowIndex + startRow + 1 }
+    }
+    columns.forEach((column, columnIndex) => {
+      // Double array size if we exceed the current capacity
+      if (rowIndex >= column.length) {
+        column.length = column.length * 2
+      }
+      column[rowIndex] = values[columnIndex]
+    })
+  }
+
+  // Construct map, truncating columns to number of rows read
+  return new ColumnsMap(
+    headers.map((header, index) => [header, columns[index].slice(0, rowIndex)]),
+  )
+}
+
+export async function loadTSVGZ(
+  file: BIDSFile,
+  headers: string[],
+  maxRows: number = -1,
+): Promise<ColumnsMap> {
+  const reader = file.stream
+    .pipeThrough(new DecompressionStream('gzip'))
+    .pipeThrough(createUTF8Stream())
+    .pipeThrough(new TextLineStream())
+    .getReader()
+
+  try {
+    return await loadColumns(reader, headers, maxRows)
+  } catch (e: any) {
+    // Cancel the reader if we interrupted the read
+    // Cancelling for I/O errors will just re-trigger the error
+    if (e.code) {
+      await reader.cancel()
+      throw e
+    }
+    throw { code: 'INVALID_GZIP', location: file.path }
+  }
+}
+
+async function _loadTSV(file: BIDSFile, maxRows: number = -1): Promise<ColumnsMap> {
+  const reader = file.stream
+    .pipeThrough(createUTF8Stream())
+    .pipeThrough(new TextLineStream())
+    .getReader()
+
+  try {
+    const headerRow = await reader.read()
+    const headers = (headerRow.done || !headerRow.value) ? [] : headerRow.value.split('\t')
+
+    if (new Set(headers).size !== headers.length) {
+      throw {
+        code: 'TSV_COLUMN_HEADER_DUPLICATE',
+        location: file.path,
+        issueMessage: headers.join(', '),
+      }
+    }
+
+    return await loadColumns(reader, headers, maxRows, 1)
+  } finally {
+    await reader.cancel()
+  }
+}
+
+export const loadTSV = filememoizeAsync(_loadTSV)

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/issues/list.ts

@@ -123,16 +123,19 @@ export const bidsIssues: IssueDefinitionRecord = {
     reason:
       'A value in a column did not match the acceptable type for that column headers specified format.',
   },
-  TSV_VALUE_INCORRECT_TYPE_NONREQUIRED: {
-    severity: 'warning',
-    reason:
-      'A value in a column did not match the acceptable type for that column headers specified format.',
-  },
   TSV_COLUMN_TYPE_REDEFINED: {
     severity: 'warning',
     reason:
       'A column required in a TSV file has been redefined in a sidecar file. This redefinition is being ignored.',
   },
+  TSV_PSEUDO_AGE_DEPRECATED: {
+    severity: 'warning',
+    reason: 'Use of the value "89+" in column "age" is deprecated. Use 89 for all ages 89 and over.',
+  },
+  INVALID_GZIP: {
+    severity: 'error',
+    reason: 'The gzip file could not be decompressed. It may be corrupt or misnamed.',
+  },
   MULTIPLE_INHERITABLE_FILES: {
     severity: 'error',
     reason: 'Multiple files in a directory were found to be valid candidates for inheritance.',
@@ -170,9 +173,9 @@ export const bidsIssues: IssueDefinitionRecord = {
     severity: 'error',
     reason: 'A json sidecar file was found without a corresponding data file',
   },
-  UNSUPPORTED_DATASET_TYPE: {
-    severity: 'error',
-    reason: 'This DatasetType is not supported by the application.',
+  SIDECAR_FIELD_OVERRIDE: {
+    severity: 'warning',
+    reason: 'Sidecar files should not override values assigned at a higher level.',
   },
   BLACKLISTED_MODALITY: {
     severity: 'error',

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/schema/applyRules.ts

@@ -146,7 +146,7 @@ function mapEvalCheck(statements: string[], context: BIDSContext): boolean {
  * Classic rules interpreted like selectors. Examples in specification:
  * schema/rules/checks/*
  */
-function evalRuleChecks(
+export function evalRuleChecks(
   rule: GenericRule,
   context: BIDSContext,
   schema: GenericSchema,

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/schema/context.test.ts

@@ -1,4 +1,4 @@
-import { assert, assertObjectMatch } from '@std/assert'
+import { assert, assertEquals, assertObjectMatch } from '@std/assert'
 import type { DatasetIssues } from '../issues/datasetIssues.ts'
 import { BIDSContext } from './context.ts'
 import { dataFile, rootFileTree } from './fixtures.test.ts'
@@ -21,6 +21,12 @@ Deno.test('test context LoadSidecar', async (t) => {
       anatValue: 'anat',
     })
   })
+  await t.step('Warnings are emitted for overriding sidecar fields', () => {
+    assertEquals(
+      context.dataset.issues.get({ code: 'SIDECAR_FIELD_OVERRIDE' }).length,
+      2,
+    )
+  })
 })
 
 Deno.test('test context loadSubjects', async (t) => {

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/schema/context.ts

@@ -18,7 +18,7 @@ import { readEntities } from './entities.ts'
 import { DatasetIssues } from '../issues/datasetIssues.ts'
 import { walkBack } from '../files/inheritance.ts'
 import { parseGzip } from '../files/gzip.ts'
-import { loadTSV } from '../files/tsv.ts'
+import { loadTSV, loadTSVGZ } from '../files/tsv.ts'
 import { parseTIFF } from '../files/tiff.ts'
 import { loadJSON } from '../files/json.ts'
 import { loadHeader } from '../files/nifti.ts'
@@ -209,14 +209,26 @@ export class BIDSContext implements Context {
       }
     }
     for (const file of sidecars) {
-      const json = await loadJSON(file).catch((error) => {
-        if (error.code) {
-          this.dataset.issues.add({ ...error, location: file.path })
+      const json = await loadJSON(file).catch((error): Record<string, unknown> => {
+        if (error.key) {
+          this.dataset.issues.add({ code: error.key, location: file.path })
           return {}
         } else {
           throw error
         }
       })
+      const overrides = Object.keys(this.sidecar).filter((x) => Object.hasOwn(json, x))
+      for (const key of overrides) {
+        if (json[key] !== this.sidecar[key]) {
+          const overrideLocation = this.sidecarKeyOrigin[key]
+          this.dataset.issues.add({
+            code: 'SIDECAR_FIELD_OVERRIDE',
+            subCode: key,
+            location: overrideLocation,
+            issueMessage: `Sidecar key defined in ${file.path} overrides previous value (${json[key]}) from ${overrideLocation}`,
+          })
+        }
+      }
       this.sidecar = { ...json, ...this.sidecar }
       Object.keys(json).map((x) => this.sidecarKeyOrigin[x] ??= file.path)
     }
@@ -242,21 +254,40 @@ export class BIDSContext implements Context {
   }
 
   async loadColumns(): Promise<void> {
-    if (this.extension !== '.tsv') {
-      return
+    if (this.extension == '.tsv') {
+      this.columns = await loadTSV(this.file, this.dataset.options?.maxRows)
+        .catch((error) => {
+          if (error.code) {
+            this.dataset.issues.add({ ...error, location: this.file.path })
+          }
+          logger.warn(
+            `tsv file could not be opened by loadColumns '${this.file.path}'`,
+          )
+          logger.debug(error)
+          return new Map<string, string[]>() as ColumnsMap
+        }) as Record<string, string[]>
+    } else if (this.extension == '.tsv.gz') {
+      const headers = this.sidecar.Columns as string[];
+      if (!headers || this.size === 0) {
+        // Missing Columns will be caught by sidecar rules
+        // Note that these rules currently select for suffix, and will need to be generalized
+        // or duplicated for new .tsv.gz files
+        // `this.size === 0` will show as `EMPTY_FILE`, so do not add INVALID_GZIP
+        return
+      }
+      this.columns = await loadTSVGZ(this.file, headers, this.dataset.options?.maxRows)
+        .catch((error) => {
+          if (error.code) {
+            this.dataset.issues.add({ ...error, location: this.file.path })
+          }
+          logger.warn(
+            `tsv.gz file could not be opened by loadColumns '${this.file.path}'`,
+          )
+          logger.debug(error)
+          return new Map<string, string[]>() as ColumnsMap
+        }) as Record<string, string[]>
     }
 
-    this.columns = await loadTSV(this.file, this.dataset.options?.maxRows)
-      .catch((error) => {
-        if (error.code) {
-          this.dataset.issues.add({ ...error, location: this.file.path })
-        }
-        logger.warn(
-          `tsv file could not be opened by loadColumns '${this.file.path}'`,
-        )
-        logger.debug(error)
-        return new Map<string, string[]>() as ColumnsMap
-      }) as Record<string, string[]>
     return
   }
 
@@ -325,37 +356,27 @@ export class BIDSContext implements Context {
         }) as Record<string, string[]>
       this.dataset.subjects.participant_id = participantsData['participant_id']
     }
-
-    // Load phenotype from phenotype/*.tsv
-    const phenotype_dir = this.dataset.tree.get('phenotype') as FileTree
-    if (phenotype_dir) {
-      const phenotypeFiles = phenotype_dir.files.filter((file) => file.name.endsWith('.tsv'))
-      // Collect observed participant_ids
-      const seen = new Set() as Set<string>
-      for (const file of phenotypeFiles) {
-        const phenotypeData = await loadTSV(file)
-          .catch((error) => {
-            return new Map()
-          }) as Record<string, string[]>
-        const participant_id = phenotypeData['participant_id']
-        if (participant_id) {
-          participant_id.forEach((id) => seen.add(id))
-        }
-      }
-      this.dataset.subjects.phenotype = Array.from(seen)
-    }
   }
 
   async asyncLoads() {
-    await Promise.allSettled([
-      this.loadSubjects(),
+    // loaders that may be depended on by other loaders
+    const initial = [
       this.loadSidecar(),
-      this.loadColumns(),
       this.loadAssociations(),
+    ]
+    // loaders that do not depend on other loaders
+    const independent = [
+      this.loadSubjects(),
       this.loadNiftiHeader(),
       this.loadJSON(),
       this.loadGzip(),
       this.loadTIFF(),
-    ])
+    ]
+
+    // Loaders with dependencies
+    await Promise.allSettled(initial)
+    await this.loadColumns()
+
+    await Promise.allSettled(independent)
   }
 }

{bids_validator_deno-2.0.11 → bids_validator_deno-2.1.0}/src/schema/tables.test.ts

@@ -69,7 +69,7 @@ Deno.test('tables eval* tests', async (t) => {
     const rule = schemaDefs.rules.tabular_data.modality_agnostic.Scans
     evalColumns(rule, context, schema, 'rules.tabular_data.modality_agnostic.Scans')
     assertEquals(
-      context.dataset.issues.get({ code: 'TSV_VALUE_INCORRECT_TYPE_NONREQUIRED' }).length,
+      context.dataset.issues.get({ code: 'TSV_VALUE_INCORRECT_TYPE' }).length,
       1,
     )
   })
@@ -159,13 +159,32 @@ Deno.test('tables eval* tests', async (t) => {
 
     // Overriding the default sex definition uses the provided values
     // Values in the default definition may raise issues
-    issues = context.dataset.issues.get({ code: 'TSV_VALUE_INCORRECT_TYPE_NONREQUIRED' })
+    issues = context.dataset.issues.get({ code: 'TSV_VALUE_INCORRECT_TYPE' })
     assertEquals(issues.length, 1)
     assertEquals(issues[0].subCode, 'sex')
     assertEquals(issues[0].line, 4)
     assertEquals(issues[0].issueMessage, "'f'")
   })
 
+  await t.step('verify pseudo-age deprecation', () => {
+    const context = {
+      path: '/participants.tsv',
+      extension: '.tsv',
+      sidecar: {},
+      columns: {
+        participant_id: ['sub-01', 'sub-02', 'sub-03'],
+        age: ['10', '89+', '89+'],
+      },
+      dataset: { issues: new DatasetIssues() },
+    }
+    const rule = schemaDefs.rules.tabular_data.modality_agnostic.Participants
+    evalColumns(rule, context, schema, 'rules.tabular_data.modality_agnostic.Participants')
+
+    // age gets a warning
+    let issues = context.dataset.issues.get({ code: 'TSV_PSEUDO_AGE_DEPRECATED' })
+    assertEquals(issues.length, 1)
+  })
+
   await t.step('verify column ordering', () => {
     const context = {
       path: '/sub-01/sub-01_scans.tsv',