OntoAligner 0.1.0__tar.gz

OntoAligner-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Hamed Babaei Giglou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

OntoAligner-0.1.0/OntoAligner.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: OntoAligner
+Version: 0.1.0
+Summary: A short description of your library
+Home-page: https://github.com/HamedBabaei/OntoAligner
+Author: Hamed Babaei Giglou
+Author-email: hamedbabaeigiglou@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# OntoAligner

OntoAligner-0.1.0/OntoAligner.egg-info/SOURCES.txt

@@ -0,0 +1,73 @@
+LICENSE
+README.md
+setup.py
+OntoAligner.egg-info/PKG-INFO
+OntoAligner.egg-info/SOURCES.txt
+OntoAligner.egg-info/dependency_links.txt
+OntoAligner.egg-info/requires.txt
+OntoAligner.egg-info/top_level.txt
+ontoaligner/__init__.py
+ontoaligner/base/__init__.py
+ontoaligner/base/configs.py
+ontoaligner/base/dataset.py
+ontoaligner/base/encoder.py
+ontoaligner/base/model.py
+ontoaligner/base/ontology.py
+ontoaligner/encoder/__init__.py
+ontoaligner/encoder/encoders.py
+ontoaligner/encoder/fewshot.py
+ontoaligner/encoder/lightweight.py
+ontoaligner/encoder/naivconvoaei.py
+ontoaligner/encoder/rag.py
+ontoaligner/evaluation/__init__.py
+ontoaligner/evaluation/evaluator.py
+ontoaligner/evaluation/metrics.py
+ontoaligner/ontology/__init__.py
+ontoaligner/ontology/anatomy.py
+ontoaligner/ontology/biodiv.py
+ontoaligner/ontology/bioml.py
+ontoaligner/ontology/commonkg.py
+ontoaligner/ontology/food.py
+ontoaligner/ontology/mse.py
+ontoaligner/ontology/phenotype.py
+ontoaligner/ontology_matchers/__init__.py
+ontoaligner/ontology_matchers/fewshot/__init__.py
+ontoaligner/ontology_matchers/fewshot/dataset.py
+ontoaligner/ontology_matchers/fewshot/fewshot.py
+ontoaligner/ontology_matchers/fewshot/models.py
+ontoaligner/ontology_matchers/icv/__init__.py
+ontoaligner/ontology_matchers/icv/icv.py
+ontoaligner/ontology_matchers/icv/models.py
+ontoaligner/ontology_matchers/icv/tasks/__init__.py
+ontoaligner/ontology_matchers/icv/tasks/base.py
+ontoaligner/ontology_matchers/icv/tasks/demo.py
+ontoaligner/ontology_matchers/icv/tasks/loader.py
+ontoaligner/ontology_matchers/icv/utils/__init__.py
+ontoaligner/ontology_matchers/icv/utils/context_manager.py
+ontoaligner/ontology_matchers/icv/utils/forward_tracer.py
+ontoaligner/ontology_matchers/icv/utils/llm_layers.py
+ontoaligner/ontology_matchers/icv/utils/pca.py
+ontoaligner/ontology_matchers/icv/utils/rng_ctx.py
+ontoaligner/ontology_matchers/lightweight/__init__.py
+ontoaligner/ontology_matchers/lightweight/lightweight.py
+ontoaligner/ontology_matchers/lightweight/models.py
+ontoaligner/ontology_matchers/llm/__init__.py
+ontoaligner/ontology_matchers/llm/llm.py
+ontoaligner/ontology_matchers/llm/models.py
+ontoaligner/ontology_matchers/rag/__init__.py
+ontoaligner/ontology_matchers/rag/dataset.py
+ontoaligner/ontology_matchers/rag/models.py
+ontoaligner/ontology_matchers/rag/rag.py
+ontoaligner/ontology_matchers/retrieval/__init__.py
+ontoaligner/ontology_matchers/retrieval/models.py
+ontoaligner/ontology_matchers/retrieval/retrieval.py
+ontoaligner/pipeline/__init__.py
+ontoaligner/pipeline/om_pipeline.py
+ontoaligner/postprocess/__init__.py
+ontoaligner/postprocess/process.py
+ontoaligner/tools/__init__.py
+ontoaligner/tools/workdir.py
+ontoaligner/utils/__init__.py
+ontoaligner/utils/io.py
+tests/test_base.py
+tests/test_encoder.py

OntoAligner-0.1.0/OntoAligner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

OntoAligner-0.1.0/OntoAligner.egg-info/requires.txt

@@ -0,0 +1,17 @@
+pathlib
+argparse
+owlready2
+rdflib
+tqdm
+ontospy
+numpy
+torch
+contextlib
+transformers
+datasets
+rapidfuzz
+openai
+rank_bm25
+scikit-learn
+sentence-transformers
+pre-commit

OntoAligner-0.1.0/OntoAligner.egg-info/top_level.txt

@@ -0,0 +1 @@
+ontoaligner

OntoAligner-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: OntoAligner
+Version: 0.1.0
+Summary: A short description of your library
+Home-page: https://github.com/HamedBabaei/OntoAligner
+Author: Hamed Babaei Giglou
+Author-email: hamedbabaeigiglou@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# OntoAligner

OntoAligner-0.1.0/README.md

@@ -0,0 +1 @@
+# OntoAligner

OntoAligner-0.1.0/ontoaligner/__init__.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+__version__ = "0.1.0"
+
+# import logging
+#
+# from onmatcher import base, encoder, evaluation, ontology, ontology_matchers, utils, postprocess
+# from onmatcher.pipeline import OMPipelines
+#
+# __all__ = [
+#     "base",
+#     "ontology",
+#     "utils",
+#     "ontology_matchers",
+#     "encoder",
+#     "pipeline",
+#     "OMPipelines",
+#     "evaluation",
+#     "postprocess"
+# ]
+#
+# # Root logger configuration
+# logger = logging.getLogger(__name__)
+# logger.setLevel(logging.DEBUG)
+#
+# stdout = logging.StreamHandler()
+# stdout.setLevel(logging.DEBUG)
+#
+# formatter = logging.Formatter("%(name)s - %(levelname)s: %(message)s")
+# stdout.setFormatter(formatter)
+#
+# logger.addHandler(stdout)

OntoAligner-0.1.0/ontoaligner/base/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

OntoAligner-0.1.0/ontoaligner/base/configs.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""
+    BaseConfig: Data Configuration of models
+"""
+import argparse
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+
+import openai
+from dotenv import find_dotenv, load_dotenv
+
+_ = load_dotenv(find_dotenv())
+
+
+class BaseConfig:
+    def __init__(self, approach: Optional[str] = "none"):
+        self.batch_size = None
+        self.device = None
+        self.root_dataset_dir = Path(__file__).parents[2]
+        self.parser = argparse.ArgumentParser()
+        self.approach = approach
+
+    def mkdir(self, path):
+        if not os.path.exists(path):
+            os.mkdir(path)
+
+    def __str__(self):
+        return "config."
+
+    def llm(self) -> Dict:
+        config = {
+            "max_token_length": 1,
+            "tokenizer_max_length": 500,
+            "num_beams": 1,
+            "device": self.device,
+            "truncation": True,
+            "top_p": 0.95,
+            "temperature": 0.8,
+            "batch_size": self.batch_size,
+            "padding": "max_length",
+        }
+        if self.approach == "naiv-conv-oaei":
+            config["tokenizer_max_length"] = 4096
+            config["max_token_length"] = 5000
+        return config
+
+    def gpt(self) -> Dict:
+        openai.api_key = os.environ["OPENAI_KEY"]
+        # due to the privacy I had to set key here,
+        # but the correct way is to set inside OPENAILLMARCH class
+        config = {
+            "sleep": 5,
+            "top_p": 0.95,
+            "temperature": 0,
+            "batch_size": self.batch_size,
+            "max_token_length": 2,
+        }
+        if self.approach == "naiv-conv-oaei":
+            config["max_token_length"] = 5000
+        return config
+
+    def fuzzy(self) -> Dict:
+        config = {"fuzzy_sm_threshold": 0.8}
+        return config
+
+    def retrieval(self) -> Dict:
+        config = {"top_k": 5, "device": self.device}
+        return config
+
+    def get_args(self, device="cpu", batch_size: int = None, nshots: int = None) -> Dict:
+        self.device = device
+        self.batch_size = batch_size
+
+        # General configurations
+        self.parser.add_argument("--root_dir", type=str, default=os.path.join(self.root_dataset_dir, "datasets"))
+        self.parser.add_argument("--experiments_dir", type=str, default=os.path.join(self.root_dataset_dir, "experiments"))
+        self.parser.add_argument("--output_dir", type=str, default=os.path.join(self.root_dataset_dir, "experiments", "outputs"))
+        self.parser.add_argument("--stats_dir", type=str, default=os.path.join(self.root_dataset_dir, "experiments", "stats"))
+        self.parser.add_argument("--openai_embedding_dir", type=str, default=os.path.join(self.root_dataset_dir, "assets", "openai-embedding"))
+
+        # LLM configurations
+        llm_config = self.llm()
+        llm_models = ["FlanT5", "LLaMA7B", "Wizard13B", "LLaMA13B", "Mistral7B"]
+        for llm_model in llm_models:
+            self.parser.add_argument("--" + llm_model, type=dict, default=llm_config)
+        self.parser.add_argument("--ChatGPT", type=dict, default=self.gpt())
+        self.parser.add_argument("--GPT4", type=dict, default=self.gpt())
+
+        # Lightweight configurations
+        fuzzy_models = ['SimpleFuzzySM', 'WeightedFuzzySM', 'TokenSetFuzzySM']
+        for fuzzy_model in fuzzy_models:
+            self.parser.add_argument("--" + fuzzy_model, type=dict, default=self.fuzzy())
+
+        # Retrieval Configurations
+        retriever_config = self.retrieval()
+        retriever_models = ["BM25Retrieval", "TFIDFRetrieval", "BERTRetrieval", "SpecterBERTRetrieval",
+                            "FlanT5XLRetrieval", "FlanT5XXLRetrieval", "SVMBERTRetrieval", "AdaRetrieval"]
+        for retriever_model in retriever_models:
+            self.parser.add_argument("--" + retriever_model, type=dict, default=retriever_config)
+
+        # RAG + ICV + FewShot configurations
+        llama_rag_config = {"retriever-config": retriever_config, "llm-config": llm_config, "nshots": nshots}
+        rag_icv_models = ["LLaMA7BAdaRAG", "MistralAdaRAG", "FalconAdaRAG", "VicunaAdaRAG", "MPTAdaRAG",
+                          "LLaMA7BBertRAG", "MistralBertRAG", "FalconBertRAG", "VicunaBertRAG", "MPTBertRAG",
+                          "LLaMA7BAdaICV", "FalconAdaICV", "VicunaAdaICV", "MPTAdaICV",
+                          "LLaMA7BBertICV", "FalconBertICV", "VicunaBertICV", "MPTBertICV",
+                          "LLaMA7BAdaFewShot", "MistralAdaFewShot", "FalconAdaFewShot", "VicunaAdaFewShot", "MPTAdaFewShot",
+                          "LLaMA7BBertFewShot", "MistralBertFewShot", "FalconBertFewShot", "VicunaBertFewShot", "MPTBertFewShot",
+                          "MambaLLMAdaFewShot", "MambaLLMBertFewShot", "MambaLLMAdaRAG", "MambaLLMBertRAG"]
+
+        for rag_icv_model in rag_icv_models:
+            self.parser.add_argument("--" + rag_icv_model, type=dict, default=llama_rag_config)
+
+        openai_rag_config = {"retriever-config": retriever_config, "llm-config": self.gpt(), "nshots": nshots}
+        self.parser.add_argument("--ChatGPTOpenAIAdaRAG", type=dict, default=openai_rag_config)
+        self.parser.add_argument("--ChatGPTOpenAIAdaFewShot", type=dict, default=openai_rag_config)
+
+        self.parser.add_argument("-f")
+        return self.parser.parse_args()

OntoAligner-0.1.0/ontoaligner/base/dataset.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import os
+from abc import ABC
+from typing import Any, Dict
+
+from ontoaligner.base.ontology import BaseAlignmentsParser
+from ontoaligner.utils import io
+
+
+
+class OMDataset(ABC):
+    track: str = ""
+    ontology_name: str = ""
+
+    source_ontology: Any = None
+    target_ontology: Any = None
+
+    alignments: Any = BaseAlignmentsParser()
+
+    working_dir: str = ""
+
+    def collect(self, root_dir: str) -> Dict:
+        om_root_path = os.path.join(root_dir, self.track, self.ontology_name)
+        data = {
+            "dataset-info": {"track": self.track, "ontology-name": self.ontology_name},
+            "source": self.source_ontology.parse(
+                root_dir=om_root_path, ontology_file_name="source.xml"
+            ),
+            "target": self.target_ontology.parse(
+                root_dir=om_root_path, ontology_file_name="target.xml"
+            ),
+            "reference": self.alignments.parse(
+                root_dir=om_root_path, reference_file_name="reference.xml"
+            ),
+        }
+        return data
+
+    def load_from_json(self, root_dir: str) -> Dict:
+        json_file_path = os.path.join(
+            root_dir, self.track, self.ontology_name, "om.json"
+        )
+        json_data = io.read_json(input_path=json_file_path)
+        return json_data
+
+    def __dir__(self):
+        return os.path.join(self.track, self.ontology_name)
+
+    def __str__(self):
+        return f"{self.ontology_name}"

OntoAligner-0.1.0/ontoaligner/base/encoder.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+
+class BaseEncoder(ABC):
+    prompt_template: str = ""
+    items_in_owl: str = ""
+
+    def __str__(self):
+        return self.prompt_template
+
+    def preprocess(self, text: str) -> str:
+        text = text.replace("_", " ")
+        text = text.lower()
+        return text
+
+    @abstractmethod
+    def parse(self, **kwargs) -> Any:
+        pass
+
+    @abstractmethod
+    def get_encoder_info(self) -> str:
+        pass
+
+    def __call__(self, **kwargs):
+        return self.parse(**kwargs)

OntoAligner-0.1.0/ontoaligner/base/model.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class BaseOMModel(ABC):
+    path: str = ""
+
+    def __init__(self, **kwargs) -> None:
+        self.kwargs = kwargs
+
+    @abstractmethod
+    def __str__(self):
+        pass
+
+    @abstractmethod
+    def generate(self, input_data: List) -> List:
+        pass

OntoAligner-0.1.0/ontoaligner/base/ontology.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List
+
+
+from owlready2 import World
+from rdflib import Namespace, URIRef
+from tqdm import tqdm
+
+
+class BaseOntologyParser(ABC):
+    def is_contain_label(self, owl_class: Any) -> bool:
+        try:
+            if len(owl_class.label) == 0:
+                return False
+            return True
+        except Exception as e:
+            print(f"Exception: {e}")
+            return False
+
+    def get_name(self, owl_class: Any) -> str:
+        return owl_class.name
+
+    def get_label(self, owl_class: Any) -> str:
+        return owl_class.label.first()
+
+    def get_iri(self, owl_class: Any) -> str:
+        return owl_class.iri
+
+    def get_childrens(self, owl_class: Any) -> List:
+        return self.get_owl_items(owl_class.subclasses())  # include_self = False
+
+    def get_parents(self, owl_class: Any) -> List:
+        ans = self.get_owl_items(owl_class.is_a)  # include_self = False, ancestors()
+        return ans
+
+    def get_synonyms(self, owl_class: Any) -> List:
+        return self.get_owl_items(owl_class.hasRelatedSynonym)
+
+    @abstractmethod
+    def get_comments(self, owl_class: Any) -> List:
+        pass
+
+    def get_owl_items(self, owl_class: Any) -> List:
+        owl_items = []
+        for item in owl_class:
+            if self.is_contain_label(item):
+                owl_items.append(
+                    {
+                        "iri": self.get_iri(item),
+                        "name": self.get_name(item),
+                        "label": self.get_label(item),
+                    }
+                )
+        return owl_items
+
+    def get_owl_classes(self, ontology: Any) -> Any:
+        return ontology.classes()
+
+    def duplicate_removals(self, owl_class_info: Dict) -> Dict:
+        def ignore_duplicates(iri: str, duplicated_list: List[Dict]) -> List:
+            new_list = []
+            for item in duplicated_list:
+                if iri != item["iri"]:
+                    new_list.append(item)
+            return new_list
+
+        new_owl_class_info = {
+            "name": owl_class_info["name"],
+            "iri": owl_class_info["iri"],
+            "label": owl_class_info["label"],
+            "childrens": ignore_duplicates(
+                iri=owl_class_info["iri"], duplicated_list=owl_class_info["childrens"]
+            ),
+            "parents": ignore_duplicates(
+                iri=owl_class_info["iri"], duplicated_list=owl_class_info["parents"]
+            ),
+            "synonyms": owl_class_info["synonyms"],
+            "comment": owl_class_info["comment"],
+        }
+        return new_owl_class_info
+
+    def extract_data(self, ontology: Any) -> List[Dict]:
+        parsed_ontology = []
+        for owl_class in tqdm(self.get_owl_classes(ontology)):
+            if not self.is_contain_label(owl_class):
+                continue
+            owl_class_info = {
+                "name": self.get_name(owl_class),
+                "iri": self.get_iri(owl_class),
+                "label": self.get_label(owl_class),
+                "childrens": self.get_childrens(owl_class),
+                "parents": self.get_parents(owl_class),
+                "synonyms": self.get_synonyms(owl_class),
+                "comment": self.get_comments(owl_class),
+            }
+            owl_class_info = self.duplicate_removals(owl_class_info=owl_class_info)
+            parsed_ontology.append(owl_class_info)
+        return parsed_ontology
+
+    def load_ontology(self, input_file_path: str) -> Any:
+        ontology = World()
+        ontology.get_ontology(input_file_path).load()
+        return ontology
+
+    def parse(self, root_dir: str, ontology_file_name: str) -> List:
+        input_file_path = os.path.join(root_dir, ontology_file_name)
+        print(f"\t\tworking on {input_file_path}")
+        ontology = self.load_ontology(input_file_path=input_file_path)
+        return self.extract_data(ontology)
+
+
+class BaseAlignmentsParser(ABC):
+    namespace: Namespace = Namespace(
+        "http://knowledgeweb.semanticweb.org/heterogeneity/alignment"
+    )
+    entity_1: URIRef = URIRef(namespace + "entity1")
+    entity_2: URIRef = URIRef(namespace + "entity2")
+    relation: URIRef = URIRef(namespace + "relation")
+
+    def extract_data(self, reference: Any) -> List[Dict]:
+        parsed_references = []
+        graph = reference.as_rdflib_graph()
+        for source, predicate, target in tqdm(graph):
+            if predicate == self.relation:
+                entity_1 = [
+                    str(o) for s, p, o in graph.triples((source, self.entity_1, None))
+                ][0]
+                entity_2 = [
+                    str(o) for s, p, o in graph.triples((source, self.entity_2, None))
+                ][0]
+                parsed_references.append(
+                    {"source": entity_1, "target": entity_2, "relation": str(target)}
+                )
+        return parsed_references
+
+    def load_ontology(self, input_file_path: str) -> Any:
+        ontology = World()
+        ontology.get_ontology(input_file_path).load()
+        return ontology
+
+    def parse(self, root_dir: str, reference_file_name: str) -> List:
+        input_file_path = os.path.join(root_dir, reference_file_name)
+        print(f"\t\tworking on reference: {input_file_path}")
+        reference = self.load_ontology(input_file_path=input_file_path)
+        return self.extract_data(reference)

OntoAligner-0.1.0/ontoaligner/encoder/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

OntoAligner-0.1.0/ontoaligner/encoder/encoders.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+from typing import Any, Dict
+
+from ..base import BaseEncoder
+
+
+class LightweightEncoder(BaseEncoder):
+    def parse(self, **kwargs) -> Any:
+        source_onto, target_onto = kwargs["source"], kwargs["target"]
+        source_ontos = []
+        for source in source_onto:
+            encoded_source = self.get_owl_items(owl=source)
+            encoded_source["text"] = self.preprocess(encoded_source["text"])
+            source_ontos.append(encoded_source)
+        target_ontos = []
+        for target in target_onto:
+            encoded_target = self.get_owl_items(owl=target)
+            encoded_target["text"] = self.preprocess(encoded_target["text"])
+            target_ontos.append(encoded_target)
+        return [source_ontos, target_ontos]
+
+    def __str__(self):
+        return {"LightweightEncoder": self.items_in_owl}
+
+    def get_owl_items(self, owl: Dict) -> Any:
+        pass
+
+    def get_encoder_info(self):
+        return "INPUT CONSIST OF COMBINED INFORMATION TO FUZZY STRING MATCHING"
+
+
+class NaiveConvOAEIEncoder(BaseEncoder):
+    prompt_template: str = """<Problem Definition>
+In this task, we are given two ontologies in the form of {items_in_owl}, which consist of IRI and classes.
+
+<Ontologies-1>
+{source}
+
+<Ontologies-2>
+{target}
+
+<Objective>
+Our objective is to provide ontology mapping for the provided ontologies based on their semantic similarities.
+
+For a class in the ontology-1, which class in ontology-2 is the best match?
+
+List matches per line.
+"""
+
+    def parse(self, **kwargs) -> Any:
+        source_onto, target_onto = kwargs["source"], kwargs["target"]
+        source_text = ""
+        for source in source_onto:
+            source_text += self.get_owl_items(owl=source)
+        target_text = ""
+        for target in target_onto:
+            target_text += self.get_owl_items(owl=target)
+        prompt_sample = self.get_prefilled_prompt()
+        prompt_sample = prompt_sample.replace("{source}", source_text)
+        prompt_sample = prompt_sample.replace("{target}", target_text)
+        return [prompt_sample]
+
+    def __str__(self):
+        return {
+            "Template": super().__str__(),
+            "NaiveConvOAEIPrompting": self.items_in_owl,
+        }
+
+    def get_owl_items(self, owl: Dict) -> str:
+        pass
+
+    def get_prefilled_prompt(self) -> str:
+        prompt_sample = self.prompt_template
+        prompt_sample = prompt_sample.replace("{items_in_owl}", self.items_in_owl)
+        return prompt_sample
+
+    def get_encoder_info(self) -> str:
+        return "PROMPT-TEMPLATE: " + self.get_prefilled_prompt()
+
+
+class RAGEncoder(BaseEncoder):
+    retrieval_encoder: Any = None
+    llm_encoder: str = None
+
+    def parse(self, **kwargs) -> Any:
+        # self.dataset_module = kwargs["dataset-module"]
+        source_onto_iri2index = {
+            source["iri"]: index for index, source in enumerate(kwargs["source"])
+        }
+        target_onto_iri2index = {
+            target["iri"]: index for index, target in enumerate(kwargs["target"])
+        }
+        return {
+            "retriever-encoder": self.retrieval_encoder,
+            "llm-encoder": self.llm_encoder,
+            "task-args": kwargs,
+            "source-onto-iri2index": source_onto_iri2index,
+            "target-onto-iri2index": target_onto_iri2index,
+        }
+
+    def __str__(self):
+        return {"RagEncoder": self.items_in_owl}
+
+    def get_encoder_info(self) -> str:
+        return "PROMPT-TEMPLATE USES:" + self.llm_encoder + " ENCODER"