The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate information available on the Web. Semantic Web will build on the well known Semantic Web language stack, part of which is the Web Ontology Language (OWL). Python is an interpreted, object-oriented, extensible programming language, which provides an excellent combination of clarity and versatility. The deep integration of both languages is one of the novel approaches for enabling free and interoperable data [1]. In this article we present a metaclass-based implementation of the deep integration ideas. The implementation is an early Python prototype supporting in-line class and properties declaration, instance creation and simple triple-based queries. The implementation is backed up by a well known OWL-DL reasoner Pellet [3]. The integration of the Python and OWL-DL through meta-class programming provides a unique approach, which can be implemented with any metaclass enabled scripting language.
The deep integration of scripting languages and Semantic Web has introduced
an idea of importing the ontologies directly into the programming context so
that its classes are usable alongside classes de ned normally. This can provide a
more natural mapping of OWL-DL than classic APIs, re ecting the set-theoretic
semantics of OWL-DL, while preserving the access to the classic Python objects.
Such integration also encourages separation of concerns among declarative and
procedural and encourages a new wave of programming, where problems can be
? Acknowledgments: The research reported in this paper has been partially nanced by
the EU within the project IST-2004-511385 K-WfGrid and Slovak national projects,
Research and development of a knowledge based system to support work ow
management in organizations with administrative processes, APVT-51-024604; Tools for
acquisition, organization and maintenance of knowledge in an environment of
heterogeneous information resources, SPVV 1025/04; E cient tools and mechanisms
for grid computing (2006-2008) VEGA 2/6103/6.
de ned by using description logics [
In this article we would like to introduce an early prototype, which
implements some of the ideas of the deep integration in Python language [
Intensional sets as introduced in [
Terminology-wise, a metaclass is simply "the class of a class". Any class whose instances are themselves classes, is a metaclass. A metaclass-based implementation of the intensional sets is based on the core metaclass Thing, whose constructor accepts two main attributes, i.e. default namespace and N3 description of the i-set. The instance of the metaclass is then a mapping of the OWL class to the intensional set. Following the above example class Person can be created with a Python construct: Person = Thing('Person', (), {defined_by: 'a owl:Class; rdfs:subClassOf :Mortal',\ namespace: 'http://samplens.org/test#'}) This creates a Python class representing the intensional set for Person and its namespace. In the background it also updates the knowledge base with the new assertion. The individual John can then be instantiated simply by calling J ohn = P erson(). This statement calls the default constructor of the class Person, which provides support for asserting new OWL individual into the knowledge base. A similar metaclass is used for the OWL property except that it can not be instantiated. The constructor is used here for di erent purpose, i.e. to create a relation between classes or individuals. The notion of importing the ontology into the Python's namespace is then a matter of decomposing the ontology into the groups of intensional sets, generating Python classes for these sets and creating the instances.
This kind of programming is also called metaclass programming and can provide a transparent way how to generate new OWL classes and properties. Since metaclasses act like regular classes it is possible to extend their functionality by inheriting from the base metaclass. It is also simple to hide the complex tasks needed for accessing the knowledge base, reasoner and processing the mappings between OWL-DL's concepts and their respective Python counterparts.
A sample session shows an in-line declaration of a class Person. This is implemented by calling a static method new of the metaclass Thing (the static method new is used to hide the complex call introduced in Sec. 2). An instance is created by calling the Person's constructor, which in fact creates an in-line declaration of the OWL individual (John). The print statements show the Python's view of the respective objects, i.e. Person as a class and John as an instance of the class Person. We also show a more complex de nition of the PersonWithSingleSon, which we will later use to demonstrate the reasoning about property assertions. >>> from Thing import Thing >>> Person = Thing.new('Person',' a owl:Class .') >>> John = Person() >>> print Person <class 'Thing.Person'> >>> print John <Thing.Person object at 0xb7d0b50c> >>> PersonWithSingleSon = Thing.new('PersonWithSingleSon', \ """ a owl:Class ; rdfs:subClassOf [ a owl:Restriction ; owl:cardinality "1"^^<http://www.w3.org/2001/XMLSchema#int> ; owl:onProperty :hasSon ] ; rdfs:subClassOf [ a owl:Restriction ; owl:cardinality "1"^^<http://www.w3.org/2001/XMLSchema#int> ; owl:onProperty :hasChild ] .""")
A similar way can be used for in-line declarations of OWL properties. Compared to a class declaration the returned Python class can not be instantiated (i.e. returns None). >>> from PropertyThing import Property >>> hasChild = Property.new('hasChild',' a owl:ObjectProperty .') >>> print hasChild <class 'PropertyThing.hasChild'> >>> hasSon = Property.new('hasSon', ' a owl:ObjectProperty ; rdfs:subPropertyOf :hasChild .')
Properties are naturally used to assign relationships between OWL classes or individuals, which can be as simple as calling: >>> Bob = PersonWithSingleSon() >>> hasChild(Bob, John)
Assuming we have declared several instances of the class Person we can nd them by iterating over the class list. It is also possible to ask any triple like queries (the query shown also demonstrates reasoning about the property assertions). >>> for individual in Person.findInstances(): ... print individual, individual.name <Thing.Man object at 0xb7d0b64c> Peter <Thing.Person object at 0xb7d0b50c> John <Thing.Person object at 0xb7d0b6ec> Jane >>> for who in hasSon.query(Bob): ... who.name 'John' >>> print hasSon.query(Bob, John) 1 4
Apart from the metaclass-based implementation of the i-sets, it is necessary to
support query answering, i.e. provide an interface to the OWL-DL reasoner.
There are several choices for the OWL-DL reasoners including Racer, Pellet and
Kaon2 [
One of the main drawbacks of the current implementation is the fact, that
it doesn't support open world semantics (OWA). Although the reasoner in the
current implementation can perform OWA reasoning and thus it is possible to
correctly answer queries, the Python's semantics are based on the boolean values.
One of the possibilities is to use epistemic operator as suggested in [
The other drawback of the approach is the performance of the reasoner, which is due to the nature of the JPype implementation (the conversions between virtual machines imposes rather large performance bottlenecks). This can be solved by extending the support for other Python to Java APIs and possible implementation of specialized client-server protocols. 5
To our best knowledge there is currently no Python implementation of the deep
integration ideas. There is a Ruby implementation done by Obie Fernandez,
however it is not known what is the current status of the project [
The most popular existing OWL APIs, that provide programmatic access
to the OWL structures are based on Java [
Among the existing Python libraries, which support RDF and OWL, the
most interesting in terms of partial integration are Sparta and Tramp, which
bind RDF graph nodes to Python objects and RDF arcs to attributes of such
objects [
We have described a metaclass-based prototype implementation of the deep
integration ideas. We have discussed the advantages and shortcomings of the current
implementation. We would like to note, that this a work in progress, which is
constantly changing and this is just a report of the current status. At the time
of writing authors are setting up an open source project, which will host the
implementation of the ideas presented. There are many other open questions,
that we haven't covered here including integration of query languages
(possibility to re-use ideas from native queries [