示例#1
0
    def loadOntology(self, reasoner=Reasoner.NONE, memory_java="10240"):

        # self.world = World()

        # Method from owlready
        self.onto = get_ontology(self.urionto).load()
        # self.onto = self.world.get_ontology(self.urionto).load()
        # self.onto.load()

        # self.classifiedOnto = get_ontology(self.urionto + '_classified')
        owlready2.reasoning.JAVA_MEMORY = memory_java
        owlready2.set_log_level(9)

        if reasoner == Reasoner.PELLET:

            try:
                with self.onto:  # it does add inferences to ontology

                    # Is this wrt data assertions? Check if necessary
                    # infer_property_values = True, infer_data_property_values = True
                    logging.info("Classifying ontology with Pellet...")
                    sync_reasoner_pellet(
                    )  # it does add inferences to ontology

                    unsat = len(list(self.onto.inconsistent_classes()))
                    logging.info("Ontology successfully classified.")
                    if unsat > 0:
                        logging.warning(
                            f"There are {str(unsat)} unsatisfiable classes: {list(self.onto.inconsistent_classes())}"
                        )
            except Exception:
                logging.info("Classifying with Pellet failed.")

        elif reasoner == Reasoner.HERMIT:

            try:
                with self.onto:  # it does add inferences to ontology

                    logging.info("Classifying ontology with HermiT...")
                    sync_reasoner()  # HermiT doe snot work very well....

                    unsat = len(list(self.onto.inconsistent_classes()))
                    logging.info("Ontology successfully classified.")
                    if unsat > 0:
                        logging.warning(
                            f"There are {str(unsat)} unsatisfiable classes: {list(self.onto.inconsistent_classes())}"
                        )
                    return f"{str(unsat)} unsatisfiable classes: {list(self.onto.inconsistent_classes())}"

            except Exception:
                logging.info("Classifying with HermiT failed.")

        # End Classification

        # report problem with unsat (Nothing not declared....)
        # print(list(self.onto.inconsistent_classes()))

        self.graph = default_world.as_rdflib_graph()
        logging.info("There are {} triples in the ontology".format(
            len(self.graph)))
示例#2
0
 def run(*args):
     if reasoner == 'Pellet':
         owlready2.sync_reasoner_pellet(*args)
     elif reasoner == 'HermiT':
         owlready2.sync_reasoner(*args)
     else:
         raise ValueError('unknown reasoner %r.  Supported reasoners'
                              'are "Pellet" and "HermiT".', reasoner)
示例#3
0
def init_onto(onto_path):
    """Helper: read ontology file & run default reasoner.
    """
    onto_path = 'file://' + onto_path
    onto = owl.get_ontology(onto_path).load()
    print('Loaded owl file at:', onto_path)
    owl.sync_reasoner()
    return onto
示例#4
0
 def consistency(self, condition: bool = False):
     try:
         with self.onto:
             if condition:
                 sync_reasoner(self.my_world)
                 classi_incosistenti = list(self.my_world.inconsistent_classes())
                 if not len(classi_incosistenti) == 0:
                     return classi_incosistenti
             else:
                 sync_reasoner(self.big_world)
             return "The ontology is consistent"
     except OwlReadyInconsistentOntologyError:
         return "The ontology is inconsistent"
def rereason(G, filename):
    world = owlready2.World()
    with open(filename, 'wb') as f:
        f.write(G.serialize(format='ntriples'))
    on = world.get_ontology(f"file://./{filename}").load()
    owlready2.sync_reasoner(world, infer_property_values=True)
    G = world.as_rdflib_graph()
    G.bind('rdf', RDF)
    G.bind('owl', OWL)
    G.bind('rdfs', RDFS)
    G.bind('skos', SKOS)
    G.bind('brick', BRICK)
    G.bind('tag', TAG)
    G.bind('bldg', BLDG)
    return G
示例#6
0
def main(path: str = '',
         output: str = None,
         stub: Arg(action='store_true') = False,
         infer: Arg(action='store_true') = False):
    if stub:
        path = '--stub'
    elif not path:
        log(Log.ERROR, f'Missing filename')
        exit(1)

    onto = load_ontology(path)
    show_classes(onto)
    show_obj_properties(onto)
    show_which_implements(onto, NOCLASS)

    if infer:
        with onto:
            owl.sync_reasoner()

    show_inconsistencies(onto)
    show_classes(onto)
    if output:
        onto.save(file=output, format='owlxml')
def populate_ontology(legal_ontology, data_instances):
    # imported ontologies
    ontologies = list(legal_ontology.imported_ontologies)
    judo = list(ontologies[0].imported_ontologies)[0]
    lkif_role = ontologies[1]
    lkif_action = lkif_role.get_namespace(
        'http://www.estrellaproject.org/lkif-core/action.owl#')
    lkif_legal_action = lkif_role.get_namespace(
        'http://www.estrellaproject.org/lkif-core/legal-action.owl#')
    lkif_top = lkif_role.get_namespace(
        'http://www.estrellaproject.org/lkif-core/lkif-top.owl#')
    lkif_legal_role = lkif_role.get_namespace(
        'http://www.estrellaproject.org/lkif-core/legal-role.owl#')
    lkif_process = lkif_role.get_namespace(
        'http://www.estrellaproject.org/lkif-core/process.owl#')

    for instance in data_instances:
        # Jurisdiction individual
        court = instance.jurisdiction_court.replace(' ', '_')
        jurisdiction = judo.Jurisdiction(court, namespace=legal_ontology)

        # Judgement individual
        judgement = instance.case_id.replace(' ', '_')
        judgement = judo.Judgement(judgement, namespace=legal_ontology)
        judgement.judgement_name.append(instance.case_name)
        judgement.jurisdiction_city.append(instance.jurisdiction_court_city)
        judgement.judgement_date.append(instance.judgement_date)
        judgement.hearing_date.append(instance.hearing_date)
        # spajanje suda i presude preko considered_by ObjectProperty-a
        judgement.considered_by.append(jurisdiction)

        # Registry individual
        registry_name = instance.judgement_registry.replace(' ', '_')
        registry = lkif_process.Physical_Object(registry_name,
                                                namespace=legal_ontology)
        registry.stores.append(
            judgement)  # dodavanje dokumenta u odgovarajuci registry

        # svi ucesnici presude modelovani su kao Legal_Person, jer ne moraju biti iskljucivo jedna osoba, vec mogu biti i kompanije, organizacije, itd.

        # Judge individual (Legal_Person that %plays% "judge" Legal_Role)
        # takodje je ucesnik odgovarajuce presude, tj. .participant(...presuda...)
        judge_name = instance.judge.replace(' ', '_')
        judge = lkif_legal_action.Legal_Person(judge_name,
                                               namespace=legal_ontology)
        judge_role = lkif_legal_role.Legal_Role('judge',
                                                namespace=legal_ontology)
        judge.plays.append(judge_role)
        judge.participant.append(judgement)

        # Side 1 (Appellant/Applicant) Counsel individual
        for counsel in instance.side1_counsels:
            a_counsel_name = counsel.replace(' ', '_')
            side1_counsel = lkif_legal_action.Legal_Person(
                a_counsel_name, namespace=legal_ontology)
            side1_counsel_role = lkif_legal_role.Legal_Role(
                instance.side1_role + '_counsel', namespace=legal_ontology)
            side1_counsel.plays.append(side1_counsel_role)
            side1_counsel.participant.append(judgement)

        # Side 1 Solicitor individual
        for solicitor in instance.side1_solicitors:
            a_solicitor_name = solicitor.replace(' ', '_')
            side1_solicitor = lkif_legal_action.Legal_Person(
                a_solicitor_name, namespace=legal_ontology)
            side1_solicitor_role = lkif_legal_role.Legal_Role(
                instance.side1_role + '_solicitor', namespace=legal_ontology)
            side1_solicitor.plays.append(side1_solicitor_role)
            side1_solicitor.participant.append(judgement)

        # Side 2 Counsel individual
        for counsel in instance.side2_counsels:
            r_counsel_name = counsel.replace(' ', '_')
            side2_counsel = lkif_legal_action.Legal_Person(
                r_counsel_name, namespace=legal_ontology)
            side2_counsel_role = lkif_legal_role.Legal_Role(
                instance.side2_role + '_counsel', namespace=legal_ontology)
            side2_counsel.plays.append(side2_counsel_role)
            side2_counsel.participant.append(judgement)

        # Side 2 Solicitor individual
        for solicitor in instance.side2_solicitors:
            r_solicitor_name = solicitor.replace(' ', '_')
            side2_solicitor = lkif_legal_action.Legal_Person(
                r_solicitor_name, namespace=legal_ontology)
            side2_solicitor_role = lkif_legal_role.Legal_Role(
                instance.side2_role + '_solicitor', namespace=legal_ontology)
            side2_solicitor.plays.append(side2_solicitor_role)
            side2_solicitor.participant.append(judgement)

        # Side 1 individual (left of V in judgement full name)
        for side1_name in instance.side1:
            side1_name = side1_name.replace(' ', '_')
            side1 = lkif_legal_action.Legal_Person(side1_name,
                                                   namespace=legal_ontology)
            side1_role = lkif_legal_role.Legal_Role(instance.side1_role,
                                                    namespace=legal_ontology)
            side1.plays.append(side1_role)
            side1.participant.append(judgement)

        # Side 2 individuals (right of V in judgement full name)
        # There could be more than 1 respondents!
        for side2_name in instance.side2:
            side2_name = side2_name.replace(' ', '_')
            side2 = lkif_legal_action.Legal_Person(side2_name,
                                                   namespace=legal_ontology)
            side2_role = lkif_legal_role.Legal_Role(
                instance.side2_role, namespace=legal_ontology
            )  # proveriti da li postoji vise razlicitih uloga!
            side2.plays.append(side2_role)
            side2.participant.append(judgement)

        # Legal rule individuals
        for rule in instance.legal_rules:
            rule = rule.replace(' ', '_')
            legal_rule = judo.Legal_Rule(rule, namespace=legal_ontology)
            judgement.considers.append(legal_rule)

        # Referencirane presude
        for ref_case, ref_name in zip(instance.referenced_cases,
                                      instance.ref_names):
            # pravljenje individuala presude koja se referencira (VIDI STA SE DESAVA AKO TAKAV INDIVIDUAL VEC POSTOJI)
            ref_case = ref_case.replace(' ', '_')
            ref_judgement = judo.Judgement(ref_case, namespace=legal_ontology)
            ref_judgement.judgement_name.append(ref_name)
            # aktuelna presuda -> considers -> referencirana presuda
            judgement.considers.append(ref_judgement)

    # HermiT reasoner -> ako bude pucalo, skines HermiT sa zvanicnog sajta, raspakujes i zamenis to sa onim sto ti je instalirano preko owlready2
    # znaci bice negde ili AppData/Python/... ili u okruzenju koje koristis u anakondi
    # pretrazi onim fensi search everything pa vidi gde je
    with legal_ontology:
        sync_reasoner(infer_property_values=True)

    save_ontology(legal_ontology)
    def GetOntology(cls, iri, doReasoner=False, cachePath=None):
        iri_hash = cls.IRI_HASH.get(iri)

        if iri_hash is None:
            cls.IRI_HASH[iri] = iri_hash = hashlib.sha1(
                iri.encode('utf-8')).hexdigest()

        onto = cls.ONTO_CACHE.get(iri_hash)
        if onto is None:
            worldDB = cls.TermWorlds.get(iri_hash)

            if worldDB is None:
                worldDBPath = cls.GetWorldDBPath(iri_hash, cachePath)

                # Activate this only if you want to save a copy of the ontologies
                #ontologiesPath = os.path.join(cachePath,'ontologies')
                #os.makedirs(ontologiesPath,exist_ok=True)
                #owlready2.onto_path.append(ontologiesPath)
                worldDB = owlready2.World(filename=worldDBPath,
                                          exclusive=False)
                cls.TermWorlds[iri_hash] = worldDB

            # Trying to get the metadata useful for an optimal ontology download
            metadataPath = cls.GetMetadataPath(iri_hash, cachePath)
            if os.path.exists(metadataPath):
                try:
                    with open(metadataPath, mode='r',
                              encoding='utf-8') as metadata_fh:
                        metadata = json.load(metadata_fh)
                except:
                    # A corrupted cache should not disturb
                    metadata = {}
            else:
                metadata = {}

            ontologyPath = cls.GetOntologyPath(iri_hash, cachePath)
            gotPath, gotMetadata = download_file(iri, ontologyPath, metadata)
            if gotPath:
                gotMetadata['orig_url'] = iri
                # Reading the ontology
                with open(ontologyPath, mode="rb") as onto_fh:
                    onto = worldDB.get_ontology(iri).load(fileobj=onto_fh,
                                                          reload=True)

                # Save the metadata
                with open(metadataPath, mode="w",
                          encoding="utf-8") as metadata_fh:
                    json.dump(gotMetadata, metadata_fh)

                # Re-save once the reasoner has run
                if doReasoner:
                    worldDB.save()
                    owlready2.sync_reasoner(onto)
            else:
                onto = worldDB.get_ontology(iri).load()
            worldDB.save()

            # And now unlink the ontology (if exists)
            if os.path.exists(ontologyPath):
                os.unlink(ontologyPath)

            cls.ONTO_CACHE[iri_hash] = onto

        return onto
示例#9
0
from owlready2 import get_ontology, onto_path, sync_reasoner

#onto = get_ontology("http://www.lesfleursdunormal.fr/static/_downloads/pizza_onto.owl")
onto = get_ontology('pizza_onto.owl')
onto.load()


class NonVegetarianPizza(onto.Pizza):
    equivalent_to = [
        onto.Pizza & (onto.has_topping.some(onto.MeatTopping)
                      | onto.has_topping.some(onto.FishTopping))
    ]


if __name__ == "__main__":
    my_pizza = onto.Pizza('my_pizza')
    my_pizza.has_topping = [
        onto.CheeseTopping(),
        onto.TomatoTopping(),
        onto.MeatTopping()
    ]

    print('Before reasoning: %s' % my_pizza.__class__)
    sync_reasoner(debug=0)
    print('After reasoning: %s' % my_pizza.__class__)
示例#10
0
    def relation_between_word_aspect(self, word_class, category, aspect_class, aspect_dependency, word_sentiment):

        if aspect_dependency != 'no':
            aspect_relation = [1, 0]
            aspect_sentiment = word_sentiment
        else:
            aspect_relation = [0, 1]
            aspect_sentiment = [0, 0, 1]

        if word_class is None:
            # aspect_relation, UnknownPolarity
            return aspect_relation, [0, 0, 1], aspect_sentiment, word_sentiment

        positive_class = self.ontology.search(iri='*Positive')[0]
        negative_class = self.ontology.search(iri='*Negative')[0]

        sub_classes = word_class.ancestors()

        if self.ontology.PropertyMention in sub_classes:

            if self.ontology.GenericNegativePropertyMention in sub_classes:
                # True, Negative
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 1, 0], [0, 1, 0], [0, 1, 0]
                else:
                    return aspect_relation, [0, 1, 0], [0, 0, 1], [0, 1, 0]
            elif self.ontology.GenericPositivePropertyMention in sub_classes:
                # True, Positive
                if aspect_dependency != 'no':
                    return aspect_relation, [1, 0, 0], [1, 0, 0], [1, 0, 0]
                else:
                    return aspect_relation, [1, 0, 0], [0, 0, 1], [1, 0, 0]
            elif self.ontology.Positive in sub_classes:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True, Positive
                        return [1, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]
                # aspect_relation, UnknownPolarity
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 0, 1], [1, 0, 0], [1, 0, 0]
                else:
                    return aspect_relation, [0, 0, 1], [0, 0, 1], [1, 0, 0]
            elif self.ontology.Negative in sub_classes:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True, Negative
                        return [1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0]
                # aspect_relation, UnknownPolarity
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 0, 1], [0, 1, 0], [0, 1, 0]
                else:
                    return aspect_relation, [0, 0, 1], [0, 0, 1], [0, 1, 0]
            else:
                if aspect_class is not None:
                    word_class = owl.types.new_class(word_class.__name__ + aspect_class.__name__,
                                                     (word_class, aspect_class))
                owl.sync_reasoner()
                positive = positive_class.__subclasscheck__(word_class)
                negative = negative_class.__subclasscheck__(word_class)

                if positive and not negative:
                    # True Positive
                    return [1, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]
                elif not positive and negative:
                    # True Negative
                    return [1, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0]
                elif positive and negative:
                    # True UnknownPolarity
                    return [1, 0], [0, 0, 1], word_sentiment, word_sentiment
                else:
                    # aspect_relation, UnknownPolarity
                    return aspect_relation, [0, 0, 1], aspect_sentiment, word_sentiment

        elif self.ontology.ActionMention in sub_classes:

            if self.ontology.GenericNegativeAction in sub_classes:
                # True, Negative
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 1, 0], [0, 1, 0], [0, 1, 0]
                else:
                    return aspect_relation, [0, 1, 0], [0, 0, 1], [0, 1, 0]
            elif self.ontology.GenericPositiveAction in sub_classes:
                # True, Positive
                if aspect_dependency != 'no':
                    return aspect_relation, [1, 0, 0], [1, 0, 0], [1, 0, 0]
                else:
                    return aspect_relation, [1, 0, 0], [0, 0, 1], [1, 0, 0]
            elif self.ontology.Positive in sub_classes:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True, Positive
                        return [1, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]
                # aspect_relation, UnknownPolarity
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 0, 1], [1, 0, 0], [1, 0, 0]
                else:
                    return aspect_relation, [0, 0, 1], [0, 0, 1], [1, 0, 0]
            elif self.ontology.Negative in sub_classes:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True Negative
                        return [1, 0], [0, 1, 0], [0, 1, 0],  [0, 1, 0]
                # aspect_relation, UnknownPolarity
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 0, 1], [0, 1, 0], [0, 1, 0]
                else:
                    return aspect_relation, [0, 0, 1], [0, 0, 1], [0, 1, 0]
            else:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True UnknownPolarity
                        return [1, 0], [0, 0, 1], word_sentiment, word_sentiment
                # aspect_relation, UnknownPolarity
                return aspect_relation, [0, 0, 1], aspect_sentiment, word_sentiment

        elif self.ontology.EntityMention in sub_classes:

            if self.ontology.Positive in sub_classes:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True Positive
                        return [1, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]
                # aspect_relation, UnknownPolarity
                if aspect_dependency != 'no':
                    return aspect_relation, [0, 0, 1], [1, 0, 0], [1, 0, 0]
                else:
                    return aspect_relation, [0, 0, 1], [0, 0, 1], [1, 0, 0]
            elif self.ontology.Negative in sub_classes:
                return [1, 0], [0, 1, 0], [0, 1, 0],  [0, 1, 0]
            else:
                for c in sub_classes:
                    if c == owl.Thing:
                        continue
                    if category in c.aspect:
                        # True UnknownPolarity
                        return [1, 0], [0, 0, 1], word_sentiment, word_sentiment
                # aspect_relation, UnknownPolarity
                return aspect_relation, [0, 0, 1], aspect_sentiment, word_sentiment
        else:
            # aspect_relation, UnknownPolarity
            return aspect_relation, [0, 0, 1], aspect_sentiment, word_sentiment
示例#11
0
from django.http import JsonResponse
from .ontology import Ontology as Ontology_class
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.views.generic.list import ListView
from django.views.generic.detail import DetailView
from django.shortcuts import render
from .models import Ontology, Jogo
from rest_framework.decorators import api_view
from rest_framework import serializers, viewsets
from owlready2 import sync_reasoner
sync_reasoner()


def index(request):
    tutorial = Ontology.objects.get(slug='PlayProfile')
    return render(request, "ontology_app/homepage.html",
                  {'tutorial': tutorial})


def get_all_instances(request, ont_name, by_class):
    ontology = Ontology.objects.get(slug=ont_name)
    ontology = Ontology_class(ontology.file.name)
    instances = ontology.get_instances_of(by_class)
    return JsonResponse(instances, safe=False)


def get_sub_class(request, ont_name, by_class):
    ontology = Ontology.objects.get(slug=ont_name)
    ontology = Ontology_class(ontology.file.name)
    sub_classes = ontology.get_sub_classes_of(by_class)
    return JsonResponse(sub_classes, safe=False)
示例#12
0
 def sync_reasoner(self):
     """Update current ontology by running the HermiT reasoner."""
     with self:
         owlready2.sync_reasoner()
示例#13
0
                                | pizza_onto.TomatoTopping
                                | pizza_onto.MeatTopping))

portlandia = pizza_onto.Pizza("portlandia")
portlandia.has_topping = [pizza_onto.TomatoTopping()]
portlandia.is_a.append(pizza_onto.has_topping.only(pizza_onto.TomatoTopping))

# close_world(pizza_onto.Pizza)

print("---- List Individuals -----")
for instance in pizza_onto.Pizza.instances():
    print(instance)

# try reasoning
with pizza_onto:
    owlready2.sync_reasoner(infer_property_values=True)

print("---- What about -----")
print("What about a margarita ? {}".format(margarita.is_a))
print("What about a napolitana ? {}".format(napolitana.is_a))
print("What about a portlandia ? {}".format(portlandia.is_a))

print("---- Individual Search -----")
print("Individuals of NonVegetarianPizza are {}".format(
    pizza_onto.search(type=pizza_onto.NonVegetarianPizza)))
print("Individuals of VegetarianPizza are {}".format(
    pizza_onto.search(type=pizza_onto.VegetarianPizza)))
print("Individuals of VeganPizza are {}".format(
    pizza_onto.search(type=pizza_onto.VeganPizza)))

print("---- What is it -----")
示例#14
0
 def __init__(self, data_dir_path):
     my_world = World()
     # path to the owl file is given here
     my_world.get_ontology("file://%s" % data_dir_path).load()
     sync_reasoner(my_world)  # reasoner is started and synchronized here
     self.graph = my_world.as_rdflib_graph()