From 7ece7bdd61a871b69a56152e006bff87d5774197 Mon Sep 17 00:00:00 2001 From: Caglar Demir Date: Wed, 5 Aug 2026 16:44:11 +0200 Subject: [PATCH] Remove stale, unused ontolearn/tentris.py Self-marked "Stale script! Should be updated or removed!" and unused anywhere else in the codebase. It imported ontolearn.base, which was deleted back in the owlapy 1.1.0 migration (2024), so it hadn't actually been importable in a long time -- the owlapy 1.6.6 migration (#601) fixed its two owlapy-related imports per #599, but that only surfaced this deeper, pre-existing breakage rather than resolving it. Closes #599. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01QAArxHvomYuQmzjbMiV8d4 --- CHANGELOG.md | 6 + ontolearn/tentris.py | 339 ------------------------------------------- 2 files changed, 6 insertions(+), 339 deletions(-) delete mode 100644 ontolearn/tentris.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f63ae3ad..6ba745a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,12 @@ date) and use that section as the basis for the GitHub release notes. ## [Unreleased] +### Removed +- `ontolearn/tentris.py`, a stale, self-marked-TODO script unused anywhere + else in the codebase. It imported `ontolearn.base`, a module removed back + in the owlapy 1.1.0 migration, so it hadn't been importable for a long + time. (#599) + ### Added - Example for generating learning problems with numeric data properties (`examples/generate_numeric_lps.py`). (#593) diff --git a/ontolearn/tentris.py b/ontolearn/tentris.py deleted file mode 100644 index 134e537f..00000000 --- a/ontolearn/tentris.py +++ /dev/null @@ -1,339 +0,0 @@ -# ----------------------------------------------------------------------------- -# MIT License -# -# Copyright (c) 2024 Ontolearn Team -# -# 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. -# ----------------------------------------------------------------------------- - -"""Tentris representations.""" - -import logging -from functools import singledispatchmethod -from types import MappingProxyType -from typing import Optional, Iterable - -import httpx as httpx -from owlapy.class_expression import OWLClassExpression, OWLClass, OWLThing -from owlapy.iri import IRI -from owlapy.owl_axiom import OWLDataPropertyRangeAxiom, OWLObjectPropertyRangeAxiom, OWLObjectPropertyDomainAxiom, \ - OWLDataPropertyDomainAxiom -from owlapy.owl_individual import OWLNamedIndividual -from owlapy.owl_literal import OWLLiteral -from owlapy.owl_object import OWLEntity -from owlapy.abstracts import AbstractOWLOntology -from owlapy.owl_ontology import OWLOntologyID -from owlapy.owl_property import OWLObjectPropertyExpression, OWLObjectProperty, OWLDataProperty - -from ontolearn.knowledge_base import KnowledgeBase -from ontolearn.abstracts import AbstractScorer, AbstractLearningProblem, AbstractKnowledgeBase, \ - EncodedPosNegLPStandardKind -from ontolearn.base.owl.utils import OWLClassExpressionLengthMetric -from ontolearn.search import EvaluatedConcept -from ontolearn.learning_problem import PosNegLPStandard -from ontolearn.metrics import F1, Precision, Accuracy, Recall -from ontolearn.utils import oplogging, Factory -from ontolearn.base.ext import OWLReasonerEx -from ontolearn.base import OntologyManager, OntologyReasoner -from owlapy.render import ManchesterOWLSyntaxOWLObjectRenderer, DLSyntaxObjectRenderer -from owlapy.utils import LRUCache - -logger = logging.getLogger(__name__) - -# TODO: Stale script! Should be updated or removed! - -_Metric_map = MappingProxyType({ - F1: 'f1_score', - Precision: 'precision', - Recall: 'recall', - Accuracy: 'accuracy', - # WeightedAccuracy: , - # : specificity, - # : sensitivity, -}) - -_debug_render = DLSyntaxObjectRenderer().render - - -def _full_iri_renderer(e: OWLEntity) -> str: - return f'<{e.to_string_id()}>' - - -_tentris_render = ManchesterOWLSyntaxOWLObjectRenderer(_full_iri_renderer, no_render_thing=True).render - - -class EncodedPosNegLPStandardTentris(EncodedPosNegLPStandardKind): - __slots__ = 'id' - - def __init__(self, id): - self.id = id - - def __repr__(self): - return f'EncodedPosNegLPStandardTentris(id={self.id})' - - -class TentrisOntology(AbstractOWLOntology): - __slots__ = '_path', '_endpoint_url', '_backing_mgr', '_backing_onto', '_endpoint_timeout' - - def __init__(self, path: str, endpoint_url: str, timeout: float): - self._path = path - self._endpoint_url = endpoint_url - self._endpoint_timeout = timeout - self._backing_mgr = OntologyManager() - self._backing_onto = self._backing_mgr.load_ontology(IRI.create('file://' + self._path)) - - def classes_in_signature(self) -> Iterable[OWLClass]: - logger.debug("Calling classes_in_signature from backing onto") - yield from self._backing_onto.classes_in_signature() - - def data_properties_in_signature(self) -> Iterable[OWLDataProperty]: - logger.debug("Calling data_properties_in_signature from backing onto") - yield from self._backing_onto.data_properties_in_signature() - - def object_properties_in_signature(self) -> Iterable[OWLObjectProperty]: - logger.debug("Calling object_properties_in_signature from backing onto") - yield from self._backing_onto.object_properties_in_signature() - - def individuals_in_signature(self) -> Iterable[OWLNamedIndividual]: - res = httpx.get(self._endpoint_url + '/instances', - params={'class_expression': _tentris_render(OWLThing)}) - for i in res.json()['instances']: - yield OWLNamedIndividual(IRI.create(i)) - - def data_property_range_axioms(self, property: OWLDataProperty) -> Iterable[OWLDataPropertyRangeAxiom]: - raise NotImplementedError - - def data_property_domain_axioms(self, property: OWLDataProperty) -> Iterable[OWLDataPropertyDomainAxiom]: - logger.debug("Calling data_property_domain_axioms from backing onto") - yield from self._backing_onto.data_property_domain_axioms(property) - - def object_property_domain_axioms(self, property: OWLObjectProperty) -> Iterable[OWLObjectPropertyDomainAxiom]: - logger.debug("Calling object_property_domain_axioms from backing onto") - yield from self._backing_onto.object_property_domain_axioms(property) - - def object_property_range_axioms(self, property: OWLObjectProperty) -> Iterable[OWLObjectPropertyRangeAxiom]: - logger.debug("Calling object_property_range_axioms from backing onto") - yield from self._backing_onto.object_property_range_axioms(property) - - def get_owl_ontology_manager(self) -> OntologyManager: - raise NotImplementedError - - def get_ontology_id(self) -> OWLOntologyID: - raise NotImplementedError - - def __eq__(self, other): - if type(other) == type(self): - return self._endpoint_url == other._endpoint_url and self._path == other._path - return NotImplemented - - def __hash__(self): - return hash((self._endpoint_url, self._path)) - - def __repr__(self): - return f'TentrisOntology(path={repr(self._path)},endpoint_url={repr(self._endpoint_url)})' - - -class TentrisReasoner(OWLReasonerEx): - __slots__ = '_ontology', '_backing_reasoner' - - def __init__(self, ontology: TentrisOntology): - self._ontology = ontology - self._backing_reasoner = OntologyReasoner(self._ontology._backing_onto) - - def data_property_domains(self, pe: OWLDataProperty, direct: bool = False) -> Iterable[OWLClass]: - raise NotImplementedError - - def object_property_domains(self, pe: OWLObjectProperty, direct: bool = False) -> Iterable[OWLClass]: - logger.debug("Calling object_property_domains(%s) from backing reasoner", _debug_render(pe)) - yield from self._backing_reasoner.object_property_domains(pe, direct=direct) - - def object_property_ranges(self, pe: OWLObjectProperty, direct: bool = False) -> Iterable[OWLClass]: - logger.debug("Calling object_property_ranges(%s) from backing reasoner", _debug_render(pe)) - yield from self._backing_reasoner.object_property_ranges(pe, direct=direct) - - def equivalent_classes(self, ce: OWLClassExpression, only_named: bool = True) -> Iterable[OWLClassExpression]: - raise NotImplementedError - - def data_property_values(self, ind: OWLNamedIndividual, pe: OWLDataProperty) -> Iterable[OWLLiteral]: - raise NotImplementedError - - def object_property_values(self, ind: OWLNamedIndividual, pe: OWLObjectPropertyExpression) \ - -> Iterable[OWLNamedIndividual]: - raise NotImplementedError - - def flush(self) -> None: - raise NotImplementedError - - def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]: - logger.warning("Instances(%s) method used", _debug_render(ce)) - res = httpx.get(self._ontology._endpoint_url + '/instances', - params={'class_expression': _tentris_render(ce)}, - timeout=self._ontology._endpoint_timeout) - for i in res.json()['instances']: - yield OWLNamedIndividual(IRI.create(i)) - - def sub_classes(self, ce: OWLClassExpression, direct: bool = False, only_named: bool = True) \ - -> Iterable[OWLClassExpression]: - logger.debug("Calling sub_classes(%s) from backing reasoner", _debug_render(ce)) - yield from self._backing_reasoner.sub_classes(ce, direct=direct, only_named=only_named) - - def sub_data_properties(self, dp: OWLDataProperty, direct: bool = False) -> Iterable[OWLDataProperty]: - logger.debug("Calling sub_data_properties(%s) from backing reasoner", _debug_render(dp)) - yield from self._backing_reasoner.sub_data_properties(dp, direct=direct) - - def sub_object_properties(self, op: OWLObjectPropertyExpression, direct: bool = False) \ - -> Iterable[OWLObjectPropertyExpression]: - logger.debug("Calling sub_object_properties(%s) from backing reasoner", _debug_render(op)) - yield from self._backing_reasoner.sub_object_properties(op, direct=direct) - - def types(self, ind: OWLNamedIndividual, direct: bool = False) -> Iterable[OWLClass]: - raise NotImplementedError - - def get_root_ontology(self) -> TentrisOntology: - return self._ontology - - def super_classes(self, ce: OWLClassExpression, direct: bool = False, only_named: bool = True) \ - -> Iterable[OWLClassExpression]: - raise NotImplementedError - - -class EvaluatedConceptTentris(EvaluatedConcept): - __slots__ = () - - @property - def inds(self): - if logger.isEnabledFor(oplogging.TRACE): - logger.debug("No individuals") - return None - - -class TentrisKnowledgeBase(KnowledgeBase): - __slots__ = 'endpoint_url', 'endpoint_timeout', 'async_client', 'tasks', '_total_req', '_current_req' - - _ontology: TentrisOntology - endpoint_url: str - endpoint_timeout: float - - def __init__(self, path: str, *, - length_metric_factory: Optional[Factory[[], OWLClassExpressionLengthMetric]] = None, - length_metric: Optional[OWLClassExpressionLengthMetric] = None, - individuals_cache_size=128, - ): - AbstractKnowledgeBase.__init__(self) - self.path = path - self.endpoint_url = 'http://localhost:8131' - self.endpoint_timeout = 15.0 - self.tasks = 8 - self.async_client = httpx.AsyncClient(timeout=httpx.Timeout(self.endpoint_timeout, - pool=self.endpoint_timeout * (1 + self.tasks)), - limits=httpx.Limits(max_connections=self.tasks, - max_keepalive_connections=self.tasks)) - self._total_req = 0 - self._current_req = 0 - - self._ontology = TentrisOntology(self.path, self.endpoint_url, timeout=50.0) - self._reasoner = TentrisReasoner(self._ontology) - - if length_metric is not None: - self._length_metric = length_metric - elif length_metric_factory is not None: - self._length_metric = length_metric_factory() - else: - self._length_metric = _Default_ClassExpressionLengthMetricFactory() - - individuals = self._ontology.individuals_in_signature() - self._ind_set = frozenset(individuals) - - self.use_individuals_cache = individuals_cache_size > 0 - if self.use_individuals_cache: - self._ind_cache = LRUCache(maxsize=individuals_cache_size) - - logger.info(f'Tentris Knowledge Base created. Endpoint: {self.endpoint_url}') - - @singledispatchmethod - def encode_learning_problem(self, lp: AbstractLearningProblem): - raise NotImplementedError(lp) - - @encode_learning_problem.register - def _(self, lp: PosNegLPStandard): - id_ = httpx.post(self.endpoint_url + '/learning_problem', json={ - 'positives': list(map(lambda _: _.to_string_id(), sorted(lp.pos))), - 'negatives': list(map(lambda _: _.to_string_id(), sorted(lp.neg))), - }).text - logger.debug("LP id: %s", id_) - return EncodedPosNegLPStandardTentris(id_) - - def evaluate_concept(self, concept: OWLClassExpression, quality_func: AbstractScorer, - encoded_learning_problem: EncodedPosNegLPStandardTentris) -> EvaluatedConcept: - e = EvaluatedConceptTentris() - ce = _tentris_render(concept.get_nnf()) - metric = _Metric_map.get(type(quality_func)) - # workaround tentris bug - if metric == 'f1_score': - metric_kv = dict() - else: - metric_kv = {'metric': metric} - try: - res = httpx.get(self.endpoint_url + '/class_expression_quality', - params={ - **metric_kv, - 'class_expression': ce, - 'learning_problem_id': str(encoded_learning_problem.id) - }, - timeout=self.endpoint_timeout) - except httpx.ReadTimeout: - logger.error("Could not resolve << %s >> using Tentris@%s", ce, encoded_learning_problem.id) - e.q = 0 - return e - e.q = float(res.text) - return e - - async def evaluate_concept_async(self, concept: OWLClassExpression, quality_func: AbstractScorer, - encoded_learning_problem: EncodedPosNegLPStandardTentris) -> EvaluatedConcept: - e = EvaluatedConceptTentris() - ce = _tentris_render(concept.get_nnf()) - metric = _Metric_map.get(type(quality_func)) - # workaround tentris bug - id_ = self._total_req + 1 - if metric == 'f1_score': - metric_kv = dict() - else: - metric_kv = {'metric': metric} - try: - # async with httpx.AsyncClient() as client: - self._total_req += 1 - self._current_req += 1 - logger.debug(f"START:{id_} -- total:{self._total_req} current:{self._current_req} -- {ce}") - res = await self.async_client.get( - self.endpoint_url + '/class_expression_quality', - params={ - **metric_kv, - 'class_expression': ce, - 'learning_problem_id': str(encoded_learning_problem.id) - }) - logger.debug(f"E N D:{id_} -- total:{self._total_req} current:{self._current_req} -- ") - self._current_req -= 1 - except httpx.ReadTimeout: - logger.error("Could not resolve << %s >> using Tentris@%s", ce, encoded_learning_problem.id) - e.q = 0 - return e - e.q = float(res.text) - # await res.aclose() - # logger.debug(f"CLOSE:{id_}") - return e