Ejemplo n.º 1
0
    def test_type_load_and_save(self):
        qid2typenames = {
            "Q123": ["animal"],
            "Q345": ["dog"],
            "Q567": ["animal", "animall", "drop"],
            "Q789": [],
        }
        max_types = 2
        type_symbols = TypeSymbols(qid2typenames, max_types=max_types)
        type_symbols.save(self.save_dir, prefix="test")
        type_symbols_2 = TypeSymbols.load_from_cache(self.save_dir, prefix="test")

        self.assertEqual(type_symbols_2.max_types, type_symbols.max_types)
        self.assertDictEqual(type_symbols_2._qid2typenames, type_symbols._qid2typenames)
        self.assertIsNone(type_symbols._typename2qids)
        self.assertIsNone(type_symbols_2._typename2qids)
        self.assertDictEqual(type_symbols_2._qid2typeid, type_symbols._qid2typeid)
        self.assertDictEqual(type_symbols_2._type_vocab, type_symbols._type_vocab)
        self.assertDictEqual(
            type_symbols_2._type_vocab_inv, type_symbols._type_vocab_inv
        )
Ejemplo n.º 2
0
    def load_from_cache(
        cls,
        load_dir,
        edit_mode=False,
        verbose=False,
        no_kg=False,
        no_type=False,
        type_systems_to_load=None,
    ):
        """Loaded a pre-saved profile.

        Args:
            load_dir: load directory
            edit_mode: edit mode flag, default False
            verbose: verbose flag, default False
            no_kg: load kg or not flag, default False
            no_type: load types or not flag, default False. If True, this will ignore type_systems_to_load.
            type_systems_to_load: list of type systems to load, default is None which means all types systems

        Returns: entity profile object
        """
        # Check type system input
        load_dir = Path(load_dir)
        type_subfolder = load_dir / TYPE_SUBFOLDER
        if type_systems_to_load is not None:
            if not isinstance(type_systems_to_load, list):
                raise ValueError(
                    f"`type_systems` must be a list of subfolders in {type_subfolder}"
                )
            for sys in type_systems_to_load:
                if sys not in list([p.name for p in type_subfolder.iterdir()]):
                    raise ValueError(
                        f"`type_systems` must be a list of subfolders in {type_subfolder}. {sys} is not one."
                    )

        if verbose:
            print("Loading Entity Symbols")
        entity_symbols = EntitySymbols.load_from_cache(
            load_dir / ENTITY_SUBFOLDER,
            edit_mode=edit_mode,
            verbose=verbose,
        )
        if no_type:
            print(
                f"Not loading type information. We will act as if there is no types associated with any entity "
                f"and will not modify the types in any way, even if calling `add`."
            )
        type_sys_dict = {}
        for fold in type_subfolder.iterdir():
            if ((not no_type) and (type_systems_to_load is None
                                   or fold.name in type_systems_to_load)
                    and (fold.is_dir())):
                if verbose:
                    print(f"Loading Type Symbols from {fold}")
                type_sys_dict[fold.name] = TypeSymbols.load_from_cache(
                    type_subfolder / fold.name,
                    edit_mode=edit_mode,
                    verbose=verbose,
                )
        if verbose:
            print(f"Loading KG Symbols")
        if no_kg:
            print(
                f"Not loading KG information. We will act as if there is not KG connections between entities. "
                f"We will not modify the KG information in any way, even if calling `add`."
            )
        kg_symbols = None
        if not no_kg:
            kg_symbols = KGSymbols.load_from_cache(
                load_dir / KG_SUBFOLDER,
                edit_mode=edit_mode,
                verbose=verbose,
            )
        return cls(entity_symbols, type_sys_dict, kg_symbols, edit_mode,
                   verbose)