relrae 0.9.0__py3-none-any.whl

relrae/RELRaE.py

@@ -0,0 +1,91 @@
+from rdflib import Graph, Namespace
+from rdflib.namespace import RDF, RDFS, OWL
+import xmlschema
+from pathlib import Path
+
+
+from .modules.RuBREx import RuBREx
+from .modules.LLM_Ref import LLMRefinement
+from .modules.human_fix import HumanFix
+from .utils import get_now
+
+
+class RELRaE:
+
+    def __init__(self, onto_name, schema, namespace, prefix, config,
+                 components_root="relrae_components", output_root="output"):
+        self.components_root = Path(components_root)
+        self.output_root = Path(output_root)
+        schema_path = self.components_root / "schema" / schema
+        self.schema = xmlschema.XMLSchema(schema_path)
+        self.namespace = Namespace(namespace)
+        self.prefix = prefix
+        self.onto_name = onto_name
+        self.onto = Graph()
+        self.errors = []
+        self.config = config
+        self.configs = [{"Pipeline": config}]
+        self.logs = {}
+
+        self.onto.bind('rdf', RDF)
+        self.onto.bind('rdfs', RDFS)
+        self.onto.bind('owl', OWL)
+        self.onto.bind(self.prefix, self.namespace)
+
+    def RuBREx(self):
+        m_rubrex = RuBREx(
+            self.schema, self.onto, self.prefix, self.namespace,
+            self.components_root,
+        )
+        m_rubrex.match_concepts()
+        m_rubrex.schema_coverage()
+
+        self.configs.append({"RuBREx": m_rubrex.config})
+        self.logs["RuBREx"] = m_rubrex.log
+        # NOTE: Consider the module complete
+        self.onto = self.onto + m_rubrex.onto
+        self.errors.append(m_rubrex.errors)
+
+    def LLM_Refinement_Loop(self):
+        m_LLM_ref = LLMRefinement(
+            self.schema, self.onto, self.prefix, self.namespace,
+            self.components_root)
+        m_LLM_ref.evaluate_relations()
+        self.errors.append(m_LLM_ref.errors)
+
+    def human_fix(self):
+        # TODO:
+        m_human_fix = HumanFix(
+            self.schema, self.onto, self.prefix, self.namespace,
+            self.components_root, self.errors, self.config["modules"]
+        )
+        m_human_fix.set_user_info()
+        m_human_fix.fix_errors()
+        m_human_fix.concepts_to_add_output(path)
+
+    def write_logs(self, path):
+        for key, values in self.logs.items():
+            with (path / f"{key}.txt").open("w", encoding="utf-8") as f:
+                for line in values:
+                    f.write(line + "\n")
+
+    def write_metadata(self, path):
+        with (path / "metadata.txt").open("w", encoding="utf-8") as f:
+            for config in self.configs:
+                for section, values in config.items():
+                    f.write(f"{section}\n\n")
+                    for key, value in values.items():
+                        f.write(f"{key}: {value}\n")
+                f.write("\n\n")
+
+    def serialise(self):
+        timestamp = get_now().replace(":", "-")
+        main_path = self.output_root / f"{self.onto_name}{timestamp}"
+        log_path = main_path / "logs"
+        log_path.mkdir(parents=True)
+        self.write_logs(log_path)
+        self.write_metadata(main_path)
+        self.onto.serialize(
+            destination=main_path / f"{self.onto_name}.ttl",
+            format="ttl",
+        )

relrae/__init__.py

@@ -0,0 +1,6 @@
+"""Public package interface for RELRaE."""
+
+from ._version import __version__
+from .RELRaE import RELRaE
+
+__all__ = ["RELRaE", "__version__"]

relrae/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

relrae/_version.py

@@ -0,0 +1,3 @@
+"""The single source of truth for the RELRaE package version."""
+
+__version__ = "0.9.0"

relrae/cli.py

@@ -0,0 +1,65 @@
+import argparse
+from importlib.resources import files
+from pathlib import Path
+import shutil
+
+
+COMPONENT_DIRECTORIES = ("config", "rules", "schema", "output")
+
+
+def _copy_defaults(source, destination):
+    """Copy packaged defaults without replacing user-edited files."""
+    for resource in source.iterdir():
+        # Finder metadata is not part of a RELRaE project, even if it happens
+        # to be present in a source checkout.
+        if resource.name.startswith("."):
+            continue
+
+        target = destination / resource.name
+        if resource.is_dir():
+            target.mkdir(exist_ok=True)
+            _copy_defaults(resource, target)
+        elif not target.exists():
+            with resource.open("rb") as source_file, target.open("xb") as target_file:
+                shutil.copyfileobj(source_file, target_file)
+
+
+def initialise_project(project_root=None):
+    """Create a RELRaE project beneath *project_root* (the cwd by default).
+
+    Existing files are intentionally left untouched, making ``relrae init``
+    safe to run again after configuration files have been customised.
+    """
+    project_root = Path.cwd() if project_root is None else Path(project_root)
+    components_root = project_root / "relrae_components"
+
+    project_root.mkdir(parents=True, exist_ok=True)
+    for directory in COMPONENT_DIRECTORIES:
+        (components_root / directory).mkdir(parents=True, exist_ok=True)
+
+    packaged_defaults = files("relrae").joinpath("relrae_components")
+    _copy_defaults(packaged_defaults, components_root)
+
+    print(f"Initialised RELRaE project in {components_root}")
+    return components_root
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    subparsers = parser.add_subparsers(dest="command")
+
+    init_parser = subparsers.add_parser(
+        "init", help="create a RELRaE project in the current directory"
+    )
+    init_parser.add_argument(
+        "directory",
+        nargs="?",
+        default=Path.cwd(),
+        type=Path,
+        help="project directory (default: current directory)",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        initialise_project(args.directory)

relrae/modules/LLM_Ref.py

@@ -0,0 +1,525 @@
+import json
+import os
+import re
+import configparser
+from pathlib import Path
+from urllib import request
+from urllib.error import URLError
+from typing import Literal
+from pydantic import BaseModel, Field, config
+from ..utils import get_now, namespace_to_prefix
+from random import randint
+import numpy as np
+from rdflib.namespace import RDFS
+from rdflib import URIRef
+import rdflib
+
+class LLMRefinement:
+
+    def __init__(self, schema, onto, prefix, namespace,
+                 components_root="relrae_components"):
+        self.log = []
+        cfg = configparser.ConfigParser()
+        cfg.read(Path(components_root) / "config" / "LLM_ref_conf.txt")
+        self.config = cfg["MAIN"]
+        self.errors = []
+        self.schema = schema
+        self.onto = onto
+        self.prefix = prefix
+        self.namespace = namespace
+        self.set_models()
+
+    # NOTE: This might not be neccessary
+    def set_models(self):
+        pass
+
+    def get_relations(self):
+        query = """
+        PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        PREFIX owl:  <http://www.w3.org/2002/07/owl#>
+
+        SELECT ?property ?propertyType
+        WHERE {
+            VALUES ?propertyType {
+                rdf:Property
+                owl:ObjectProperty
+                owl:DatatypeProperty
+                owl:AnnotationProperty
+            }
+
+            ?property rdf:type ?propertyType .
+        }
+        """
+        qres = self.onto.query(query)
+        property_list = []
+        for r in qres:
+            property_list.append(r.property)
+        self.log.append(f"Retrieved {len(property_list)} properties")
+        return property_list
+
+    def get_relation_info(self, relation):
+        query = f"""
+        PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        PREFIX owl:  <http://www.w3.org/2002/07/owl#>
+
+        SELECT ?subject ?predicate ?object
+        WHERE {{
+            {{
+                BIND(<{relation}> AS ?subject)
+                ?subject ?predicate ?object .
+            }}
+            UNION
+            {{
+                ?subject ?predicate <{relation}> .
+                BIND(<{relation}> AS ?object)
+            }}
+        }}
+        """
+        qres = self.onto.query(query)
+        prefixed_relation = namespace_to_prefix(
+            relation, self.namespace, self.prefix)
+        rel_info = {prefixed_relation: []}
+        for r in qres:
+            rel_info[prefixed_relation].append([
+                namespace_to_prefix(r.predicate, self.namespace, self.prefix),
+                namespace_to_prefix(r.object, self.namespace, self.prefix)
+            ])
+        self.log.append(f"Retrieved info for relation {str(relation)}")
+        # print(rel_info)
+        return rel_info
+
+    def normalise_relation_label(self, label):
+        label = namespace_to_prefix(label, self.namespace, self.prefix).strip()
+        prefix_marker = f"{self.prefix}:"
+
+        if ":" in label:
+            prefix, label = label.split(":", 1)
+            if prefix != self.prefix:
+                prefix = self.prefix
+        else:
+            prefix = self.prefix
+
+        words = re.findall(r"[A-Za-z0-9]+", label)
+        if not words:
+            raise ValueError(f"Cannot normalise empty relation label: {label}")
+
+        camel_label = words[0].lower()
+        for word in words[1:]:
+            camel_label += word[:1].upper() + word[1:].lower()
+
+        return f"{prefix_marker}{camel_label}"
+
+    def get_examples(self, model_role, strat):
+        if model_role == "eval":
+            examples = self.config["eval_examples"]
+        else:
+            examples = self.config["ref_examples"]
+
+        # print(examples)
+        shots = {"zero": None,
+                 "one": 0,
+                 "few": 4}
+
+        if strat == "zero":
+            return []
+
+        examples_list = examples[0:shots[strat]]
+        return examples_list
+
+    def average_eval(self, responses):
+        evals = []
+        confs = []
+        for r in responses:
+            if r["evaluation"] == "Yes":
+                evals.append(1)
+            else:
+                evals.append(0)
+            confs.append(r["confidence"])
+        mean_evals = round((sum(evals)/len(evals)), 0)
+        if int(mean_evals) == 1:
+            eval = "Yes"
+        else:
+            eval = "No"
+        avg_eval = {
+            "evaluation": eval,
+            "confidence": round(sum(confs)/len(confs), 3),
+            "variance": round(float(np.var(evals)), 3)
+        }
+        return avg_eval
+
+    def evaluation_loop(self, relation, evaluator, refiner, info):
+        accepted = False
+        rejected_labels = []
+        loops = 0
+        active_label = relation
+
+        while not accepted and loops < int(self.config["refinement_loops"]):
+            loops += 1
+            eval_model = evaluator[0]
+            eval_prompt = eval_model.build_eval_prompt(
+                namespace_to_prefix(active_label, self.namespace, self.prefix),
+                self.config["domain"],
+                self.config["source"],
+                info,
+                rejected_labels,
+                self.config["eval_messages"],
+                evaluator[1])
+            # print(eval_prompt)
+            full_eval = eval_model.run_prompt(eval_prompt)
+            if full_eval[0] == "Error":
+                self.log.append("Error: LLM could not generate valid response")
+            else:
+                avg_eval = self.average_eval(full_eval[0])
+                print(active_label)
+                print("\n=======================\n")
+                print(avg_eval)
+                print("\n=======================\n")
+                print(full_eval[1])
+
+                self.log.append(full_eval[1])
+                if avg_eval["evaluation"] == "Yes":
+                    self.log.append("Label accepted")
+                    break
+
+                self.log.append("Label rejected")
+            rejected_labels.append(namespace_to_prefix(
+                active_label, self.namespace, self.prefix))
+            print("\n ==== Rejected -> Refining ==== \n")
+            ref_model = refiner[0]
+            ref_prompt = ref_model.build_ref_prompt(
+                namespace_to_prefix(active_label, self.namespace, self.prefix),
+                self.config["domain"],
+                self.config["source"],
+                info,
+                rejected_labels,
+                self.config["ref_messages"],
+                refiner[1])
+            full_ref = ref_model.run_prompt(ref_prompt)
+            ref = full_ref[0][0]
+            print(ref)
+            print(rejected_labels)
+            print("\n=======================\n")
+            print(full_ref[1])
+            print("\n=======================\n")
+            self.log.append(full_ref[1])
+            active_label = self.normalise_relation_label(
+                ref["relationship_label"])
+
+        if accepted:
+            self.replace_relation(relation, active_label)
+            return ["refined", rejected_labels]
+        else:
+            return ["unrefined", rejected_labels]
+
+    def evaluate_relations(self):
+        relations = self.get_relations()
+
+        eval_m = LLM(self.config["eval_llm"],
+                     EvaluatorResponse,
+                     self.config["eval_repeats"],
+                     self.namespace,
+                     self.prefix)
+        eval_ex = self.get_examples("eval", self.config["eval_prompt_strat"])
+
+        ref_m = LLM(self.config["ref_llm"],
+                    RefinerResponse,
+                    self.config["ref_repeats"],
+                    self.namespace,
+                    self.prefix)
+        ref_ex = self.get_examples("ref", self.config["ref_prompt_strat"])
+
+        for rel in relations:
+            rel_info = self.get_relation_info(rel)
+            response = self.evaluation_loop(rel, [eval_m, eval_ex], [
+                                            ref_m, ref_ex], rel_info)
+            if response[0] == "unrefined":
+                self.errors.append([rel, rel_info, response[1]])
+
+    def replace_relation(self, original, new):
+        query = f"""
+        PREFIX rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+        PREFIX owl:  <http://www.w3.org/2002/07/owl#>
+
+        SELECT ?s ?p ?o WHERE{{
+            ?s ?p ?o
+            FITLER(
+                ?s = <{self.namespace}{original}> ||
+                ?p = <{self.namespace}{original}> ||
+                ?o = <{self.namespace}{original}>
+            )
+        }}
+        """
+        qres = self.onto.query(query)
+
+        for r in qres:
+
+            if r.p == str(RDFS.label):
+                n_sub = URIRef(f"{self.namespace}{new}")
+                n_obj = rdflib.Literal(new)
+                self.onto.remove((r.s, r.p, r.o))
+                self.onto.add((n_sub, r.p, n_obj))
+            elif r.s == f"{self.namespace}{original}":
+                n_sub = URIRef(f"{self.namespace}{new}")
+                self.onto.remove((r.s, r.p, r.o))
+                self.onto.add((n_sub, r.p, r.o))
+            elif r.p == f"{self.namespace}{original}":
+                n_pred = URIRef(f"{self.namespace}{new}")
+                self.onto.remove((r.s, r.p, r.o))
+                self.onto.add((r.s, n_pred, r.o))
+            elif r.o == f"{self.namespace}{original}":
+                n_obj = URIRef(f"{self.namespace}{new}")
+                self.onto.remove((r.s, r.p, r.o))
+                self.onto.add((r.s, r.p, n_obj))
+
+        s = URIRef(f"{self.namespace}{new}")
+        p = URIRef(f"{self.namespace}editedBy")
+        o = rdflib.Literal(f"{self.config["eval_llm"]} @ {get_now()}")
+        self.onto.add([s, p, o])
+        self.log.append(f"Relationship {original} updated to {new}.")
+
+class EvaluatorResponse(BaseModel):
+    evaluation: Literal["Yes", "No"]
+    justification: str
+    confidence: float = Field(ge=0.00, le=100.00)
+
+
+class RefinerResponse(BaseModel):
+    relationship_label: str
+    justification: str
+
+
+class LLM:
+
+    def __init__(self, settings, format, repeats, ns, pr):
+        self.repeats = repeats
+        self.model = settings[0]
+        self.api_key = settings[1]
+        self.params = settings[2]
+        self.provider = self.get_provider(settings)
+        self.r_format = format
+        self.onto_ns = ns
+        self.onto_pr = pr
+
+    def gen_seeds(self, n):
+        seeds = []
+        for i in range(int(n)):
+            seeds.append(randint(1, 9999))
+        return seeds
+
+    def get_provider(self, settings):
+        if len(settings) > 3:
+            return str(settings[3]).lower()
+        if isinstance(self.params, dict) and self.params.get("provider"):
+            return str(self.params["provider"]).lower()
+        if str(self.api_key).lower() in ("", "none", "ollama"):
+            return "ollama"
+        if str(self.model).lower().startswith(("gpt", "o1", "o3", "o4")):
+            return "openai"
+        if str(self.model).lower().startswith(("gemini", "models/gemini")):
+            return "google"
+        return "ollama"
+
+    def build_messages(self, prompt, examples, active):
+        message_list = [{"role": "system", "content": prompt}]
+        for example in examples:
+            for e in example:
+                message_list.append(e)
+        message_list.append(active)
+        return message_list
+
+    def process_context(self, context):
+        context_list = []
+        reject_relations = [
+            "http://www.w3.org/2000/01/rdf-schema#label",
+            f"{self.onto_pr}:generatedBy",
+            f"{self.onto_pr}:hasXSDSource"
+        ]
+        for l in context.keys():
+            for r in context[l]:
+                if r[0] in reject_relations:
+                    continue
+                triple = [l, r[0], r[1]]
+                context_list.append(triple)
+        print(context_list)
+        return context_list
+
+    def build_eval_prompt(self, relation, domain, source, info, rejected_label, prompt, examples):
+        active = {"role": "user", "content": f"relation: {relation}, context: {
+            self.process_context(info)}, domain: {domain}, source: {source}, rejected labels: {rejected_label}"}
+
+        messages = self.build_messages(prompt[0], examples, active)
+        return messages
+
+    def build_ref_prompt(self, relation, domain, source, info, rejected_label, prompt, examples):
+        active = {"role": "user", "content": f"relation: {relation}, context: {
+            self.process_context(info)}, domain: {domain}, source: {source}, rejected_labels: {rejected_label}"}
+
+        messages = self.build_messages(prompt[0], examples, active)
+        return messages
+
+    def run_prompt(self, messages):
+        results = []
+        logs = []
+        seeds = []
+        seed = 0
+
+        while seed < int(self.repeats):
+            retrys = 10
+            valid = False
+            while not valid and retrys > 0:
+                c_seed = randint(1, 9999)
+                try:
+                    raw_response = self.call_provider(messages, c_seed)
+                    parsed_response = self.parse_response(raw_response)
+                    results.append(parsed_response)
+                    logs.append({
+                        "provider": self.provider,
+                        "model": self.model,
+                        "seed": c_seed,
+                        "response": parsed_response,
+                    })
+                    valid = True
+                    seeds.append(c_seed)
+                    seed += 1
+                    retrys -= 1
+                except Exception as exc:
+                    logs.append({
+                        "provider": self.provider,
+                        "model": self.model,
+                        "seed": c_seed,
+                        "error": str(exc),
+                    })
+                    retrys -= 1
+
+        if not results:
+            results = "Error"
+
+        return [results, logs]
+
+    def call_provider(self, messages, seed):
+        if self.provider == "ollama":
+            return self.call_ollama(messages, seed)
+        if self.provider == "openai":
+            return self.call_openai(messages, seed)
+        if self.provider in ("google", "googleai", "gemini"):
+            return self.call_google(messages, seed)
+        raise ValueError(f"Unsupported LLM provider: {self.provider}")
+
+    def get_params(self, seed, provider=None):
+        params = {}
+        if isinstance(self.params, dict):
+            params.update(self.params)
+        params.pop("provider", None)
+        params["seed"] = seed
+        if provider == "openai":
+            supported = {
+                "temperature",
+                "top_p",
+                "max_tokens",
+                "max_completion_tokens",
+                "presence_penalty",
+                "frequency_penalty",
+                "seed",
+                "stop",
+            }
+            params = {
+                key: value for key, value in params.items()
+                if key in supported
+            }
+        return params
+
+    def get_api_key(self, env_var):
+        if str(self.api_key).lower() not in ("", "none"):
+            return self.api_key
+        return os.environ.get(env_var)
+
+    def parse_response(self, raw_response):
+        if isinstance(raw_response, self.r_format):
+            return raw_response.model_dump()
+        if isinstance(raw_response, dict):
+            return self.r_format.model_validate(raw_response).model_dump()
+        return self.r_format.model_validate_json(raw_response).model_dump()
+
+    def messages_to_text(self, messages):
+        prompt_parts = []
+        for message in messages:
+            prompt_parts.append(f"{message['role']}: {message['content']}")
+        return "\n\n".join(prompt_parts)
+
+    def call_ollama(self, messages, seed):
+        params = self.get_params(seed, "ollama")
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+            "format": self.r_format.model_json_schema(),
+            "options": params,
+        }
+        data = json.dumps(payload).encode("utf-8")
+        req = request.Request(
+            "http://localhost:11434/api/chat",
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            with request.urlopen(req, timeout=120) as response:
+                body = json.loads(response.read().decode("utf-8"))
+        except URLError as exc:
+            raise RuntimeError(
+                "Could not reach Ollama at localhost:11434") from exc
+
+        return body["message"]["content"]
+
+    def call_openai(self, messages, seed):
+        try:
+            from openai import OpenAI
+        except ImportError as exc:
+            raise ImportError(
+                "Install the openai package to use OpenAI models") from exc
+
+        api_key = self.get_api_key("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OpenAI API key missing")
+
+        params = self.get_params(seed, "openai")
+        client = OpenAI(api_key=api_key)
+        completion = client.chat.completions.parse(
+            model=self.model,
+            messages=messages,
+            response_format=self.r_format,
+            **params,
+        )
+        return completion.choices[0].message.parsed
+
+    def call_google(self, messages, seed):
+        try:
+            from google import genai
+        except ImportError as exc:
+            raise ImportError(
+                "Install the google-genai package to use Google AI models"
+            ) from exc
+
+        api_key = self.get_api_key("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("Google AI API key missing")
+
+        params = self.get_params(seed, "google")
+        client = genai.Client(api_key=api_key)
+        response = client.models.generate_content(
+            model=self.model,
+            contents=self.messages_to_text(messages),
+            config={
+                **params,
+                "response_format": {
+                    "text": {
+                        "mime_type": "application/json",
+                        "schema": self.r_format.model_json_schema(),
+                    }
+                },
+            },
+        )
+        return response.text