54 | > = ({ className, orientation = 'vertical', ...props }) => (
55 |
67 |
68 |
69 | );
70 |
71 | export { ScrollArea, ScrollBar };
72 |
--------------------------------------------------------------------------------
/annimate_desktop/src/components/manage-page/advanced-section.tsx:
--------------------------------------------------------------------------------
1 | import { Button } from '@/components/ui/button';
2 | import {
3 | Tooltip,
4 | TooltipContent,
5 | TooltipTrigger,
6 | } from '@/components/ui/tooltip';
7 | import { useToast } from '@/components/ui/use-toast';
8 | import { openPath } from '@/lib/api';
9 | import { useClearCache, useDbDir } from '@/lib/store';
10 | import { Folder } from 'lucide-react';
11 | import { FC } from 'react';
12 |
13 | export const AdvancedSection: FC = () => {
14 | const {
15 | mutation: { mutate: clearCache },
16 | } = useClearCache();
17 | const { toast } = useToast();
18 | const { data: dbDir, error: dbDirError } = useDbDir();
19 |
20 | if (dbDirError !== null) {
21 | throw new Error(`Failed to load data folder: ${dbDirError.message}`);
22 | }
23 |
24 | return (
25 |
26 |
27 |
28 |
41 |
42 |
43 |
44 | {dbDir ?? 'Loading ...'}
45 |
46 |
47 |
48 |
75 |
76 | );
77 | };
78 |
--------------------------------------------------------------------------------
/annimate_core/tests/segmentations.rs:
--------------------------------------------------------------------------------
1 | use std::fs;
2 | use std::path::Path;
3 |
4 | use annimate_core::Storage;
5 | use serde::Serialize;
6 |
7 | const DATA_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data");
8 | const DB_DIR: &str = concat!(env!("CARGO_TARGET_TMPDIR"), "/tests/segmentations/db");
9 |
10 | macro_rules! segmentations_test {
11 | ($(
12 | $name:ident: {
13 | corpus_paths: $corpus_paths:expr,
14 | corpus_names: $corpus_names:expr,
15 | }
16 | )*) => {
17 | $(
18 | #[test]
19 | fn $name() {
20 | let test_data = TestData {
21 | corpus_paths: &$corpus_paths,
22 | corpus_names: &$corpus_names,
23 | };
24 |
25 | let db_dir = Path::new(DB_DIR).join(stringify!($name));
26 |
27 | let _ = fs::remove_dir_all(&db_dir);
28 | let storage = Storage::from_db_dir(db_dir).unwrap();
29 |
30 | storage
31 | .import_corpora(
32 | test_data
33 | .corpus_paths
34 | .into_iter()
35 | .map(|p| Path::new(DATA_DIR).join(p))
36 | .collect(),
37 | |_| (),
38 | || false,
39 | )
40 | .unwrap();
41 |
42 | let segmentations = storage.segmentations(test_data.corpus_names).unwrap();
43 |
44 | insta::with_settings!(
45 | {
46 | info => &test_data,
47 | omit_expression => true,
48 | },
49 | { insta::assert_debug_snapshot!(segmentations) }
50 | );
51 | }
52 | )*
53 | };
54 | }
55 |
56 | segmentations_test! {
57 | subtok: {
58 | corpus_paths: ["subtok.demo_relANNIS.zip"],
59 | corpus_names: ["subtok.demo"],
60 | }
61 | subtok_renamed: {
62 | corpus_paths: ["subtok.demo_renamed_graphml.zip"],
63 | corpus_names: ["subtok.demo_renamed"],
64 | }
65 | pcc2: {
66 | corpus_paths: ["pcc2_v7_relANNIS.zip"],
67 | corpus_names: ["pcc2"],
68 | }
69 | nondefaultsegmentation: {
70 | corpus_paths: ["nondefaultsegmentation.demo_graphml.zip"],
71 | corpus_names: ["nondefaultsegmentation.demo"],
72 | }
73 | }
74 |
75 | #[derive(Serialize)]
76 | struct TestData {
77 | corpus_paths: &'static [&'static str],
78 | corpus_names: &'static [&'static str],
79 | }
80 |
--------------------------------------------------------------------------------
/annimate_core/tests/exportable_anno_keys.rs:
--------------------------------------------------------------------------------
1 | use std::fs;
2 | use std::path::Path;
3 |
4 | use annimate_core::Storage;
5 | use serde::Serialize;
6 |
7 | const DATA_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data");
8 | const DB_DIR: &str = concat!(
9 | env!("CARGO_TARGET_TMPDIR"),
10 | "/tests/exportable_anno_keys/db"
11 | );
12 |
13 | macro_rules! exportable_anno_keys_test {
14 | ($(
15 | $name:ident: {
16 | corpus_paths: $corpus_paths:expr,
17 | corpus_names: $corpus_names:expr,
18 | }
19 | )*) => {
20 | $(
21 | #[test]
22 | fn $name() {
23 | let test_data = TestData {
24 | corpus_paths: &$corpus_paths,
25 | corpus_names: &$corpus_names,
26 | };
27 |
28 | let db_dir = Path::new(DB_DIR).join(stringify!($name));
29 |
30 | let _ = fs::remove_dir_all(&db_dir);
31 | let storage = Storage::from_db_dir(db_dir).unwrap();
32 |
33 | storage
34 | .import_corpora(
35 | test_data
36 | .corpus_paths
37 | .into_iter()
38 | .map(|p| Path::new(DATA_DIR).join(p))
39 | .collect(),
40 | |_| (),
41 | || false,
42 | )
43 | .unwrap();
44 |
45 | let exportable_anno_keys = storage
46 | .exportable_anno_keys(test_data.corpus_names)
47 | .unwrap();
48 |
49 | insta::with_settings!(
50 | {
51 | info => &test_data,
52 | omit_expression => true,
53 | },
54 | { insta::assert_debug_snapshot!(exportable_anno_keys) }
55 | );
56 | }
57 | )*
58 | };
59 | }
60 |
61 | exportable_anno_keys_test! {
62 | empty: {
63 | corpus_paths: ["empty_graphml.zip"],
64 | corpus_names: ["empty"],
65 | }
66 | subtok: {
67 | corpus_paths: ["subtok.demo_relANNIS.zip"],
68 | corpus_names: ["subtok.demo"],
69 | }
70 | subtok_renamed: {
71 | corpus_paths: ["subtok.demo_renamed_graphml.zip"],
72 | corpus_names: ["subtok.demo_renamed"],
73 | }
74 | pcc2: {
75 | corpus_paths: ["pcc2_v7_relANNIS.zip"],
76 | corpus_names: ["pcc2"],
77 | }
78 | }
79 |
80 | #[derive(Serialize)]
81 | struct TestData {
82 | corpus_paths: &'static [&'static str],
83 | corpus_names: &'static [&'static str],
84 | }
85 |
--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 | "extends": [
4 | "config:recommended"
5 | ],
6 | "rangeStrategy": "bump",
7 | "packageRules": [
8 | {
9 | "matchDatasources": [
10 | "npm"
11 | ],
12 | "minimumReleaseAge": "1440 minutes"
13 | },
14 | {
15 | "matchManagers": [
16 | "npm"
17 | ],
18 | "matchDepTypes": [
19 | "dependencies"
20 | ],
21 | "matchUpdateTypes": [
22 | "bump",
23 | "digest",
24 | "lockFileMaintenance",
25 | "minor",
26 | "patch",
27 | "pin",
28 | "pinDigest",
29 | "rollback",
30 | "replacement"
31 | ],
32 | "groupName": "NPM dependencies non-major",
33 | "groupSlug": "npm-non-major"
34 | },
35 | {
36 | "matchManagers": [
37 | "npm"
38 | ],
39 | "matchDepTypes": [
40 | "devDependencies"
41 | ],
42 | "matchUpdateTypes": [
43 | "bump",
44 | "digest",
45 | "lockFileMaintenance",
46 | "minor",
47 | "patch",
48 | "pin",
49 | "pinDigest",
50 | "rollback",
51 | "replacement"
52 | ],
53 | "groupName": "NPM dev dependencies non-major",
54 | "groupSlug": "npm-dev-non-major"
55 | },
56 | {
57 | "matchPackageNames": [
58 | "graphannis",
59 | "graphannis-core"
60 | ],
61 | "groupName": "graphANNIS monorepo",
62 | "groupSlug": "graphannis-monorepo"
63 | },
64 | {
65 | "matchPackageNames": [
66 | "tauri",
67 | "tauri-*",
68 | "@tauri-apps/**"
69 | ],
70 | "groupName": "Tauri monorepo",
71 | "groupSlug": "tauri-monorepo"
72 | },
73 | {
74 | "matchPackageNames": [
75 | "toml",
76 | "toml_edit"
77 | ],
78 | "groupName": "Toml monorepo",
79 | "groupSlug": "toml-monorepo"
80 | },
81 | {
82 | "matchDatasources": [
83 | "github-runners"
84 | ],
85 | "enabled": false,
86 | "description": "GitHub runners need to be pinned to make sure the required packages are available"
87 | }
88 | ],
89 | "customManagers": [
90 | {
91 | "customType": "regex",
92 | "managerFilePatterns": [
93 | "/^\\.github\\/workflows\\/.*\\.yml$/"
94 | ],
95 | "matchStrings": [
96 | "\\s*renovate:\\s*datasource=(?.*?)\\s*versioning=(?.*?)\\s*depName=(?.*?)\\s*\\n.*?:\\s*(?.*)\\s*"
97 | ]
98 | }
99 | ]
100 | }
--------------------------------------------------------------------------------
/annimate_core/src/format/csv.rs:
--------------------------------------------------------------------------------
1 | use std::io::{Seek, Write};
2 |
3 | use super::table::{self, TableWriter};
4 | use super::{Exporter, QueryInfo};
5 | use crate::TableExportColumn;
6 | use crate::anno::AnnoKeyFormat;
7 | use crate::error::AnnimateError;
8 | use crate::query::{ExportData, Match};
9 |
10 | #[derive(Debug)]
11 | pub(super) struct CsvExporter;
12 |
13 | /// Configuration of an export in the CSV format.
14 | #[derive(Debug)]
15 | pub struct CsvExportConfig {
16 | /// Columns to export.
17 | pub columns: Vec,
18 | }
19 |
20 | impl Exporter for CsvExporter {
21 | type Config = CsvExportConfig;
22 |
23 | fn get_export_data(config: &CsvExportConfig) -> Vec {
24 | config
25 | .columns
26 | .iter()
27 | .filter_map(TableExportColumn::data)
28 | .cloned()
29 | .collect()
30 | }
31 |
32 | fn export(
33 | config: &CsvExportConfig,
34 | matches_iter: I,
35 | query_info: QueryInfo<'_, S>,
36 | anno_key_format: &AnnoKeyFormat,
37 | out: W,
38 | on_matches_exported: F,
39 | cancel_requested: G,
40 | ) -> Result<(), AnnimateError>
41 | where
42 | F: Fn(usize),
43 | G: Fn() -> bool,
44 | I: ExactSizeIterator- >,
45 | S: AsRef,
46 | W: Write + Seek + Send,
47 | {
48 | table::export(
49 | &config.columns,
50 | matches_iter,
51 | query_info.nodes,
52 | anno_key_format,
53 | &mut CsvTableWriter::new(out),
54 | on_matches_exported,
55 | cancel_requested,
56 | )
57 | }
58 | }
59 |
60 | struct CsvTableWriter(csv::Writer)
61 | where
62 | W: Write;
63 |
64 | impl CsvTableWriter
65 | where
66 | W: Write,
67 | {
68 | fn new(inner: W) -> CsvTableWriter {
69 | CsvTableWriter(csv::Writer::from_writer(inner))
70 | }
71 | }
72 |
73 | impl TableWriter for CsvTableWriter
74 | where
75 | W: Write,
76 | {
77 | fn write_record(&mut self, record: I) -> Result<(), AnnimateError>
78 | where
79 | I: IntoIterator>,
80 | {
81 | Ok(self.0.write_record(record.into_iter().map(StrAsBytes))?)
82 | }
83 | }
84 |
85 | struct StrAsBytes
(S);
86 |
87 | impl AsRef<[u8]> for StrAsBytes
88 | where
89 | S: AsRef,
90 | {
91 | fn as_ref(&self) -> &[u8] {
92 | self.0.as_ref().as_bytes()
93 | }
94 | }
95 |
96 | impl From for AnnimateError {
97 | fn from(err: csv::Error) -> AnnimateError {
98 | AnnimateError::Io(err.into())
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/annimate_desktop/src-tauri/src/preload.rs:
--------------------------------------------------------------------------------
1 | use std::collections::HashSet;
2 | use std::sync::{Arc, Mutex};
3 | use std::time::Duration;
4 |
5 | use annimate_core::Storage;
6 |
7 | use crate::delayed_queue::DelayedQueue;
8 |
9 | const DELAY: Duration = Duration::from_secs(5);
10 |
11 | pub(crate) struct Preloader {
12 | shared: Arc,
13 | }
14 |
15 | struct Shared {
16 | corpus_names_to_preload: Mutex>,
17 | queue: DelayedQueue,
18 | }
19 |
20 | impl Preloader {
21 | pub(crate) fn new(storage: Arc) -> Self {
22 | let shared = Arc::new(Shared {
23 | corpus_names_to_preload: Mutex::new(HashSet::new()),
24 | queue: DelayedQueue::new(),
25 | });
26 |
27 | tauri::async_runtime::spawn({
28 | let shared = Arc::clone(&shared);
29 |
30 | async move {
31 | loop {
32 | let corpus_name = shared.queue.pop().await;
33 |
34 | // Ignore errors as preloading is not critical.
35 | // Also, there may be errors due to corpora having been deleted in the meantime.
36 | let _ = tauri::async_runtime::spawn_blocking({
37 | let storage = Arc::clone(&storage);
38 | move || storage.preload_corpus(&corpus_name)
39 | })
40 | .await;
41 | }
42 | }
43 | });
44 |
45 | Self { shared }
46 | }
47 |
48 | pub(crate) async fn set_corpus_names_to_preload(&self, corpus_names: Vec) {
49 | // Remove corpora from queue that are no longer on the list
50 | self.shared
51 | .queue
52 | .retain(|corpus_name| corpus_names.contains(corpus_name));
53 |
54 | let mut corpus_names_to_preload = self.shared.corpus_names_to_preload.lock().unwrap();
55 | let now = tokio::time::Instant::now();
56 |
57 | // Enqueue corpora that have been added to the list
58 | for corpus_name in &corpus_names {
59 | if !corpus_names_to_preload.contains(corpus_name) {
60 | self.shared.queue.push(corpus_name.clone(), now + DELAY);
61 | }
62 | }
63 |
64 | // Save new list
65 | *corpus_names_to_preload = HashSet::from_iter(corpus_names);
66 | }
67 |
68 | pub(crate) fn suspend(&self) -> SuspendGuard<'_> {
69 | self.shared.queue.suspend();
70 | SuspendGuard { preloader: self }
71 | }
72 |
73 | fn resume(&self) {
74 | self.shared.queue.resume();
75 | }
76 | }
77 |
78 | pub(crate) struct SuspendGuard<'a> {
79 | preloader: &'a Preloader,
80 | }
81 |
82 | impl Drop for SuspendGuard<'_> {
83 | fn drop(&mut self) {
84 | self.preloader.resume();
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/annimate_desktop/src/components/manage-page/corpora-in-set-list.tsx:
--------------------------------------------------------------------------------
1 | import { Checkbox } from '@/components/ui/checkbox';
2 | import { Label } from '@/components/ui/label';
3 | import { ScrollArea } from '@/components/ui/scroll-area';
4 | import { useToast } from '@/components/ui/use-toast';
5 | import { Corpus } from '@/lib/api-types';
6 | import { useToggleCorpusInSet } from '@/lib/store';
7 | import { FC, useId } from 'react';
8 |
9 | export type CorporaInSetListProps = {
10 | corpora: Corpus[];
11 | corpusSet: string;
12 | };
13 |
14 | export const CorporaInSetList: FC = ({
15 | corpora,
16 | corpusSet,
17 | }) => (
18 |
19 |
22 |
23 |
24 | {corpora.length === 0 ? (
25 |
26 | No corpora available
27 |
28 | ) : (
29 |
30 | {corpora.map(({ name, includedInSets }) => (
31 |
37 | ))}
38 |
39 | )}
40 |
41 |