pyeasyphd 0.0.2__py3-none-any.whl

pyeasyphd/tools/search/data.py

@@ -0,0 +1,318 @@
+from typing import Any, Dict
+
+
+def obtain_search_keywords() -> Dict[str, Any]:
+    """Keywords."""
+    _h_ = "(?:| |-)"  # hyphen
+
+    evol = "evol(?:ution|utionary)"  # 'evol(?:ution|utionary|ve|ved|ving)'
+    computation = "computation(?:|al)"
+    strateg = "strateg(?:y|ies)"
+    program = "program(?:|ming)"
+    algorithm = "algorithm(?:|s)"
+    automat = "automat(?:ed|ion)"
+    keywords_ec = [  # evolution computation
+        ["simulated annealing"],
+        ["taboo search"],
+        [f"{evol} {strateg}"],
+        ["CMA-ES"],  #
+        [f"{evol} {program}"],
+        [f"differential {evol}"],
+        [f"{evol} {algorithm}"],
+        [[evol], [strateg, program, "differential", algorithm]],
+        [f"genetic {algorithm}"],
+        [f"genetic {program}"],
+        [["genetic"], [algorithm, program]],
+        ["particle swarm"],
+        [["swarm"], ["particle"]],
+        ["ant colony"],
+        ["bee colony"],
+        [["colony"], ["ant", "bee"]],
+        [f"memetic {algorithm}"],
+        [f"population{_h_}based"],
+        ["quality diversity"],
+        [evol, algorithm, automat],
+        [evol, computation],
+    ]
+
+    keywords_ss = [  # search strategy
+        ["local search"],
+        [["local", "search"], ["local search"]],
+        ["local optimization"],
+        [["local", "optimization"], ["local optimization"]],
+        ["random search"],
+        [["random", "search"], ["random search"]],
+        ["random optimization"],
+        [["random", "optimization"], ["random optimization"]],
+        ["global search"],
+        [["global", "search"], ["global search"]],
+        ["global optimization"],
+        [["global", "optimization"], ["global optimization"]],
+        ["heuristic search"],
+        [["heuristic", "search"], ["heuristic search"]],
+        ["heuristic optimization"],
+        [["heuristic", "optimization"], ["heuristic optimization"]],
+    ]
+
+    nsga = "NSGA(?:|II|-II|III|-III)"
+    moea_d = "MOEA/D"
+    network = "network(?:|s)"
+    uncertain = "uncertain(?:|ty)"
+    keywords_multi = [  # multi objective
+        [moea_d],
+        [nsga],
+        [f"multi{_h_}objective optimization"],
+        [
+            [f"multi{_h_}objective", "optimization"],
+            [f"multi{_h_}objective optimization"],
+        ],
+        [[f"multi{_h_}objective"], ["optimization"]],
+        [f"multi{_h_}model optimization"],
+        [[f"multi{_h_}model", "optimization"], [f"multi{_h_}model optimization"]],
+        [[f"multi{_h_}model"], ["optimization"]],
+        [f"many{_h_}objective optimization"],
+        [[f"many{_h_}objective", "optimization"], [f"many{_h_}objective optimization"]],
+        [[f"many{_h_}objective"], ["optimization"]],
+        [f"dynamic multi{_h_}objective"],
+        [f"dynamic {evol} multi{_h_}objective"],
+        [
+            ["dynamic", f"multi{_h_}objective"],
+            [
+                f"dynamic multi{_h_}objective",
+                f"dynamic {evol} multi{_h_}objective"
+            ]
+        ],
+        [f"dynamic multi{_h_}model"],
+        [["dynamic", f"multi{_h_}model"], [f"dynamic multi{_h_}model"]],
+        [f"dynamic many{_h_}objective"],
+        [f"dynamic {evol} many{_h_}objective"],
+        [
+            ["dynamic", f"many{_h_}objective"],
+            [
+                f"dynamic many{_h_}objective",
+                f"dynamic {evol} many{_h_}objective",
+            ]
+        ],
+        ["dynamic", "optimization"],
+        ["dynamic", network],
+        [
+            ["dynamic"],
+            [
+                f"multi{_h_}objective",
+                f"multi{_h_}model",
+                f"many{_h_}objective",
+                "optimization",
+                network,
+            ],
+        ],
+        [f"{uncertain} optimization"],
+        [[uncertain, "optimization"], [f"{uncertain} optimization"]],
+        [[uncertain], ["optimization"]],
+        ["pareto optimization"],
+        [["pareto", "optimization"], ["pareto optimization"]],
+        [["pareto"], ["optimization"]],
+    ]
+
+    dimension = "dimension(?:|al)"
+    distribut = "distribut(?:ion|ed)"
+    keywords_parallel = [  # parallel
+        [f"large{_h_}scale"],
+        [f"high{_h_}{dimension}"],
+        [f"high{_h_}performance"],
+        ["parallel", evol],
+        ["parallel", algorithm],
+        [["parallel"], [evol, algorithm]],
+        [distribut, evol],
+        [distribut, algorithm],
+        [[distribut], [evol, algorithm]],
+    ]
+
+    keywords_mo = [  # math optimization
+        [f"zero{_h_}orde", "optimization"],
+        ["coordinate", "descent"],
+        ["gradient", "descent"],
+        ["gradient", "stochastic"],
+        [["gradient"], ["descent", "stochastic"]],
+        ["convex", "optimization"],
+        [f"non{_h_}convex", "optimization"],
+        [["convex"], [f"non{_h_}convex", "optimization"]],
+        [[f"non{_h_}convex"], ["convex", "optimization"]],
+        ["stochastic", "optimization"],
+        [["stochastic"], ["optimization"]],
+        ["gaussian", "distribution"],
+    ]
+
+    multi_task = "multi(?:|-)task"
+    federa = "federa(?:l|ted)"
+    weakly_ = f"weakly{_h_}"
+    generat = "generat(?:ive|ion)"
+    keywords_ml = [  # machine learning
+        ["automated", "machine", "learning"],
+        [["machine", "learning"], [automat]],
+        ["deep", "learning"],
+        [f"semi{_h_}supervised", "learning"],
+        [f"self{_h_}supervised", "learning"],
+        [f"{weakly_}supervised", "learning"],
+        ["unsupervised", "learning"],
+        [f"multi{_h_}instance", "learning"],
+        ["active", "learning"],
+        [
+            ["supervised", "learning"],
+            [
+                f"semi{_h_}supervised",
+                f"self{_h_}supervised",
+                f"weakly{_h_}supervised",
+                "unsupervised",
+            ],
+        ],
+        ["reinforcement", "learning", f"on{_h_}policy"],
+        ["reinforcement", "learning", f"off{_h_}policy"],
+        ["reinforcement", "learning", "offline"],
+        ["reinforcement", "learning", f"model{_h_}based"],
+        ["reinforcement", "learning", "continual"],
+        ["reinforcement", "learning", "deep"],
+        ["reinforcement", "learning", evol],
+        [
+            ["reinforcement", "learning"],
+            [
+                "offline",
+                f"on{_h_}policy",
+                f"off{_h_}policy",
+                f"model{_h_}based",
+                "deep",
+                "continual",
+                evol,
+            ],
+        ],
+        ["policy", "search"],
+        [["policy"], ["policy", "search"]],
+        [f"q{_h_}learning"],
+        ["manifold", "learning"],
+        [["manifold"], ["Learning"]],
+        [multi_task, "learning"],
+        [[multi_task], ["learning"]],
+        ["transfe", "learning"],
+        [["transfe"], ["Learning"]],
+        ["domain", "adaptation"],
+        ["domain", "generalization"],
+        [f"meta{_h_}learning"],
+        [[f"meta{_h_}learning"], ["learning"]],
+        [federa, "learning"],
+        [[federa], ["learning"]],
+        ["ensemble", "learning"],
+        [["ensemble"], ["learning"]],
+        ["online", "learning"],
+        [f"few{_h_}shot", "learning"],
+        [[f"few{_h_}shot"], ["learning"]],
+        [f"one{_h_}shot", "learning"],
+        [[f"one{_h_}shot"], ["learning"]],
+        [f"zero{_h_}shot", "learning"],
+        [[f"zero{_h_}shot"], ["learning"]],
+        ["representation", "learning"],
+        [["representation"], ["learning"]],
+        ["induction"],
+        ["deduction"],
+        ["transduction"],
+        ["neural", network],
+        ["graph", network],
+        [[network], ["graph", "neural"]],
+        [["graph"], [network, "neural"]],
+        ["kernel"],
+        ["embedding"],
+        ["transformer"],
+        ["diffusion", "model"],
+        [["diffusion"], ["model"]],
+        [generat, "model"],
+        [[generat], ["model"]],
+        ["large language model"],
+        [["large", "language", "model"], ["large language model"]],
+    ]
+
+    cluster = "cluster(?:|s|ing)"
+    data_driven = "date(?:| |-)driven"
+    prove = "prov(?:able|e)"
+    predict = "predict(?:|ed|ion)"
+    recommend = "recommend(?:ed|ation)"
+    markov = "markov(?:|ian)"
+    keywords_ec_ml = [  # evolution computation and machine learning
+        ["neuro(?:| |-)evolution"],
+        ["adaptation"],
+        ["bayesian", "optimization"],
+        ["bi-level", "optimization"],
+        ["bayesian", "inference"],
+        ["bayesian", "learning"],
+        [["bayesian"], ["optimization", "inference", "learning"]],
+        [markov, "decision"],
+        [markov, "chain"],
+        [[markov], ["decision", "chain"]],
+        [prove],
+        ["time", "series"],
+        [cluster],
+        [f"co{_h_}evolution", f"co{_h_}operation"],
+        [[f"co{_h_}evolution"], [f"co{_h_}operation"]],
+        [[f"co{_h_}operation"], [f"co{_h_}evolution"]],
+        [data_driven],
+        [predict],
+        [recommend, "system"],
+        [distribut, "shift"],
+    ]
+
+    converg = "converg(?:e|ence|ent|ed|ing)"
+    theor = "theor(?:y|etic|etical|etically)"
+    analy = "analy(?:ze|sis|zed|zing)"
+    bound = "bound(?:|s)"
+    run = "run(?:|ning)"
+    keywords_theory = [  # theory
+        ["drift", "analysis"],
+        ["hitting", "time"],
+        [evol, converg],
+        [evol, "time"],
+        [evol, theor],
+        [evol, bound],
+        [evol, "complexity"],
+        ["swarm", converg],
+        ["swarm", "time"],
+        ["swarm", theor],
+        ["swarm", bound],
+        ["swarm", "complexity"],
+        ["colony", converg],
+        ["colony", "time"],
+        ["colony", theor],
+        ["colony", bound],
+        ["colony", "complexity"],
+        ["genetic", converg],
+        ["genetic", "time"],
+        ["genetic", theor],
+        ["genetic", bound],
+        ["genetic", "complexity"],
+        [analy, converg],
+        [analy, "time"],
+        [analy, theor],
+        [analy, bound],
+        [analy, "complexity"],
+        [computation, "time"],
+        [f"{run} time"],
+        ["upper", bound],
+        ["lower", bound],
+        [[converg], [evol, "swarm", "colony", "genetic", analy]],
+        [
+            ["time"],
+            [evol, "swarm", "colony", "genetic", analy, "hitting", computation, run],
+        ],
+        [[theor], [evol, "swarm", "colony", "genetic", analy]],
+        [[bound], [evol, "swarm", "colony", "genetic", analy, "upper", "lower"]],
+        [["complexity"], [evol, "swarm", "colony", "genetic", analy]],
+        [[analy], [converg, "time", theor, bound, "complexity"]],
+    ]
+
+    keywords_dict = {
+        "EC": keywords_ec,
+        "SS": keywords_ss,
+        "Multi": keywords_multi,
+        "Parallel": keywords_parallel,
+        "MO": keywords_mo,
+        "ML": keywords_ml,
+        "ECML": keywords_ec_ml,
+        "Theory": keywords_theory,
+    }
+    return keywords_dict

pyeasyphd/tools/search/search_base.py

@@ -0,0 +1,118 @@
+import copy
+import re
+from typing import Dict, List, Tuple
+
+from ...bib.bibtexparser import Library
+from ...main import PythonRunBib, PythonWriters
+from .search_writers import WriteInitialResult, WriteSeparateResult
+
+
+def search_keywords_core(keywords_list_list: List[List[str]], library: Library, field: str) -> Tuple[Library, Library]:
+    """Search keywords in `field` such as `title` or `abstract` or `keywords`."""
+    search_library = []
+    no_search_library = []
+
+    for entry in library.entries:
+        flag = False
+        content = entry[field] if field in entry else ""
+        if content:
+            content = re.sub("{", "", content)
+            content = re.sub("}", "", content)
+
+            # All keywords from keyword_list_list[0] should be found in bib
+            flag = all([re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[0]])
+            if flag and (len(keywords_list_list) == 2):
+                # Any keywords from keyword_list_list[1] found in bib will results in False flag.
+                flag = not any([re.search(keyword, content, flags=re.I) for keyword in keywords_list_list[1]])
+
+        if flag:
+            search_library.append(entry)
+        else:
+            no_search_library.append(entry)
+
+    return Library(search_library), Library(no_search_library)
+
+
+class SearchInitialResult(object):
+    """Search initial result.
+
+    Args:
+        options: dict
+
+    Attributes:
+        options: dict
+
+        print_on_screen (bool = False): print on screen
+        deepcopy_library_for_every_field (bool = False): deepcopy library for every field
+    """
+
+    def __init__(self, options: dict) -> None:
+        self.options = options
+
+        self.print_on_screen: bool = options.get("print_on_screen", False)
+        self.deepcopy_library_for_every_field = options.get("deepcopy_library_for_every_field", False)
+
+        self._python_bib = PythonRunBib(options)
+
+        _options = {}
+        _options["empty_entry_cite_keys"] = True
+        _options.update(self.options)
+        self._python_writer = PythonWriters(_options)
+
+    def main(
+        self,
+        search_field_list: List[str],
+        path_initial: str,
+        library: Library,
+        keywords_type: str,
+        keywords_list_list: List[List[str]],
+        combine_keywords: str,
+        output_prefix: str,
+        path_separate: str,
+    ) -> Tuple[List[str], Dict[str, List[List[str]]], Dict[str, int], Library]:
+        """Search."""
+        error_pandoc_md_md, field_data_dict, no_search_library = [], {}, library
+        field_number_dict: Dict[str, int] = {}
+
+        for field in search_field_list:
+            if len(no_search_library.entries) == 0:
+                continue
+
+            # Search
+            search_library, no_search_library = search_keywords_core(keywords_list_list, no_search_library, field)
+            field_number_dict.update({field: len(search_library.entries)})
+
+            # Deepcopy library for every field
+            if self.deepcopy_library_for_every_field:
+                no_search_library = copy.deepcopy(library)
+
+            # Operate on the search library (deepcopy)
+            libraries = self._python_bib.parse_to_multi_standard_library(copy.deepcopy(search_library))
+            library_for_abbr, library_for_zotero, library_for_save = libraries
+
+            if self.print_on_screen:
+                print("".join(self._python_writer.write_to_str(library_for_zotero)))
+                continue
+            if not (library_for_abbr.entries and library_for_zotero.entries and library_for_save.entries):
+                continue
+
+            # Initially write tex, bib, and md files
+            data_temp, temp_error_pandoc_md_md = WriteInitialResult(copy.deepcopy(self.options)).main(
+                path_initial,
+                output_prefix,
+                field,
+                keywords_type,
+                combine_keywords,
+                library_for_abbr,
+                library_for_zotero,
+                library_for_save,
+            )
+
+            # Separatelly write with the method 'a' for '_basic', '_beauty', '_complex'
+            WriteSeparateResult().main(copy.deepcopy(data_temp), field, keywords_type, combine_keywords, path_separate)
+
+            # Save for combined results
+            field_data_dict.update({field: copy.deepcopy(data_temp)})
+            error_pandoc_md_md.extend(temp_error_pandoc_md_md)
+
+        return error_pandoc_md_md, field_data_dict, field_number_dict, no_search_library