Rewrite configurations; add types for generics

Use classes instead of dictionaries for usage configurations; add types
for generics like `dict` and `Callable`.

Author: enzet

emmio/audio/config.py

@@ -5,6 +5,16 @@
 from emmio.language import LanguageConfig
 
 
+class AudioUsageConfig(BaseModel):
+    """Configuration for a collection of audio files."""
+
+    id: str
+    """Identifier of the audio files."""
+
+    language: LanguageConfig
+    """Language of the files."""
+
+
 class AudioConfig(BaseModel):
     """Configuration for a collection of audio files."""
 

emmio/audio/core.py

@@ -69,7 +69,7 @@ class DirectoryAudioProvider(AudioProvider):
     def __post_init__(self) -> None:
         """Initialize the audio provider."""
 
-        self.path_pattern: re.Pattern = re.compile(
+        self.path_pattern: re.Pattern[str] = re.compile(
             rf"(?P<word>[^()]*)\s*(\([^()]*\))?\s*\d?\.{self.file_extension}"
         )
         self.cache: dict[str, list[Path]] = defaultdict(list)

emmio/audio/data.py

@@ -2,9 +2,9 @@
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Self
+from typing import Any, Self
 
-from emmio.audio.config import AudioConfig
+from emmio.audio.config import AudioConfig, AudioUsageConfig
 from emmio.audio.core import (
     AudioCollection,
     AudioProvider,
@@ -32,7 +32,7 @@ def from_config(cls, path: Path) -> Self:
         :param path: path to the configuration file
         :return: audio data
         """
-        config: dict = ArtifactData.read_config(path)
+        config: dict[str, Any] = ArtifactData.read_config(path)
 
         audio_providers: dict[str, AudioProvider] = {}
         for id_, data in config.items():
@@ -41,23 +41,25 @@ def from_config(cls, path: Path) -> Self:
             )
         return cls(path, audio_providers)
 
-    def get_audio_provider(self, usage_config: dict) -> AudioProvider:
+    def get_audio_provider(
+        self, usage_config: AudioUsageConfig
+    ) -> AudioProvider:
         """Get an audio provider from a usage configuration.
 
         :param usage_config: usage configuration
         :return: audio provider
         """
-        match id_ := usage_config["id"]:
+        match id_ := usage_config.id:
             case "wikimedia_commons":
                 return WikimediaCommonsAudioProvider(
-                    Language.from_code(usage_config["language"]),
+                    Language.from_code(usage_config.language),
                     self.path / "cache",
                 )
             case _:
                 return self.audio_providers[id_]
 
     def get_audio_collection(
-        self, usage_configs: list[dict]
+        self, usage_configs: list[AudioUsageConfig]
     ) -> AudioCollection:
         """Get an audio collection from a list of usage configurations.
 

emmio/core.py

@@ -5,7 +5,7 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from pathlib import Path
-from typing import Self
+from typing import Any, Self
 
 from pydantic import BaseModel
 
@@ -54,7 +54,7 @@ def from_config(cls, path: Path) -> Self:
         raise NotImplementedError()
 
     @staticmethod
-    def read_config(path: Path) -> dict:
+    def read_config(path: Path) -> dict[str, Any]:
         """Read the configuration file.
 
         :param path: path to the configuration file
@@ -69,5 +69,5 @@ def read_config(path: Path) -> dict:
             raise FileExistsError()
 
         with (path / "config.json").open(encoding="utf-8") as config_file:
-            result: dict = json.load(config_file)
+            result: dict[str, Any] = json.load(config_file)
             return result

emmio/data.py

@@ -18,17 +18,21 @@
 from typing import Self
 
 from emmio import ui
+from emmio.audio.config import AudioUsageConfig
 from emmio.audio.core import AudioCollection, AudioProvider
 from emmio.audio.data import AudioData
+from emmio.dictionary.config import DictionaryUsageConfig
 from emmio.dictionary.core import Dictionary, DictionaryCollection
 from emmio.dictionary.data import DictionaryData
 from emmio.language import Language
 from emmio.learn.core import Learning
 from emmio.lexicon.core import Lexicon
+from emmio.lists.config import ListUsageConfig
 from emmio.lists.core import List
 from emmio.lists.data import ListsData
 from emmio.lists.frequency_list import FrequencyList
-from emmio.sentence.core import Sentences, SentencesCollection
+from emmio.sentence.config import SentencesUsageConfig
+from emmio.sentence.core import SentencesCollection
 from emmio.sentence.data import SentencesData
 from emmio.text.core import Texts
 from emmio.text.data import TextData
@@ -119,34 +123,34 @@ def get_lists_data(self) -> ListsData:
             )
         return self._lists_data
 
-    def get_list(self, usage_config: dict) -> List | None:
+    def get_list(self, usage_config: ListUsageConfig) -> List | None:
         """Get a list by usage configuration."""
         return self.get_lists_data().get_list(usage_config)
 
-    def get_frequency_list(self, usage_config: dict) -> FrequencyList | None:
+    def get_frequency_list(
+        self, usage_config: ListUsageConfig
+    ) -> FrequencyList | None:
         """Get a frequency list by usage configuration."""
         return self.get_lists_data().get_frequency_list(usage_config)
 
-    def get_dictionary(self, usage_config: dict) -> Dictionary | None:
+    def get_dictionary(
+        self, usage_config: DictionaryUsageConfig
+    ) -> Dictionary | None:
         """Get a dictionary by usage configuration."""
         return self.dictionaries.get_dictionary(usage_config)
 
     def get_dictionaries(
-        self, usage_configs: list[dict]
+        self, usage_configs: list[DictionaryUsageConfig]
     ) -> DictionaryCollection:
         """Get a collection of dictionaries by usage configurations."""
         return self.dictionaries.get_dictionaries(usage_configs)
 
-    def get_sentences(self, usage_config: dict) -> Sentences:
-        """Get sentences by usage configuration."""
-        return self.sentences.get_sentences(usage_config)
-
     def get_text(self, text_id: str) -> Texts:
         """Get a text by its identifier."""
         return self.texts.get_text(text_id)
 
     def get_sentences_collection(
-        self, usage_configs: list[dict]
+        self, usage_configs: list[SentencesUsageConfig]
     ) -> SentencesCollection:
         """Get a collection of sentences by usage configurations."""
         return self.sentences.get_sentences_collection(usage_configs)
@@ -161,20 +165,22 @@ def get_audio_data(self) -> AudioData:
             )
         return self._audio_data
 
-    def get_audio_provider(self, usage_config: dict) -> AudioProvider:
+    def get_audio_provider(
+        self, usage_config: AudioUsageConfig
+    ) -> AudioProvider:
         """Get an audio provider by usage configuration."""
         return self.get_audio_data().get_audio_provider(usage_config)
 
     def get_audio_collection(
-        self, usage_configs: list[dict]
+        self, usage_configs: list[AudioUsageConfig]
     ) -> AudioCollection:
         """Get an audio collection by usage configurations."""
         return self.get_audio_data().get_audio_collection(usage_configs)
 
     def get_words(self, id_: str) -> list[str] | None:
         """Get words from a list by its identifier."""
 
-        if not (list_ := self.get_list({"id": id_})):
+        if not (list_ := self.get_list(ListUsageConfig(id=id_))):
             return None
         return list_.get_words()
 

emmio/dictionary/config.py

@@ -5,6 +5,22 @@
 from emmio.language import LanguageConfig
 
 
+class DictionaryUsageConfig(BaseModel):
+    """Configuration of a dictionary."""
+
+    id: str
+    """Identifier of the dictionary."""
+
+    from_language: LanguageConfig | None = None
+    """Language of words being defined."""
+
+    to_language: LanguageConfig | None = None
+    """Language of definitions and translations."""
+
+    name: str | None = None
+    """Additional name to identify the dictionary."""
+
+
 class DictionaryConfig(BaseModel):
     """Configuration of a dictionary."""
 

emmio/dictionary/data.py

@@ -2,10 +2,10 @@
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Self
+from typing import Any, Self
 
 from emmio.core import ArtifactData
-from emmio.dictionary.config import DictionaryConfig
+from emmio.dictionary.config import DictionaryConfig, DictionaryUsageConfig
 from emmio.dictionary.core import (
     Dictionary,
     DictionaryCollection,
@@ -32,7 +32,7 @@ def from_config(cls, path: Path) -> Self:
 
         :param path: path to the directory with dictionaries
         """
-        config: dict = ArtifactData.read_config(path)
+        config: dict[str, Any] = ArtifactData.read_config(path)
 
         dictionaries: dict[str, Dictionary] = {}
         for id_, data in config.items():
@@ -42,23 +42,38 @@ def from_config(cls, path: Path) -> Self:
         return cls(path, dictionaries)
 
     def get_dictionary(
-        self, dictionary_usage_config: dict
+        self, dictionary_usage_config: DictionaryUsageConfig
     ) -> Dictionary | None:
         """Get dictionary by dictionary usage configuration."""
-        match id_ := dictionary_usage_config["id"]:
+
+        match id_ := dictionary_usage_config.id:
             case "kaikki":
+                if dictionary_usage_config.from_language is None:
+                    raise ValueError(
+                        "Language is required for Kaikki dictionary."
+                    )
+                if dictionary_usage_config.name is None:
+                    raise ValueError("Name is required for Kaikki dictionary.")
                 return EnglishWiktionaryKaikki(
                     self.path,
                     self.path / "cache",
-                    Language.from_code(dictionary_usage_config["language"]),
-                    dictionary_usage_config["name"],
+                    Language.from_code(dictionary_usage_config.from_language),
+                    dictionary_usage_config.name,
                 )
             case "google_translate":
+                if dictionary_usage_config.from_language is None:
+                    raise ValueError(
+                        "Language is required for Google Translate dictionary."
+                    )
+                if dictionary_usage_config.to_language is None:
+                    raise ValueError(
+                        "Language is required for Google Translate dictionary."
+                    )
                 return GoogleTranslate(
                     self.path,
                     self.path / "cache",
-                    Language.from_code(dictionary_usage_config["from"]),
-                    Language.from_code(dictionary_usage_config["to"]),
+                    Language.from_code(dictionary_usage_config.from_language),
+                    Language.from_code(dictionary_usage_config.to_language),
                 )
             case _:
                 if id_ in self.dictionaries:
@@ -67,7 +82,7 @@ def get_dictionary(
         return None
 
     def get_dictionaries(
-        self, dictionary_usage_configs: list[dict]
+        self, dictionary_usage_configs: list[DictionaryUsageConfig]
     ) -> DictionaryCollection:
         """Get dictionaries by dictionary usage configurations.
 

emmio/dictionary/en_wiktionary.py

@@ -42,12 +42,14 @@
 }
 
 
-LINK_PATTERN: re.Pattern = re.compile(
+LINK_PATTERN: re.Pattern[str] = re.compile(
     r"^(?P<preffix>\(.*\) )?(?P<link_type>.*) of "
     r"(?P<link>[^:;,. ]*)[:;,.]?"
     r'(?P<suffix1>[:;,] .*)?(?P<suffix2> \(.*\))?(?P<suffix3> ".*")?$'
 )
-DESCRIPTOR_PATTERN: re.Pattern = re.compile(r"\((?P<descriptor>[^()]*)\) .*")
+DESCRIPTOR_PATTERN: re.Pattern[str] = re.compile(
+    r"\((?P<descriptor>[^()]*)\) .*"
+)
 
 
 def get_file_name(word: str) -> str:

emmio/graph.py

@@ -59,7 +59,7 @@ def cumulative_actions(
         self,
         records: list[tuple[LearningRecord, Learning]],
         lexicons: list[Lexicon],
-        point: Callable,
+        point: Callable[[datetime], datetime],
         width: float,
         by_language: bool = False,
     ) -> None:

emmio/language.py

@@ -40,7 +40,7 @@ def __init__(
         symbols: str,
         self_name: str | None = None,
         parent: Language | None = None,
-        checking: Callable | None = None,
+        checking: Callable[[str], bool] | None = None,
         sentence_end: str | None = None,
     ) -> None:
         self.code: str = code
@@ -51,7 +51,7 @@ def __init__(
         self.sentence_end: str | None = sentence_end
         self.iso639_language = ISO639Language(code)
 
-        self.has_symbol: Callable
+        self.has_symbol: Callable[[str], bool]
         if checking:
             self.has_symbol = checking
         else: