Loading the English and French Word Embeddings

# python
from pathlib import Path
import os

# pypi
from dotenv import load_dotenv

@attr.s(auto_attribs=True)
class DictLoader:
    """Loader for the english and french dictionaries

    This is specifically for the training and testing files
     - CSV-ish (separated by spaces instead of commas)
     - No header: column 1 = English, column 2 = English

    Args:
     path: path to the file
     columns: list of strings
     delimiter: separator for the columns in the source file
    """
    path: str
    columns: list=["English", "French"]
    delimiter: str=" "

    _dataframe: pandas.DataFrame=None
    _dictionary: dict=None

@attr.s(auto_attribs=True)
class LoadAndBuild:
    """Loads embeddings and dictionaries and builds subsets"""
    _paths: Paths=None
    _english_embeddings: BaseKeyedVectors=None
    _french_embeddings: BaseKeyedVectors=None
    _training: dict=None
    _testing: dict=None
    _merged_dicts: dict=None
    _subset_builder: SubsetBuilder=None

    @property
    def paths(self) -> Paths:
        """Object with paths to files"""
        if self._paths is None:
            self._paths = Paths()
        return self._paths

    @property
    def english_embeddings(self) -> BaseKeyedVectors:
        """Word embeddings for English"""
        if self._english_embeddings is None:
            self._english_embeddings = Embeddings(self.paths.source.english,
                                                  binary=True).embeddings
        return self._english_embeddings

    @property
    def french_embeddings(self) -> BaseKeyedVectors:
        """Word embeddings for French"""
        if self._french_embeddings is None:
            self._french_embeddings = Embeddings(self.paths.source.french,
                                                 binary=False).embeddings
        return self._french_embeddings

    @property
    def training(self) -> dict:
        """training dictionary"""
        if self._training is None:
            self._training = DictLoader(self.paths.source.training).dictionary
        return self._training

    @property
    def testing(self) -> dict:
        """Testing dictionary"""
        if self._testing is None:
            self._testing = DictLoader(self.paths.source.testing).dictionary
        return self._testing

    @property
    def merged_dicts(self) -> dict:
        """Testing and training merged"""
        if self._merged_dicts is None:
            self._merged_dicts = self.training.copy()
            self._merged_dicts.update(self.testing)
            assert len(self._merged_dicts) == (len(self.training) + len(self.testing))
        return self._merged_dicts

    @property
    def subset_builder(self) -> SubsetBuilder:
        """Builder of the subset dictionaries"""
        if self._subset_builder is None:
            self._subset_builder = SubsetBuilder(
                self.english_embeddings,
                self.french_embeddings,
                self.merged_dicts,
                self.paths.target.english,
                self.paths.target.french)
        return self._subset_builder

    def __call__(self) -> None:
        """Calls the subset builder"""
        self.subset_builder()
        return

EmbeddingsKeys = Namespace(
    english_subset="ENGLISH_EMBEDDINGS_SUBSET",
    french_subset="FRENCH_EMBEDDINGS_SUBSET",
    training="ENGLISH_FRENCH_TRAINING",
    testing="ENGLISH_FRENCH_TESTING",
)

@attr.s(auto_attribs=True)
class EmbeddingsLoader:
    """Loads the embeddings and dictionaries

    Warning:
     this assumes that you've loaded the proper environment variables to
    find the files - it doesn't call ``load_dotenv``

    """
    _loader_builder: LoadAndBuild=None
    _english_subset: dict=None
    _french_subset: dict=None
    _training: dict=None
    _testing: dict=None

@property
def loader_builder(self) -> LoadAndBuild:
    """Object to load sources and build subsets"""
    if self._loader_builder is None:
        self._loader_builder = LoadAndBuild()
    return self._loader_builder

@property
def english_subset(self) -> dict:
    """The english embeddings subset

    This is a subset of the Google News embeddings that matches the keys in 
    the english to french dictionaries
    """
    if self._english_subset is None:
        if not self.loader_builder.paths.target.english.is_file():
            self.loader_builder()
            self._english_subset = self.loader_builder.subset_builder.subset_1
        else:
            with self.loader_builder.paths.target.english.open("rb") as reader:
                self._english_subset = pickle.load(reader)
    return self._english_subset

@property
def french_subset(self) -> dict:
    """Subset of the MUSE French embeddings"""
    if self._french_subset is None:
        if self.loader_builder.paths.target.french.is_file():
            with self.loader_builder.paths.target.french.open("rb") as reader:
                self._french_subset = pickle.load(reader)
        else:
            self.loader_builder()
            self._french_subset = self.loader_builder.subset_builder.subset_2
    return self._french_subset

@property
def training(self) -> dict:
    """The english to french dictionary training set"""
    if self._training is None:
        self._training = DictLoader(self.loader_builder.paths.source.training).dictionary
    return self._training

@property
def testing(self) -> dict:
    """testing english to french dictionary"""
    if self._testing is None:
        self._testing = DictLoader(self.loader_builder.paths.source.testing).dictionary
    return self._testing