Ctrl+K

SUP (White Horse)

SUP (White Horse)#

A white horse (DE: Schimmel) is the intersection of a White Color and a Horse.

Knoten im Focus: SUP mit der id ID_999.

Ausgangspunkt ist eine freemind oder freeplane-Mindmap, die so aussieht:

Wir erzeugen diese Mindmap programmatisch, mit kurzen IDs.

In dem vorliegenden Beispiel interessiert uns vor allem der Knoten SUP mit der id ID_003.

xml_white_horse_sup = """<map version="freeplane 1.7.0">
<!--To view this file, download free mind mapping software Freeplane from http://freeplane.sourceforge.net -->
<node TEXT="white-horse-SUP" ID="ID_0" STYLE="oval" FOLDED="false">
  <node TEXT="TAXONOMY white_horse" ID="ID_001">
    <node TEXT="White Horse" ID="ID_002">
      <font BOLD="true"/>
      <node TEXT="SUP" ID="ID_999">
        <node TEXT="White Color" ID="ID_004">
           <font BOLD="true"/>
        </node>
        <node TEXT="Horse" ID="ID_005">
           <font BOLD="true"/>
        </node>
      </node>
    </node>
  </node>
</node>
</map>
"""

with open("white-horse-SUP.mm", "w") as white_horse_sup:
    white_horse_sup.write(xml_white_horse_sup)

from gd07 import GenDifS

Mindmap einlesen:

m = GenDifS("white-horse-SUP.mm", verb=1)

Sichtbar machen, was wir eingelesen haben:

m.describe_mindmap()

self.mindmap_topnode.get('TEXT')='white-horse-SUP'
len(self.mindmap_xml.getroot().xpath('.//node'))=6 nodes

Übersetzen der Mindmap in verschiedene Sprachen:

m.compile(language_list_list=['RDFStest', 'OWLtest', 'OWL', 'RDFS']) # alles außer SKOS

Welche Taxonomien haben wir unserer Mindmap?

m.taxonomies_by_name.keys()

dict_keys(['white_horse'])

Taxonomy white_horse#

Wir haben in unserer Mindmap nur eine einzige Taxonomie, hier mit dem Namen white_horse. Wir weisen diese der gleichnamigen Variablen zu.

white_horse = m.taxonomies_by_name["white_horse"]

Uns interessiert der Knoten ID_999

ID_999 = white_horse.dict_of_all_gdn['ID_999']
type(ID_999)

gd07.gdn_differentia

Ein Knoten vom Typ gd07.gdn_differentia hat ein Dictionary molecule_dict, das für jede Sprache den erzeugten ttl-Code als String enthält:

for k,v in ID_999.molecule_dict.items():
    print(f"-- {k} --\n{v}\n")

-- RDFS --
# ID_999 RDFS
:White_Horse a owl:Class .
:White_Color a owl:Class.
   :White_Horse rdfs:subClassOf :White_Color .
:Horse a owl:Class.
   :White_Horse rdfs:subClassOf :Horse .

-- OWL --
# ID_999 OWL
:SUP_ID_999 a owl:class ;
   rdfs:subClassOf :White_Horse ;
   owl:intersectionOf (:White_Color :Horse ) .

-- OWLtest --
# ID_999 OWLtest
ex:White_Horse_ID_999 a :White_Color .
ex:White_Horse_ID_999 a :Horse .
ex:White_Horse_ID_999_2 a :White_Horse .
ex:White_Horse_ID_999 gendifs:classify_similar ex:White_Horse_ID_999_2 .

Diese Code-Snippets werden erzeugt in der Klasse ID_999.molecule_per_language:

type(ID_999.molecule_per_language)

gd07.GenDifS_molecule_per_language

Die Klasse molecule_per_language enthält alle Detailinformationen aus der Code-Generierung.

entity_context repräsentiert alle Informationen, die zur Codegenerierung verwendet wurden:

ID_999.molecule_per_language.entity_context

{'id': 'ID_999',
 'codeclass': 'SUP',
 'species': Entity(@id='ID_002', @text='White_Horse'),
 'genus_list': [Entity(@id='ID_004', @text='White_Color'),
  Entity(@id='ID_005', @text='Horse')]}

Die Klasse inspect_inferencing gibt Zugriff auf die Ergebnisse des Selbsttests, insbesondere test_results:

ID_999.molecule_per_language.inspect_inferencing.test_results

{(b'urn:ex#White_Horse_ID_999',
  b'urn:ex#White_Horse_ID_999_2'): {'cat1 not empty': True, 'cat2 not empty': True, 'disjoint before': True, 'subset after': True, 'ok': True}}

In dieser Klasse sind 2 Graphen enthalten:

  • g1: Der aus der Node ID_999 lokale Graph vor dem Inferencing

  • g2: Dieser Graph nach dem Inferencing, also nach der vollständigen Ausmaterialisierung durch owlrl.

print(g1_ttl) oder print(g2_ttl) würde sehr viel uninteressanten Code zeigen:

# print(g1_ttl)

# print(g2_ttl)

Praktischerweise gruppiert die Serialisierungsfnktion von rdflib die Tripel zu sinnvollen Records (Molekülen, im ttl-Text: Absätzen). Wir definieren uns eine kleine Hilfsfunktion focus().

def focus(focus_curie_list, ttl):
    return "\n\n".join( [ paragraph for paragraph in ttl.split("\n\n") \
                         if any( [ focus_curie in paragraph for focus_curie in focus_curie_list ] ) ] )

Vor dem Inferencing: Alle Absätze aus g1, in denen der String ID_999 vorkommt:

g1_ttl =  ID_999.molecule_per_language.inspect_inferencing.g1.serialize()
print( focus( ["ID_999"], g1_ttl) )

:SUP_ID_999 a owl:class ;
    rdfs:subClassOf :White_Horse ;
    owl:intersectionOf ( :White_Color :Horse ) .

ex:White_Horse_ID_999 a :Horse,
        :White_Color ;
    gendifs:classify_similar ex:White_Horse_ID_999_2 .

ex:White_Horse_ID_999_2 a :White_Horse .

Nach dem Inferencing: Alle Absätze aus g2, in denen der String ID_999 vorkommt:

g2_ttl = ID_999.molecule_per_language.inspect_inferencing.g2.serialize()
print( focus( ["ID_999"], g2_ttl) )

ex:White_Horse_ID_999 a :Horse,
        :SUP_ID_999,
        :White_Color,
        :White_Horse ;
    owl:sameAs ex:White_Horse_ID_999 ;
    gendifs:classify_similar ex:White_Horse_ID_999_2 .

:SUP_ID_999 a owl:class ;
    rdfs:subClassOf :Horse,
        :White_Color,
        :White_Horse ;
    owl:intersectionOf _:n2208183cba6844a0820b09620b2cf1dbb1 ;
    owl:sameAs :SUP_ID_999 .

ex:White_Horse_ID_999_2 a :White_Horse ;
    owl:sameAs ex:White_Horse_ID_999_2 .

Wir sehen, dass ex:White_Horse_ID_999 nach dem Inferencing nun eine Instanz (u.A. auch von ex:SUP_ID_999 und deshalb) auch von White_Horse ist.

QED

Contents