pax_global_header 0000666 0000000 0000000 00000000064 15042011661 0014506 g ustar 00root root 0000000 0000000 52 comment=8e1bdbb322c656fcb7f6745447d740eec40fc18e
OWL-RL-7.1.4/ 0000775 0000000 0000000 00000000000 15042011661 0012473 5 ustar 00root root 0000000 0000000 OWL-RL-7.1.4/.gitignore 0000664 0000000 0000000 00000000247 15042011661 0014466 0 ustar 00root root 0000000 0000000 # Jetbrains editors
.idea/
* Python
*.pyc
.pytest_cache/
# 2to3
*.bak
/venv/
docs/build/
build/
dist/
deb_dist/
sdist/
*.egg-info/
owlrl*.tar.gz
# Mac
.DS_Store
OWL-RL-7.1.4/CHANGELOG.rst 0000664 0000000 0000000 00000030726 15042011661 0014524 0 ustar 00root root 0000000 0000000 Changelog
---------
v.7.1.4 - July, 2025
~~~~~~~~~~~~~~~~~~~~~~~
Changes:
* dependencies updates to meet RDFLib 7.1.4
* Python 3.9+ only, to match RDFLib 7.1.4
* background dependencies updated and tested to work
v.7.1.3 - January, 2025
~~~~~~~~~~~~~~~~~~~~~~~
Changes:
* dependencies updates only to meet RDFLib 7.1.3
* ensured development dependencies allow for Python 3.8.1+
* updated README with contact info and installation instructions
v.7.1.2 - October, 2024
~~~~~~~~~~~~~~~~~~~~~~~
Changes:
* Python dependency changed to > 3.8 (not > 3.10) to be compatible with other RDFLib packaged
v.7.1.1 - October, 2024
~~~~~~~~~~~~~~~~~~~~~~~
Changes:
* works with rdflib >= 7.1.1
This version of OWL-RL has been released now to update the RDFLib dependency version only, to further reduce upstream dependencies. Additionally there are several major functional updates included:
* [Better handling of detecting identical literals for RDFS sameAs rules](https://github.com/RDFLib/OWL-RL/pull/68)
* [Allow OWL-RL Closures to be run on rdflib Dataset instances](https://github.com/RDFLib/OWL-RL/pull/69)
* [Add inferred triples to a separate named graph](https://github.com/RDFLib/OWL-RL/pull/70)
The main result of the changes above is to allow OWLRL to be run on a Graph within a Dataset and to store the inferred triples in a separate Graph which allows asserted and inferred data to be kept cleanly, side-by-side, and used together but managed independently.
This update is of particular importance to tools such as [pySHACL](https://github.com/RDFLib/pySHACL)...
6.0.2 - October, 2021
~~~~~~~~~~~~~~~~~~~~~~~
Changes:
* works with rdflib >= 6.2.0
* replaces owl namespace element lists with those of rdflib (OWL, RDF, RDFS, XSD)
v5.2.3
~~~~~~
Changes:
* fix README image display
* fix version acquisition in setup.py
v5.2.2
~~~~~~
Changes:
* Depend on RDFLib v5.0+
* Removed rdflib_jsonld as a requirement. It is included in rdflib 6.0
* Detect if rdflib 6.0 is in use, and do not import the jsonld module
v5.2.1
~~~~~~
Changes:
* Added stdeb.cfg file, and notes in requirements-dev.txt for building a debian package
* Removed the .py extension from the files in the scripts directory
* Same change as above but for the RDFConvertService script
* Fix Qualified Max Cardinality 0 Bug
* Fix output printing of owlrl commandline script
v5.2.0
~~~~~~
Changes:
* Dropped LiteralProxies finally. Processing of literals is no longer done through a LiteralProxy class (thanks :code:`@wrobell`)
* As a consequence:
* The change improves performance of the library by about 14%.
* Related blocks of code, which swallow exceptions are removed.
* Unit tests for the following OWL 2 RL rules are implemented
cax-dw,
cls-avf,
cls-maxc1,
cls-maxc2,
cls-maxqc1,
cls-maxqc2,
cls-maxqc3,
cls-maxqc4
* Unit tests for RDFS closure implemented
adding datatype axioms,
one time rules
* Unit tests for OWL 2 RL extras closure implemented
one time rules
v5.1.1
~~~~~~
Changes:
* Renamed script: :code:`closure.py` to :code:`owlrl.py`
* Fixed a deployment bug which caused the shebang to be rewritten incorrectly in the owlrl.py script.
v5.1.0
~~~~~~
Changes:
* Rename module from RDFClosure to owlrl
* Published on PyPI!
* Fixed bugs caused by python3 automatic conversion (like :code:`range` being a variabe, not a function)
* Added some basic tests (more tests coming!)
* Started foundational work to remove :code:`LiteralProxies` in the future (thanks :code:`@wrobell`)
* Simplified some sections of the code (thanks :code:`@wrobell`)
Version 5.0.0
~~~~~~~~~~~~~
Changes:
* Port to Python3. Minimum recommended version is now Python v3.5.
* Fixed a bug where the inferencing process would crash if the engine encountered a literal node that has a datatype for which it does not have a hardcoded converter.
Version 4/5
~~~~~~~~~~~
This is a major release: the package has been updated to Python 2.7 and RDFLib 4 (and to Python 3.5 in v5.0.0).
Some important changes:
* The local parser and serializer implementations have been removed; the package relies fully on RDFLib.
* If the extra JSON-LD parser and serializer is available, that format may also be used both for input and output.
* RDFa as a possible input format has been added.
* The datatype part has been reworked to adapt itself to the way RDFLib handles datatypes.
* The :code:`Literal` class has been adapted to the latest versions of RDFLib's :code:`Literal` (there is no :code:`cmp_value` any more, only value)
* Python 2.7 includes an implementation for rational numbers (under the name :code:`Fraction`), so the separate module became moot.
* The :code:`script` directory has been moved to the top level of the distribution.
* The RDF1.1 specific datatypes (:code:`LangString` and :code:`HTML`) have been added, although the :code:`HTML` is simply treated as a text (a reliance on the HTML5 Library may be too much for what this is worth…)
* The :code:`closure` script has now an extra flag (:code:`-m`) to use the "maximal" entailment, i.e., extended OWLRL+RDF with extra trimmings.
Version 4.2.1
~~~~~~~~~~~~~
Changes:
* Per error report of Michael Schneider: if a class name is a blank node, the XML serialization went wrong. In case of exception, the fall back is to use the pure xml rather than the pretty xml; that works. There was also a 'trimming' argument missing in case of a pure format conversion that led to an exception, that is handled, too.
Version 4.2
~~~~~~~~~~~
Changes:
* I exchanged rdflib Graph usage to rdflib ConjunctiveGraph. It avoids issues around deprecation and is also a possible entry point for named graphs.
* Added an extra check in the allValuesFrom handling for datatype restrictions. This does not affect pure OWLRL but is used by the extras that implement facets.
* The RestrictedDatatype class has now a 'Core' superclass; this can be used by other restricted datatypes that are not necessarily defined in OWL 2
Version 4.1
~~~~~~~~~~~
Changes:
* On advise from Dominique, the error message in the CGI script uses cgi.escape on the text input before displaying it.
* 'Trimming' has been added to the command line options
* Adaptation to rdflib 2.4.2 (or even 2.4.1?): the :code:`Literal._PythonToXSD` changed its structure from a dictionary to a list of tuples; :code:`DatatypeHandling.use_Alt_lexical_conversions()` had to change.
Version 4.0
~~~~~~~~~~~
Changes:
* The top level :code:`__init__` file has been reorganized, so that the package can be used as a module for applications in RDFLib. There is a top level class (:code:`DeductiveClosure`) that can be invoked from an RDFLib application and the old entry point (:code:`convert_graph`) relies on that.
* New class have been added to cover a combined RDFS + OWL 2 RL closure (Michael Schneider's idea).
* An extension mechanism has been built in from bottom up; user can define his/her own rules via an extension class that is given as a parameter to the core closure class.
* Using the extension mechanism a separate OWLRLExtras module has been added to implement, eg, self restriction, rational datatype.
* In the closure class the array of temporarily stored tuples has been exchanged against a set; in other words, checking whether the tuple is to be stored already is now done by the built-in set operation. It became much faster...
* The input argument has changed from 'source' to 'sources'; ie, several input files can be given to the service at the same time (eg, a separate URI for the data and the ontology, respectively).
* Added the implementation of owl:imports.
* Added an implemenatation for the datatype restrictions.
* Bugs:
* there was an optimization in the datatype handling of OWLRL that excluded subsumptions for 'implicit' literals, ie, literals that are given datatypes via the ^^ formalism (and not via sameAs and explicit datatype definitions). But this excluded proper inferences for existential restrictions...:-(
* handler for the :code:`xsd:normalizedString` datatype was missing.
Version 3.2
~~~~~~~~~~~
Note: this version passes the full batch of official OWL Full/RL tests uploaded by Michael Schneider to the OWL Working Group site. The difference, in this respect, between this version and version 3.1 is the handling of datatypes (which was only rudimentary in 3.1)
* Bugs:
* the rules on dt-diff/dt-eq were missing in the implementation. (My mistake: I did not realize that ( owl:sameAs "adfa") was a possible setups whereby those rules do come in even in practice, so I did not implement them thinking that the results would not appear in the final code anyway due to a literal appearing in a subject position. Clearly an error in judgement.)
* :code:`PlainLiteral` was in a wrong namespace in the OWLRL file:-(
* Added an explicit handling for virtually all data types, to check the lexical values. (This is, in fact, a RDFLib deficiency for most cases, except those that came in via OWL, like PlainLiteral...)
* Added a note referring to a Turtle parser bug...
Version 3.1
~~~~~~~~~~~
Note: this version passes the first, basic batch of official OWL Full/RL tests uploaded by Michael Schneider to the OWL Working Group site.
* Bugs:
* if the URI of a predicate did not correspond to a defined namespace, the extra namespace declaration did not appear in the pretty xml output. Typical situation: the user defines a namespace without trailing '#' or '/', but uses the prefix nevertheless; this ends up in a URI for, say, a predicate or a type that cannot be represented in XML. The proper approach is then to add a new prefix with 'http://' and use that in the output.
The original XML serialization of RDFLib does that; the PrettyXMLSerialization did not. The pretty XML serialization is based on the one of RDFLib, and has therefore inherited this bug.
* the axiomatic expression for (byte subclass short) was misspelled to (byte subclass byte)
* the axiomatic triples added automatically should say (Thing type :code:`owl:Class`) (and not :code:`rdfs:Class` as before). Also, (Nothing type :code:`owl:Class`) was missing there.
* :code:`rdf:text` changed to :code:`rdf:PlainLiteral` (in the axiomatic triples), as a result of the OWL WG on changing the name.
* missing subclass relationship for dateTimeStamp vs dateTime.
* there was an optimization that added Datatype triples only for those datatypes that appeared as part of a literal in the input graph. However, the rule set requires those triples to be added no matter what. At the moment, this is pending (there are discussions in the group on this).
* the set of triples declaring annotation properties were missing
* error message for asymmetric properties was bogus (has :code:`%p` instead of :code:`%s` in the text).
* there was a leftover error message via exceptions for :code:`owl:Nothing` check.
* rule :code:`scm-eqc2` was missing :-(
* New Features:
* added some support to booleans; essentially introducing a stronger check (according to XSD the :code:`"111"^xsd:boolean` is not a valid boolean values, though RDFLib accepts it as such...).
* triples with a bnode predicate were systematically filtered out when added to a graph. However, incoming ontologies may include statements like '[ owl:inverseOf P]', and processing those through the rule set requires to allow such triples during deduction. Lucklily RDFLib is relaxed on that. So such 'generalized' triples are now allowed during the forward chaining and are filtered out only once, right before serialization.
* some improvements on the datatype handling:
* adding type relationships to super(data)types. For example, if the original graph includes (:code:` rdf:type xsd:short`), then the triple (:code:` rdf:type xsd:integer`), etc, is also added. As an optimization the (:code:`xsd:short rdfs:subClassOf xsd:integer`) triples are not added, but the direct datatyping is done instead.
* adding disjointness information on datatypes on top of the hierarchy. This means that inconsistencies of the sort :code:` ex:prop 123 . ex:prop "1"^^xsd:boolean`. will be detected (integers and booleans must be disjoing per XSD; the explicit type relationships and the disjointness of some data types will trigger the necessary rules).
Note that, mainly the first rule, is really useful when generic nodes are used as datatypes, as opposed to explicit literals.
* added the possibility to set the input format explicitly, and changed the RDFConvert script accordingly (the service is not yet changed...).
* added the possibility to consume standard input.
OWL-RL-7.1.4/Doc_OLD/ 0000775 0000000 0000000 00000000000 15042011661 0013676 5 ustar 00root root 0000000 0000000 OWL-RL-7.1.4/Doc_OLD/RDFClosure-module.html 0000664 0000000 0000000 00000136522 15042011661 0020030 0 ustar 00root root 0000000 0000000
RDFClosure
This module is brute force implementation of the 'finite' version of
RDFS semantics
and of OWL 2 RL on the top of RDFLib (with some caveats, see
below). Some extensions to these are also implemented. Brute force means
that, in all cases, simple forward chaining rules are used to extend
(recursively) the incoming graph with all triples that the rule sets
permit (ie, the "deductive closure" of the graph is computed).
There is an extra options whether the axiomatic triples are added to the
graph (prior to the forward chaining step). These, typically set the
domain and range for properties or define some core classes. In the case
of RDFS, the implementation uses a 'finite' version of the axiomatic
triples only (as proposed, for example, by Herman ter Horst). This means
that it adds only those rdf:_i type predicates that do
appear in the original graph, thereby keeping this step finite. For OWL 2
RL, OWL 2 does not define axiomatic triples formally; but they can be
deduced from the OWL 2 RDF Based Semantics document and are listed in
Appendix 6 (though informally). Note, however, that this implementation
adds only those triples that refer to OWL terms that are meaningful for
the OWL 2 RL case.
Package Entry Points
The main entry point to the package is via the DeductiveClosure class. This class should be
initialized to control the parameters of the deductive closure; the
forward chaining is done via the expand method. The simplest way to use the package
from an RDFLib application is as follows:
graph = Graph() # creation of an RDFLib graph
...
... # normal RDFLib application, eg, parsing RDF data
...
DeductiveClosure(OWLRL_Semantics).expand(graph) # calculate an OWL 2 RL deductive closure of graph
# without axiomatic triples
The first argument of the DeductiveClosure
initialization can be replaced by other classes, providing different
types of deductive closure; other arguments are also possible. For
example:
will calculate the deductive closure including RDFS and some
extensions to OWL 2 RL, and with all possible axiomatic triples added
to the graph (this is about the maximum the package can do…)
The same instance of DeductiveClosure can be used for several graph
expansions. In other words, the expand function does not change any
state.
For convenience, a second entry point to the package is provided in
the form of a function called convert_graph, that expects a directory with various
options, including a file name. The function parses the file, creates
the expanded graph, and serializes the result into RDF/XML or Turtle.
This function is particularly useful as an entry point for a CGI call
(where the HTML form parameters are in a directory) and is easy to use
with a command line interface. The package distribution contains an
example for both.
There are major closure type (ie, semantic closure possibilities);
these can be controlled through the appropriate parameters of the DeductiveClosure class:
In all three cases there are other dimensions that can control the
exact closure being generated:
for convenience, the so called axiomatic triples (see, eg, the axiomatic triples in RDFS) are, by default,
not added to the graph closure to reduce the number of
generated triples. These can be controlled through a separate
initialization argument
similarly, the axiomatic triples for D-entailment are separated
Some Technical/implementation aspects
The core processing is done in the in the Core class,
which is subclassed by the RDFS and the OWL 2
RL classes (these two are then, on their turn, subclassed by the RDFS + OWL 2 RL Semantics) class). The core implements
the core functionality of cycling through the rules, whereas the rules
themselves are defined and implemented in the subclasses. There are
also methods that are executed only once either at the beginning or at
the end of the full processing cycle. Adding axiomatic triples is
handled separately, which allows a finer user control over these
features.
Literals must be handled separately. Indeed, the functionality
relies on 'extended' RDF graphs, that allows literals to be in a
subject position, too. Because RDFLib does not allow that, processing
begins by exchanging all literals in the graph for bnodes (identical
literals get the same associated bnode). Processing occurs on these
bnodes; at the end of the process all these bnodes are replaced by
their corresponding literals if possible (if the bnode occurs in a
subject position, that triple is removed from the resulting graph).
Details of this processing is handled in the separate Literals Proxies class.
The OWL specification includes references to datatypes that are not
in the core RDFS specification, consequently not directly implemented
by RDFLib. These are added in a separate module of the package.
Problems with Literals with datatypes
The current distribution of RDFLib is fairly poor in handling
datatypes, particularly in checking whether a lexical form of a
literal is "proper" as for its declared datatype. A typical
example is:
"-1234"^^xsd:nonNegativeInteger
which should not be accepted as valid literal. Because the
requirements of OWL 2 RL are much stricter in this respect, an
alternative set of datatype handling (essentially, conversions) had
to be implemented (see the XsdDatatypes module).
The DeductiveClosure class has an additional instance
variable whether the default RDFLib conversion routines should be
exchanged against the new ones. If this flag is set to True and
instance creation (this is the default), then the conversion routines
are set back to the originals once the expansion is complete, thereby
avoiding to influence older application that may not work properly
with the new set of conversion routines.
If the user wants to use these alternative lexical conversions
everywhere in the application, then the use_improved_datatypes_conversions method can be
invoked. That method changes the conversion routines and, from that
point on, all usage of DeductiveClosure instances will use the improved
conversion methods without resetting them. Ie, the code structure can
be something like:
which will result in a proper graph expansion except for the
datatype specific comparisons which will be incomplete.
Problems with Literals with datatypes
The current distribution of RDFLib is fairly poor in handling
datatypes, particularly in checking whether a lexical form of a
literal is "proper" as for its declared datatype. A typical
example is:
"-1234"^^xsd:nonNegativeInteger
which should not be accepted as valid literal. Because the
requirements of OWL 2 RL are much stricter in this respect, an
alternative set of datatype handling (essentially, conversions) had
to be implemented (see the XsdDatatypes module).
The DeductiveClosure class has an additional instance
variable whether the default RDFLib conversion routines should be
exchanged against the new ones. If this flag is set to True and
instance creation (this is the default), then the conversion routines
are set back to the originals once the expansion is complete, thereby
avoiding to influence older application that may not work properly
with the new set of conversion routines.
If the user wants to use these alternative lexical conversions
everywhere in the application, then the use_improved_datatypes_conversions method can be
invoked. That method changes the conversion routines and, from that
point on, all usage of DeductiveClosure instances will use the improved
conversion methods without resetting them. Ie, the code structure can
be something like:
RDFClosure.RDFSClosure: This module is brute force implementation of the RDFS semantics on
the top of RDFLib (with some caveats, see in the introductory
text).
return_closure_class(owl_closure,
rdfs_closure,
owl_extras,
trimming=False)
Return the right semantic extension class based on three possible
choices (this method is here to help potential users, the result can
be fed into a DeductiveClosure instance at initialization)
convert_graph(options,
closureClass=None)
Entry point for external scripts (CGI or command line) to parse an
RDF file(s), possibly execute OWL and/or RDFS closures, and serialize
back the result in some format.
Parse the input into the graph, possibly checking the suffix for the
format.
Parameters:
iformat - input format; can be one of AUTO, TURTLE, or RDFXML. AUTO means
that the suffix of the file name or URI will decide: '.ttl' means
Turtle, RDF/XML otherwise.
inp - input file; anything that RDFLib accepts in that position (URI,
file name, file object). If '-', standard input is used.
Interpret the owl import statements. Essentially, recursively merge
with all the objects in the owl import statement, and remove the
corresponding triples from the graph.
This method can be used by an application prior to expansion. It is
not done by the the DeductiveClosure class.
Parameters:
iformat - input format; can be one of AUTO, TURTLE, or RDFXML. AUTO means
that the suffix of the file name or URI will decide: '.ttl' means
Turtle, RDF/XML otherwise.
Return the right semantic extension class based on three possible
choices (this method is here to help potential users, the result can be
fed into a DeductiveClosure instance at initialization)
Parameters:
owl_closure (boolean) - whether OWL 2 RL deductive closure should be calculated
rdfs_closure (boolean) - whether RDFS deductive closure should be calculated. In case
owl_closure==True, this parameter should also be
used in the initialization of DeductiveClosure
owl_extras - whether the extra possibilities (rational datatype, etc) should
be added to an OWL 2 RL deductive closure. This parameter has no
effect in case owl_closure==False.
trimming - whether extra trimming is done on the OWL RL + Extension output
Entry point for external scripts (CGI or command line) to parse an RDF
file(s), possibly execute OWL and/or RDFS closures, and serialize back
the result in some format. Note that this entry point can be used
requiring no entailment at all; because both the input and the output
format for the package can be RDF/XML or Turtle, such usage would simply
mean a format conversion.
If OWL 2 RL processing is required, that also means that the
owl:imports statements are interpreted. Ie, ontologies can be spread over
several files. Note, however, that the output of the process would then
include all imported ontologies, too.
Parameters:
options - object with specific attributes, namely:
options.sources: list of uris or file names for the source
data; for each one if the name ends with 'ttl', it is
considered to be turtle, RDF/XML otherwise (this can be
overwritten by the options.iformat, though)
options.text: direct Turtle encoding of a graph as a text
string (useful, eg, for a CGI call using a text field)
options.owlClosure: can be yes or no
options.rdfsClosure: can be yes or no
options.owlExtras: can be yes or no; whether the extra rules
beyond OWL 2 RL are used or not.
options.axioms: whether relevant axiomatic triples are added
before chaining (can be a boolean, or the strings
"yes" or "no")
options.daxioms: further datatype axiomatic triples are added
to the output (can be a boolean, or the strings
"yes" or "no")
options.format: output format, can be "turtle" or
"rdfxml"
options.iformat: input format, can be "turtle",
"rdfa", "json", "rdfxml", or
"auto". "auto" means that the suffix of
the file is considered: '.ttl'. '.html', 'json' or '.jsonld'
respectively with 'xml' as a fallback
options.trimming: whether the extension to OWLRL should also
include trimming
closureClass - explicit class reference. If set, this overrides the various
different other options to be used as an extension.
1# -*- coding: utf-8 -*- 2# 3""" 4This module is brute force implementation of the 'finite' version of U{RDFS semantics<http://www.w3.org/TR/rdf-mt/>} 5and of U{OWL 2 RL<http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules>} 6on the top of RDFLib (with some caveats, see below). Some extensions to these are also implemented. 7Brute force means that, in all cases, simple forward chaining rules are used to extend (recursively) the incoming graph with all triples 8that the rule sets permit (ie, the "deductive closure" of the graph is computed). 9There is an extra options whether the axiomatic triples are added to the graph (prior to the forward chaining step). 10These, typically set the domain and range for properties or define some core classes. 11In the case of RDFS, the implementation uses a 'finite' version of the axiomatic triples only (as proposed, for example, 12by Herman ter Horst). This means that it adds only those C{rdf:_i} type predicates that do appear in the original graph, 13thereby keeping this step finite. For OWL 2 RL, OWL 2 does not define axiomatic triples formally; but they can be deduced from the 14U{OWL 2 RDF Based Semantics<http://www.w3.org/TR/owl2-rdf-based-semantics/>} document and are listed in Appendix 6 (though informally). 15Note, however, that this implementation adds only those triples that refer to OWL terms that are meaningful for the OWL 2 RL case. 16 17 18Package Entry Points 19==================== 20 21The main entry point to the package is via the L{DeductiveClosure<DeductiveClosure>} class. This class should be initialized to control 22the parameters of the deductive closure; the forward chaining is done via the L{expand<DeductiveClosure.expand>} method. 23The simplest way to use the package from an RDFLib application is as follows:: 24 25 graph = Graph() # creation of an RDFLib graph 26 ... 27 ... # normal RDFLib application, eg, parsing RDF data 28 ... 29 DeductiveClosure(OWLRL_Semantics).expand(graph) # calculate an OWL 2 RL deductive closure of graph 30 # without axiomatic triples 31 32The first argument of the C{DeductiveClosure} initialization can be replaced by other classes, providing different 33types of deductive closure; other arguments are also possible. For example:: 34 35 DeductiveClosure(OWLRL_Extension, rdfs_closure = True, axiomatic_triples = True, datatype_axioms = True).expand(graph) 36 37will calculate the deductive closure including RDFS and some extensions to OWL 2 RL, and with all possible axiomatic 38triples added to the graph (this is about the maximum the package can do…) 39 40The same instance of L{DeductiveClosure<DeductiveClosure>} can be used for several graph expansions. In other words, the expand function does not change any state. 41 42For convenience, a second entry point to the package is provided in the form of a function called L{convert_graph<convert_graph>}, 43that expects a directory with various options, including a file name. The function parses the file, creates the expanded graph, and serializes the result into RDF/XML or 44Turtle. This function is particularly useful as an entry point for a CGI call (where the HTML form parameters are in a directory) and 45is easy to use with a command line interface. The package distribution contains an example for both. 46 47There are major closure type (ie, semantic closure possibilities); these can be controlled through the appropriate 48parameters of the L{DeductiveClosure<DeductiveClosure>} class: 49 50 - using the L{RDFS_Semantics<RDFSClosure.RDFS_Semantics>} class, implementing the U{RDFS semantics<http://www.w3.org/TR/rdf-mt/>} 51 - using the L{OWLRL_Semantics<OWLRL.OWLRL_Semantics>} class, implementing the U{OWL 2 RL<http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules>} 52 - using L{RDFS_OWLRL_Semantics<CombinedClosure.RDFS_OWLRL_Semantics>} class, implementing a combined semantics of U{RDFS semantics<http://www.w3.org/TR/rdf-mt/>} and U{OWL 2 RL<http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules>} 53 54In all three cases there are other dimensions that can control the exact closure being generated: 55 56 - for convenience, the so called axiomatic triples (see, eg, the U{axiomatic triples in RDFS<http://www.w3.org/TR/rdf-mt/#rdfs_interp>}) are, by default, I{not} added to the graph closure to reduce the number of generated triples. These can be controlled through a separate initialization argument 57 - similarly, the axiomatic triples for D-entailment are separated 58 59Some Technical/implementation aspects 60===================================== 61 62The core processing is done in the in the L{Core<Closure.Core>} class, which is subclassed by the L{RDFS<RDFS_Semantics>} and 63the L{OWL 2 RL<OWLRL_Semantics>} classes (these two are then, on their turn, subclassed by the 64L{RDFS + OWL 2 RL Semantics<CombinedClosure.RDFS_OWLRL_Semantics>}) class). The core implements the core functionality of cycling 65through the rules, whereas the rules themselves are defined and implemented in the subclasses. There are also methods that are executed only once either 66at the beginning or at the end of the full processing cycle. Adding axiomatic triples is handled separately, which allows a finer user control over 67these features. 68 69Literals must be handled separately. Indeed, the functionality relies on 'extended' RDF graphs, that allows literals 70to be in a subject position, too. Because RDFLib does not allow that, processing begins by exchanging all literals in the 71graph for bnodes (identical literals get the same associated bnode). Processing occurs on these bnodes; at the end of the process 72all these bnodes are replaced by their corresponding literals if possible (if the bnode occurs in a subject position, that triple 73is removed from the resulting graph). Details of this processing is handled in the separate L{Literals Proxies<RDFClosure.Literals.LiteralProxies>} 74class. 75 76The OWL specification includes references to datatypes that are not in the core RDFS specification, consequently not 77directly implemented by RDFLib. These are added in a separate module of the package. 78 79 80Problems with Literals with datatypes 81------------------------------------- 82 83The current distribution of RDFLib is fairly poor in handling datatypes, particularly in checking whether a lexical form 84of a literal is "proper" as for its declared datatype. A typical example is:: 85 "-1234"^^xsd:nonNegativeInteger 86which should not be accepted as valid literal. Because the requirements of OWL 2 RL are much stricter in this respect, an alternative set of datatype handling (essentially, conversions) had to be implemented (see the L{XsdDatatypes} module). 87 88The L{DeductiveClosure<DeductiveClosure>} class has an additional instance variable whether 89the default RDFLib conversion routines should be exchanged against the new ones. If this flag is set to True and instance creation (this is 90the default), then the conversion routines are set back 91to the originals once the expansion is complete, thereby avoiding to influence older application that may not work properly with the 92new set of conversion routines. 93 94If the user wants to use these alternative lexical conversions everywhere in the application, then 95the L{use_improved_datatypes_conversions<DeductiveClosure.use_improved_datatypes_conversions>} method can be invoked. That method changes 96the conversion routines and, from that point on, all usage of L{DeductiveClosure<DeductiveClosure>} instances will use the 97improved conversion methods without resetting them. Ie, the code structure can be something like:: 98 DeductiveClosure().use_improved_datatypes_conversions() 99 ... RDFLib application100 DeductiveClosure().expand(graph)101 ...102The default situation can be set back using the L{use_rdflib_datatypes_conversions<DeductiveClosure.use_improved_datatypes_conversions>} call.103104It is, however, not I{required} to use these methods at all. Ie, the user can use::105 DeductiveClosure(improved_datatypes=False).expand(graph)106which will result in a proper graph expansion except for the datatype specific comparisons which will be incomplete.107108109110Problems with Literals with datatypes111-------------------------------------112113The current distribution of RDFLib is fairly poor in handling datatypes, particularly in checking whether a lexical form114of a literal is "proper" as for its declared datatype. A typical example is::115 "-1234"^^xsd:nonNegativeInteger116which should not be accepted as valid literal. Because the requirements of OWL 2 RL are much stricter in this respect, an alternative set of datatype handling (essentially, conversions) had to be implemented (see the L{XsdDatatypes} module).117118The L{DeductiveClosure<DeductiveClosure>} class has an additional instance variable whether119the default RDFLib conversion routines should be exchanged against the new ones. If this flag is set to True and instance creation (this is120the default), then the conversion routines are set back121to the originals once the expansion is complete, thereby avoiding to influence older application that may not work properly with the122new set of conversion routines.123124If the user wants to use these alternative lexical conversions everywhere in the application, then125the L{use_improved_datatypes_conversions<DeductiveClosure.use_improved_datatypes_conversions>} method can be invoked. That method changes126the conversion routines and, from that point on, all usage of L{DeductiveClosure<DeductiveClosure>} instances will use the127improved conversion methods without resetting them. Ie, the code structure can be something like::128 DeductiveClosure().use_improved_datatypes_conversions()129 ... RDFLib application130 DeductiveClosure().expand(graph)131 ...132The default situation can be set back using the L{use_rdflib_datatypes_conversions<DeductiveClosure.use_improved_datatypes_conversions>} call.133134It is, however, not I{required} to use these methods at all. Ie, the user can use::135 DeductiveClosure(improved_datatypes=False).expand(graph)136which will result in a proper graph expansion except for the datatype specific comparisons which will be incomplete.137138139@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher140@requires: U{rdflib_jsonld<https://github.com/RDFLib/rdflib-jsonld>}141@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>}142@organization: U{World Wide Web Consortium<http://www.w3.org>}143@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">}144145"""146147148# Examples: LangString is disjoint from String149__version__="5.0"150__author__='Ivan Herman'151__contact__='Ivan Herman, ivan@w3.org'152__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231'153154importStringIO155fromtypesimport*156157# noinspection PyPackageRequirements,PyPackageRequirements,PyPackageRequirements158importrdflib159160fromrdflibimportLiteralasrdflibLiteral161# noinspection PyPep8Naming162fromrdflibimportGraph163164importDatatypeHandling,Closure165fromOWLRLExtrasimportOWLRL_Extension,OWLRL_Extension_Trimming166fromOWLRLimportOWLRL_Semantics167fromRDFSClosureimportRDFS_Semantics168fromCombinedClosureimportRDFS_OWLRL_Semantics169fromOWLimportimports170171################################################################################################################172RDFXML="xml"173TURTLE="turtle"174JSON="json"175AUTO="auto"176RDFA="rdfa"177178NONE="none"179RDF="rdf"180RDFS="rdfs"181OWL="owl"182FULL="full"183184try:185fromrdflib_jsonld.parserimportJsonLDParser186fromrdflib_jsonld.serializerimportJsonLDSerializer187fromrdflib.pluginimportregister,Serializer,Parser188register('json-ld',Parser,'rdflib_jsonld.parser','JsonLDParser')189register('json-ld',Serializer,'rdflib_jsonld.serializer','JsonLDSerializer')190json_ld_available=True191except:192json_ld_available=False
199"""Parse the input into the graph, possibly checking the suffix for the format.200201 @param iformat: input format; can be one of L{AUTO}, L{TURTLE}, or L{RDFXML}. L{AUTO} means that the suffix of the file name or URI will decide: '.ttl' means Turtle, RDF/XML otherwise.202 @param inp: input file; anything that RDFLib accepts in that position (URI, file name, file object). If '-', standard input is used.203 @param graph: the RDFLib Graph instance to parse into. 204 """205ififormat==AUTO:206ifinp=="-":207format="turtle"208else:209ifinp.endswith('.ttl')orinp.endswith('.n3'):210format="turtle"211elifjson_ld_availableand(inp.endswith('.json')orinp.endswith('.jsonld')):212format="json-ld"213elifinp.endswith('.html'):214format="rdfa1.1"215else:216format="xml"217elififormat==TURTLE:218format="n3"219elififormat==RDFA:220format="rdfa1.1"221elififormat==RDFXML:222format="xml"223elififormat==JSON:224ifjson_ld_available:225format="json-ld"226else:227raiseException("JSON-LD parser is not available")228else:229raiseException("Unknown input syntax")230231ifinp=="-":232# standard input is used233importsys234source=sys.stdin235else:236source=inp237graph.parse(source,format=format)
241"""Interpret the owl import statements. Essentially, recursively merge with all the objects in the owl import statement, and remove the corresponding242 triples from the graph.243244 This method can be used by an application prior to expansion. It is I{not} done by the the L{DeductiveClosure} class.245246 @param iformat: input format; can be one of L{AUTO}, L{TURTLE}, or L{RDFXML}. L{AUTO} means that the suffix of the file name or URI will decide: '.ttl' means Turtle, RDF/XML otherwise.247 @param graph: the RDFLib Graph instance to parse into. 248 """249whileTrue:250#1. collect the import statements:251all_imports=[tfortingraph.triples((None,imports,None))]252iflen(all_imports)==0:253# no import statement whatsoever, we can go on...254return255#2. remove all the import statements from the graph256fortinall_imports:graph.remove(t)257#3. get all the imported vocabularies and import them258for(s,p,uri)inall_imports:259# this is not 100% kosher. The expected object for an import statement is a URI. However,260# on local usage, a string would also make sense, so I do that one, too261ifisinstance(uri,rdflibLiteral):262__parse_input(iformat,str(uri),graph)263else:264__parse_input(iformat,uri,graph)
265#4. start all over again to see if import statements have been imported
269"""270 Return the right semantic extension class based on three possible choices (this method is here to help potential users, the result can be271 fed into a L{DeductiveClosure} instance at initialization)272 @param owl_closure: whether OWL 2 RL deductive closure should be calculated273 @type owl_closure: boolean274 @param rdfs_closure: whether RDFS deductive closure should be calculated. In case C{owl_closure==True}, this parameter should also be used in the initialization of L{DeductiveClosure}275 @type rdfs_closure: boolean276 @param owl_extras: whether the extra possibilities (rational datatype, etc) should be added to an OWL 2 RL deductive closure. This parameter has no effect in case C{owl_closure==False}.277 @param trimming : whether extra trimming is done on the OWL RL + Extension output278 @return: deductive class reference or None279 @rtype: Class type280 """281ifowl_closure:282ifowl_extras:283iftrimming:284returnOWLRL_Extension_Trimming285else:286returnOWLRL_Extension287else:288ifrdfs_closure:289returnRDFS_OWLRL_Semantics290else:291returnOWLRL_Semantics292elifrdfs_closure:293returnRDFS_Semantics294else:295returnNone
300"""301 Entry point to generate the deductive closure of a graph. The exact choice deductive302 closure is controlled by a class reference. The important initialization parameter is the C{closure_class}: a Class object referring to a303 subclass of L{Closure.Core}. Although this package includes a number of304 such subclasses (L{OWLRL_Semantics}, L{RDFS_Semantics}, L{RDFS_OWLRL_Semantics}, and L{OWLRL_Extension}), the user can use his/her own if additional rules are305 implemented. 306307 Note that owl:imports statements are I{not} interpreted in this class, that has to be done beforehand on the graph that is to be expanded.308309 @ivar rdfs_closure: Whether the RDFS closure should also be executed. Default: False.310 @type rdfs_closure: boolean311 @ivar axiomatic_triples: Whether relevant axiomatic triples are added before chaining, except for datatype axiomatic triples. Default: False.312 @type axiomatic_triples: boolean313 @ivar datatype_axioms: Whether further datatype axiomatic triples are added to the output. Default: false.314 @type datatype_axioms: boolean315 @ivar closure_class: the class instance used to expand the graph316 @type closure_class: L{Closure.Core}317 @cvar improved_datatype_generic: Whether the improved set of lexical-to-Python conversions should be used for datatype handling I{in general}, ie, not only for a particular instance and not only for inference purposes. Default: False.318 @type improved_datatype_generic: boolean319 """320improved_datatype_generic=False321
323"""324 @param closure_class: a closure class reference.325 @type closure_class: subclass of L{Closure.Core}326 @param rdfs_closure: whether RDFS rules are executed or not327 @type rdfs_closure: boolean328 @param axiomatic_triples: Whether relevant axiomatic triples are added before chaining, except for datatype axiomatic triples. Default: False.329 @type axiomatic_triples: boolean330 @param datatype_axioms: Whether further datatype axiomatic triples are added to the output. Default: false.331 @type datatype_axioms: boolean332 @param improved_datatypes: Whether the improved set of lexical-to-Python conversions should be used for datatype handling. See the introduction for more details. Default: True.333 @type improved_datatypes: boolean334 """335ifclosure_classisNone:336self.closure_class=None337else:338ifnotisinstance(closure_class,ClassType):339raiseValueError("The closure type argument must be a class reference")340else:341self.closure_class=closure_class342self.axiomatic_triples=axiomatic_triples343self.datatype_axioms=datatype_axioms344self.rdfs_closure=rdfs_closure345self.improved_datatypes=improved_datatypes
383"""384 Entry point for external scripts (CGI or command line) to parse an RDF file(s), possibly execute OWL and/or RDFS closures,385 and serialize back the result in some format.386 Note that this entry point can be used requiring no entailment at all;387 because both the input and the output format for the package can be RDF/XML or Turtle, such usage would388 simply mean a format conversion.389390 If OWL 2 RL processing is required, that also means that the owl:imports statements are interpreted. Ie,391 ontologies can be spread over several files. Note, however, that the output of the process would then include all 392 imported ontologies, too.393394 @param options: object with specific attributes, namely:395 - options.sources: list of uris or file names for the source data; for each one if the name ends with 'ttl', it is considered to be turtle, RDF/XML otherwise (this can be overwritten by the options.iformat, though)396 - options.text: direct Turtle encoding of a graph as a text string (useful, eg, for a CGI call using a text field)397 - options.owlClosure: can be yes or no398 - options.rdfsClosure: can be yes or no399 - options.owlExtras: can be yes or no; whether the extra rules beyond OWL 2 RL are used or not.400 - options.axioms: whether relevant axiomatic triples are added before chaining (can be a boolean, or the strings "yes" or "no")401 - options.daxioms: further datatype axiomatic triples are added to the output (can be a boolean, or the strings "yes" or "no")402 - options.format: output format, can be "turtle" or "rdfxml"403 - options.iformat: input format, can be "turtle", "rdfa", "json", "rdfxml", or "auto". "auto" means that the suffix of the file is considered: '.ttl'. '.html', 'json' or '.jsonld' respectively with 'xml' as a fallback404 - options.trimming: whether the extension to OWLRL should also include trimming405 @param closureClass: explicit class reference. If set, this overrides the various different other options to be used as an extension.406 """407408def__check_yes_or_true(opt):409returnoptisTrueoropt=="yes"oropt=="Yes"oropt=="True"oropt=="true"
410411importwarnings412413warnings.filterwarnings("ignore")414iflen(options.sources)==0and(options.textisNoneorlen(options.text.strip())==0):415raiseException("No graph specified either via a URI or text")416417graph=Graph()418419# Just to be sure that this attribute does not create issues with older versions of the service...420# the try statement should be removed, eventually...421iformat=AUTO422try:423iformat=options.iformat424except:425# exception can be raised if that attribute is not used at all, true for older versions426pass427428# similar measure with the possible usage of the 'source' options429try:430ifoptions.sourceisnotNone:431options.sources.append(options.source)432except:433# exception can be raised if that attribute is not used at all, true for newer versions434pass435436# Get the sources first. Note that a possible error is filtered out, namely to process the same file twice. This is done437# by turning the input arguments into a set...438forinpinset(options.sources):439__parse_input(iformat,inp,graph)440441# add the possible extra text (ie, the text input on the HTML page)442ifoptions.textisnotNone:443graph.parse(StringIO.StringIO(options.text),format="n3")444445# Get all the options right446# noinspection PyPep8Naming447owlClosure=__check_yes_or_true(options.owlClosure)448# noinspection PyPep8Naming449rdfsClosure=__check_yes_or_true(options.rdfsClosure)450# noinspection PyPep8Naming451owlExtras=__check_yes_or_true(options.owlExtras)452try:453trimming=__check_yes_or_true(options.trimming)454except:455trimming=False456axioms=__check_yes_or_true(options.axioms)457daxioms=__check_yes_or_true(options.daxioms)458459ifowlClosure:460interpret_owl_imports(iformat,graph)461462# adds to the 'beauty' of the output463graph.bind("owl","http://www.w3.org/2002/07/owl#")464graph.bind("xsd","http://www.w3.org/2001/XMLSchema#")465466#@@@@ some smarter choice should be used later to decide what the closure class is!!! That should467# also control the import management. Eg, if the superclass includes OWL...468ifclosureClassisnotNone:469closure_class=closureClass470else:471closure_class=return_closure_class(owlClosure,rdfsClosure,owlExtras,trimming)472473DeductiveClosure(closure_class,improved_datatypes=True,rdfs_closure=rdfsClosure,axiomatic_triples=axioms,datatype_axioms=daxioms).expand(graph)474475ifoptions.format==TURTLE:476returngraph.serialize(format="turtle")477elifoptions.format==JSON:478ifjson_ld_available:479returngraph.serialize(format="json-ld")480else:481raiseException("JSON-LD serializer is not available")482else:483returngraph.serialize(format="pretty-xml")484
36"""Core of the semantics management, dealing with the RDFS and other Semantic triples. The only 37 reason to have it in a separate class is for an easier maintainability. 38 39 This is a common superclass only. In the present module, it is subclassed by 40 a L{RDFS Closure<RDFClosure.RDFSClosure.RDFS_Semantics>} class and a L{OWL RL Closure<RDFClosure.OWLRL.OWLRL_Semantics>} classes. 41 There are some methods that are implemented in the subclasses only, ie, this class cannot be used by itself! 42 43 @ivar IMaxNum: maximal index of C{rdf:_i} occurrence in the graph 44 @ivar literal_proxies: L{Literal Proxies with BNodes<RDFClosure.Literals.LiteralProxies>} for the graph 45 @type literal_proxies: L{LiteralProxies<RDFClosure.Literals.LiteralProxies>} 46 @ivar graph: the real graph 47 @type graph: rdflib.Graph 48 @ivar axioms: whether axioms should be added or not 49 @type axioms: boolean 50 @ivar daxioms: whether datatype axioms should be added or not 51 @type daxioms: boolean 52 @ivar added_triples: triples added to the graph, conceptually, during one processing cycle 53 @type added_triples: set of triples 54 @ivar error_messages: error messages (typically inconsistency messages in OWL RL) found during processing. These are added to the final graph at the very end as separate BNodes with error messages 55 @type error_messages: array of strings 56 @ivar rdfs: whether RDFS inference is also done (used in subclassed only) 57 @type rdfs: boolean 58 """ 59# noinspection PyUnusedLocal
61""" 62 @param graph: the RDF graph to be extended 63 @type graph: rdflib.Graph 64 @param axioms: whether axioms should be added or not 65 @type axioms: boolean 66 @param daxioms: whether datatype axioms should be added or not 67 @type daxioms: boolean 68 @param rdfs: whether RDFS inference is also done (used in subclassed only) 69 @type rdfs: boolean 70 """ 71self._debug=debugGlobal 72 73# Calculate the maximum 'n' value for the '_i' type predicates (see Horst's paper) 74n=1 75maxnum=0 76cont=True 77whilecont: 78cont=False 79predicate=ns_rdf[("_%d"%n)] 80for(s,p,o)ingraph.triples((None,predicate,None)): 81# there is at least one if we got here 82maxnum=n 83n+=1 84cont=True 85self.IMaxNum=maxnum 86 87self.graph=graph 88self.axioms=axioms 89self.daxioms=daxioms 90 91self.rdfs=rdfs 92 93self.error_messages=[] 94self.empty_stored_triples()
106"""107 Do some pre-processing step. This method before anything else in the closure. By default, this method is empty, subclasses108 can add content to it by overriding it.109 """110pass
113"""114 Do some post-processing step. This method when all processing is done, but before handling possible115 errors (ie, the method can add its own error messages). By default, this method is empty, subclasses116 can add content to it by overriding it.117 """118pass
121"""122 The core processing cycles through every tuple in the graph and dispatches it to the various methods implementing123 a specific group of rules. By default, this method raises an exception; indeed, subclasses124 I{must} add content to by overriding it.125 @param t: one triple on which to apply the rules126 @type t: tuple127 @param cycle_num: which cycle are we in, starting with 1. This value is forwarded to all local rules; it is also used128 locally to collect the bnodes in the graph.129 """130raiseException("This method should not be called directly; subclasses should override it")
133"""134 Add axioms.135 This is only a placeholder and raises an exception by default; subclasses I{must} fill this with real content136 """137raiseException("This method should not be called directly; subclasses should override it")
140"""141 Add d axioms.142 This is only a placeholder and raises an exception by default; subclasses I{must} fill this with real content143 """144raiseException("This method should not be called directly; subclasses should override it")
147"""148 This is only a placeholder; subclasses should fill this with real content. By default, it is just an empty call.149 This set of rules is invoked only once and not in a cycle.150 """151pass
155"""156 Return the literal value corresponding to a Literal node. Used in error messages.157 @param node: literal node158 @return: the literal value itself159 """160try:161returnself.literal_proxies.bnode_to_lit[node].lex162except:163return"????"
173"""174 Send the stored triples to the graph, and empty the container175 """176fortinself.added_triples:177self.graph.add(t)178self.empty_stored_triples()
181"""182 In contrast to its name, this does not yet add anything to the graph itself, it just stores the tuple in an183 L{internal set<Core.added_triples>}. (It is important for this to be a set: some of the rules in the various closures may184 generate the same tuples several times.) Before adding the tuple to the set, the method checks whether185 the tuple is in the final graph already (if yes, it is not added to the set).186187 The set itself is emptied at the start of every processing cycle; the triples are then effectively added to the188 graph at the end of such a cycle. If the set is189 actually empty at that point, this means that the cycle has not added any new triple, and the full processing can stop.190191 @param t: the triple to be added to the graph, unless it is already there192 @type t: a 3-element tuple of (s,p,o)193 """194(s,p,o)=t195ifnot(isinstance(s,rdflibLiteral)orisinstance(p,rdflibLiteral))andtnotinself.graph:196ifself._debugorofflineGeneration:197printt198self.added_triples.add(t)
202"""203 Generate the closure the graph. This is the real 'core'.204205 The processing rules store new triples via the L{separate method<store_triple>} which stores206 them in the L{added_triples<added_triples>} array. If that array is emtpy at the end of a cycle,207 it means that the whole process can be stopped.208209 If required, the relevant axiomatic triples are added to the graph before processing in cycles. Similarly210 the exchange of literals against bnodes is also done in this step (and restored after all cycles are over).211 """212self.pre_process()213214# Handling the axiomatic triples. In general, this means adding all tuples in the list that215# forwarded, and those include RDF or RDFS. In both cases the relevant parts of the container axioms should also216# be added.217ifself.axioms:218self.add_axioms()219220# Create the bnode proxy structure for literals221self.literal_proxies=LiteralProxies(self.graph,self)222223# Add the datatype axioms, if needed (note that this makes use of the literal proxies, the order of the call is important!224ifself.daxioms:225self.add_d_axioms()226227self.flush_stored_triples()228229# Get first the 'one-time rules', ie, those that do not need an extra round in cycles down the line230self.one_time_rules()231self.flush_stored_triples()232233# Go cyclically through all rules until no change happens234new_cycle=True235cycle_num=0236whilenew_cycle:237# yes, there was a change, let us go again238cycle_num+=1239240# DEBUG: print the cycle number out241ifself._debug:242print"----- Cycle #:%d"%cycle_num243244# go through all rules, and collect the replies (to see whether any change has been done)245# the new triples to be added are collected separately not to interfere with246# the current graph yet247self.empty_stored_triples()248249# Execute all the rules; these might fill up the added triples array250fortinself.graph:251self.rules(t,cycle_num)252253# Add the tuples to the graph (if necessary, that is). If any new triple has been generated, a new cycle254# will be necessary...255new_cycle=len(self.added_triples)>0256257fortinself.added_triples:258self.graph.add(t)259260# All done, but we should restore the literals from their proxies261self.literal_proxies.restore()262263self.post_process()264self.flush_stored_triples()265266# Add possible error messages267ifself.error_messages:268# I am not sure this is the right vocabulary to use for this purpose, but I haven't found anything!269# I could, of course, come up with my own, but I am not sure that would be kosher...270ERRNS=Namespace("http://www.daml.org/2002/03/agents/agent-ont#")271self.graph.bind("err","http://www.daml.org/2002/03/agents/agent-ont#")272forminself.error_messages:273message=BNode()274self.graph.add((message,type,ERRNS['ErrorMessage']))275self.graph.add((message,ERRNS['error'],rdflibLiteral(m)))
Core of the semantics management, dealing with the RDFS and other
Semantic triples. The only reason to have it in a separate class is for
an easier maintainability.
This is a common superclass only. In the present module, it is
subclassed by a RDFS
Closure class and a OWL RL
Closure classes. There are some methods that are implemented in the
subclasses only, ie, this class cannot be used by itself!
rules(self,
t,
cycle_num)
The core processing cycles through every tuple in the graph and
dispatches it to the various methods implementing a specific group of
rules.
Do some pre-processing step. This method before anything else in the
closure. By default, this method is empty, subclasses can add content to
it by overriding it.
Do some post-processing step. This method when all processing is done,
but before handling possible errors (ie, the method can add its own error
messages). By default, this method is empty, subclasses can add content
to it by overriding it.
The core processing cycles through every tuple in the graph and
dispatches it to the various methods implementing a specific group of
rules. By default, this method raises an exception; indeed, subclasses
must add content to by overriding it.
Parameters:
t (tuple) - one triple on which to apply the rules
cycle_num - which cycle are we in, starting with 1. This value is forwarded
to all local rules; it is also used locally to collect the bnodes
in the graph.
This is only a placeholder; subclasses should fill this with real
content. By default, it is just an empty call. This set of rules is
invoked only once and not in a cycle.
In contrast to its name, this does not yet add anything to the graph
itself, it just stores the tuple in an internal set. (It is important for this to be a set:
some of the rules in the various closures may generate the same tuples
several times.) Before adding the tuple to the set, the method checks
whether the tuple is in the final graph already (if yes, it is not added
to the set).
The set itself is emptied at the start of every processing cycle; the
triples are then effectively added to the graph at the end of such a
cycle. If the set is actually empty at that point, this means that the
cycle has not added any new triple, and the full processing can stop.
Parameters:
t (a 3-element tuple of (s,p,o)) - the triple to be added to the graph, unless it is already there
Generate the closure the graph. This is the real 'core'.
The processing rules store new triples via the separate method which stores them in the added_triples array. If that array is emtpy at the end
of a cycle, it means that the whole process can be stopped.
If required, the relevant axiomatic triples are added to the graph
before processing in cycles. Similarly the exchange of literals against
bnodes is also done in this step (and restored after all cycles are
over).
error messages (typically inconsistency messages in OWL RL) found during
processing. These are added to the final graph at the very end as
separate BNodes with error messages
The combined closure: performing both the OWL 2 RL and RDFS
closures. The two are very close but there are some rules in RDFS that
are not in OWL 2 RL (eg, the axiomatic triples concerning the container
membership properties). Using this closure class the OWL 2 RL
implementation becomes a full extension of RDFS.
1#!/d/Bin/Python/python.exe 2# -*- coding: utf-8 -*- 3# 4""" 5The combined closure: performing I{both} the OWL 2 RL and RDFS closures. 6The two are very close but there are some rules in RDFS that are not in OWL 2 RL (eg, the axiomatic 7triples concerning the container membership properties). Using this closure class the 8OWL 2 RL implementation becomes a full extension of RDFS. 9 10@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 11@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 12@organization: U{World Wide Web Consortium<http://www.w3.org>} 13@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 14 15""" 16 17__author__='Ivan Herman' 18__contact__='Ivan Herman, ivan@w3.org' 19__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 20 21fromRDFClosure.RDFSimportResource,Class,Datatype 22fromRDFClosure.OWLimportOWLClass,Thing,equivalentClass,DataRange 23 24fromRDFClosure.RDFSClosureimportRDFS_Semantics 25fromRDFClosure.OWLRLimportOWLRL_Semantics
32"""Common subclass of the RDFS and OWL 2 RL semantic classes. All methods simply call back 33 to the functions in the superclasses. This may lead to some unnecessary duplication of terms 34 and rules, but it it not so bad. Also, the additional identification defined for OWL Full, 35 ie, Resource being the same as Thing and OWL and RDFS classes being identical are added to the 36 triple store. 37 38 Note that this class is also a possible user extension point: subclasses can be created that 39 extend the standard functionality by extending this class. This class I{always} performs RDFS inferences. 40 Subclasses have to set the C{self.rdfs} flag explicitly to the requested value if that is to be controlled. 41 42 @ivar full_binding_triples: additional axiom type triples that are added to the combined semantics; these 'bind' the RDFS and the OWL worlds together 43 @ivar rdfs: whether RDFS inference is to be performed or not. In this class instance the value is I{always} C{True}, subclasses may explicitly change it at initialization time. 44 @type rdfs: boolean 45 """ 46full_binding_triples=[ 47(Thing,equivalentClass,Resource), 48(Class,equivalentClass,OWLClass), 49(DataRange,equivalentClass,Datatype) 50] 51
53""" 54 @param graph: the RDF graph to be extended 55 @type graph: rdflib.Graph 56 @param axioms: whether (non-datatype) axiomatic triples should be added or not 57 @type axioms: bool 58 @param daxioms: whether datatype axiomatic triples should be added or not 59 @type daxioms: bool 60 @param rdfs: placeholder flag (used in subclassed only, it is always defaulted to True in this class) 61 @type rdfs: boolean 62 """ 63OWLRL_Semantics.__init__(self,graph,axioms,daxioms,rdfs) 64RDFS_Semantics.__init__(self,graph,axioms,daxioms,rdfs) 65self.rdfs=True
70"""If an extension wants to add new datatypes, this method should be invoked at initialization time. 71 72 @param uri : URI for the new datatypes, like owl_ns["Rational"] 73 @param conversion_function : a function converting the lexical representation of the datatype to a Python value, 74 possibly raising an exception in case of unsuitable lexical form 75 @param datatype_list : list of datatypes already in use that has to be checked 76 @param subsumption_dict : dictionary of subsumption hierarchies (indexed by the datatype URI-s) 77 @param subsumption_key : key in the dictionary, if None, the uri parameter is used 78 @param subsumption_list : list of subsumptions associated to a subsumption key (ie, all datatypes that are superclasses of the new datatype) 79 """ 80fromDatatypeHandlingimportAltXSDToPYTHON,use_Alt_lexical_conversions 81 82ifdatatype_list: 83datatype_list.append(uri) 84 85ifsubsumption_dictandsubsumption_list: 86ifsubsumption_key: 87subsumption_dict[subsumption_key]=subsumption_list 88else: 89subsumption_dict[uri]=subsumption_list 90 91AltXSDToPYTHON[uri]=conversion_function 92use_Alt_lexical_conversions()
95"""Do some post-processing step. This method when all processing is done, but before handling possible 96 errors (ie, the method can add its own error messages). By default, this method is empty, subclasses 97 can add content to it by overriding it. 98 """ 99OWLRL_Semantics.post_process(self)
102"""103 @param t: a triple (in the form of a tuple)104 @param cycle_num: which cycle are we in, starting with 1. This value is forwarded to all local rules; it is also used105 locally to collect the bnodes in the graph.106 """107OWLRL_Semantics.rules(self,t,cycle_num)108ifself.rdfs:109RDFS_Semantics.rules(self,t,cycle_num)
122"""Adds some extra axioms and calls for the d_axiom part of the OWL Semantics."""123fortinself.full_binding_triples:124self.store_triple(t)125126# Note that the RL one time rules include the management of datatype which is a true superset127# of the rules in RDFS. It is therefore unnecessary to add those even self.rdfs is True.128OWLRL_Semantics.one_time_rules(self)
Common subclass of the RDFS and OWL 2 RL semantic classes. All methods
simply call back to the functions in the superclasses. This may lead to
some unnecessary duplication of terms and rules, but it it not so bad.
Also, the additional identification defined for OWL Full, ie, Resource
being the same as Thing and OWL and RDFS classes being identical are
added to the triple store.
Note that this class is also a possible user extension point:
subclasses can be created that extend the standard functionality by
extending this class. This class always performs RDFS inferences.
Subclasses have to set the self.rdfs flag explicitly to the
requested value if that is to be controlled.
add_new_datatype(uri,
conversion_function,
datatype_list,
subsumption_dict=None,
subsumption_key=None,
subsumption_list=None)
If an extension wants to add new datatypes, this method should be
invoked at initialization time.
full_binding_triples = [(rdflib.term.URIRef(u'http://www.w3.or...
additional axiom type triples that are added to the combined
semantics; these 'bind' the RDFS and the OWL worlds together
boolean
rdfs
whether RDFS inference is also done (used in subclassed only)
If an extension wants to add new datatypes, this method should be
invoked at initialization time.
Parameters:
uri - URI for the new datatypes, like owl_ns["Rational"]
conversion_function - a function converting the lexical representation of the datatype
to a Python value, possibly raising an exception in case of
unsuitable lexical form
datatype_list - list of datatypes already in use that has to be checked
subsumption_dict - dictionary of subsumption hierarchies (indexed by the datatype
URI-s)
subsumption_key - key in the dictionary, if None, the uri parameter is used
subsumption_list - list of subsumptions associated to a subsumption key (ie, all
datatypes that are superclasses of the new datatype)
Do some post-processing step. This method when all processing is done,
but before handling possible errors (ie, the method can add its own error
messages). By default, this method is empty, subclasses can add content
to it by overriding it.
Go through the RDFS entailment rules rdf1, rdfs4-rdfs12, by extending
the graph.
Parameters:
t - a triple (in the form of a tuple)
cycle_num - which cycle are we in, starting with 1. This value is forwarded
to all local rules; it is also used locally to collect the bnodes
in the graph.
Most of the XSD datatypes are handled directly by RDFLib. However, in
some cases, that is not good enough. There are two major reasons for
this:
Some datatypes are missing from RDFLib and required by OWL 2 RL
and/or RDFS
In other cases, though the datatype is present, RDFLib is fairly lax
in checking the lexical value of those datatypes. Typical case is
boolean.
Some of these deficiencies are handled by this module. All the
functions convert the lexical value into a python datatype (or return the
original string if this is not possible) which will be used, eg, for
comparisons (equalities). If the lexical value constraints are not met,
exceptions are raised.
_strToDecimal(v)
The built in datatype handling for RDFLib maps a decimal number to
float, but the python version 2.4 and upwards also has a Decimal
number.
Almost all time/date related methods require the extraction of an
optional time zone information.
Parameters:
incoming_v - the time/date string @return (v,timezone) tuple; 'v' is the input
string with the timezone info cut off, 'timezone' is a _namelessTZ instance
or None
The built in datatype handling for RDFLib maps a decimal number to
float, but the python version 2.4 and upwards also has a Decimal number.
Better make use of that to use very high numbers. However, there is also
a big difference between Python's decimal and XSD's decimal, because the
latter does not allow for an exponential normal form (why???). This must
be filtered out.
Parameters:
v - the literal string defined as decimal @return Decimal
Rudimentary test for the AnyURI value. If it is a relative URI, then
some tests are done to filter out mistakes. I am not sure this is the
full implementation of the RFC, though, may have to be checked at some
point later.
Parameters:
v - the literal string defined as a URI @return the incoming value
Rudimentary test for the base64Binary value. The problem is that the
built-in b64 module functions ignore the fact that only a certain family
of characters are allowed to appear in the lexical value, so this is
checked first.
Parameters:
v - the literal string defined as a base64encoded string @return the
decoded (binary) content
Test and convert a double value into a Decimal or float. Raises an
exception if the number is outside the permitted range, ie, 1.0E+310 and
1.0E-330. To be on the safe side (python does not have double!) Decimals
are used if possible. Upper and lower values, as required by xsd, are
checked (and these fixed values are the reasons why Decimal is used!)
Parameters:
v - the literal string defined as a double @return Decimal
Test and convert a float value into Decimal or (python) float. Raises
an exception if the number is outside the permitted range, ie, 1.0E+40
and 1.0E-50. (And these fixed values are the reasons why Decimal is
used!)
Parameters:
v - the literal string defined as a float @return Decimal if the
local python version is >= 2.4, float otherwise
Registering the datatypes item for RDFLib, ie, bind the dictionary
values. The 'bind' method of RDFLib adds extra datatypes to the
registered ones in RDFLib, though the table used here (ie, AltXSDToPYTHON) actually overrides all of the default
conversion routines. The method also add a Decimal entry to the
PythonToXSD array of RDFLib.
1#!/d/Bin/Python/python.exe 2# -*- coding: utf-8 -*- 3# 4""" 5Most of the XSD datatypes are handled directly by RDFLib. However, in some cases, that is not good enough. There are two 6major reasons for this: 7 8 1. Some datatypes are missing from RDFLib and required by OWL 2 RL and/or RDFS 9 2. In other cases, though the datatype is present, RDFLib is fairly lax in checking the lexical value of those datatypes. Typical case is boolean. 10 11Some of these deficiencies are handled by this module. All the functions convert the lexical value into a 12python datatype (or return the original string if this is not possible) which will be used, eg, 13for comparisons (equalities). If the lexical value constraints are not met, exceptions are raised. 14 15@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 16@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 17@organization: U{World Wide Web Consortium<http://www.w3.org>} 18@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 19""" 20 21__author__='Ivan Herman' 22__contact__='Ivan Herman, ivan@w3.org' 23__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 24 25# noinspection PyPep8Naming 26fromRDFClosure.RDFSimportRDFNSasns_rdf 27 28fromrdflib.termimportXSDToPython,Literal,_toPythonMapping 29# noinspection PyPep8Naming 30fromrdflib.namespaceimportXSDasns_xsd 31 32importdatetime,time,re 33fromdecimalimportDecimal 34 35# noinspection PyMissingConstructor,PyPep8Naming
37"""(Nameless) timezone object. The python datetime object requires timezones as 38 a specific object added to the conversion, rather than the explicit hour and minute 39 difference used by XSD. This class is used to wrap around the hour/minute values. 40 """
60"""Almost all time/date related methods require the extraction of an optional time zone information. 61 @param incoming_v: the time/date string 62 @return (v,timezone) tuple; 'v' is the input string with the timezone info cut off, 'timezone' is a L{_namelessTZ} instance or None 63 """ 64ifincoming_v[-1]=='Z': 65v=incoming_v[:-1] 66tzone=_namelessTZ(0,0) 67else: 68pattern=".*(\+|-)([0-9][0-9]):([0-9][0-9])" 69match=re.match(pattern,incoming_v) 70ifmatchisNone: 71v=incoming_v 72tzone=None 73else: 74hours=int(match.groups()[1]) 75ifmatch.groups()[0]=='-': 76hours=-hours-1 77minutes=int(match.groups()[2]) 78v=incoming_v[:-6] 79tzone=_namelessTZ(hours,minutes) 80returnv,tzone
86"""The built-in conversion to boolean is way too lax. The xsd specification requires that only true, false, 1 or 0 should be used... 87 @param v: the literal string defined as boolean 88 @return corresponding boolean value 89 @raise ValueError: invalid boolean values 90 """ 91ifv.lower()=="true"orv.lower()=="1": 92returnTrue 93elifv.lower()=="false"orv.lower()=="0": 94returnFalse 95else: 96raiseValueError("Invalid boolean literal value %s"%v)
102"""The built in datatype handling for RDFLib maps a decimal number to float, but the python version 2.4 and upwards also103 has a Decimal number. Better make use of that to use very high numbers.104 However, there is also a big difference between Python's decimal and XSD's decimal, because the latter does not allow105 for an exponential normal form (why???). This must be filtered out.106 @param v: the literal string defined as decimal107 @return Decimal108 @raise ValueError: invalid decimal value109 """110# check whether the lexical form of 'v' is o.k.111ifv.find('E')!=-1orv.find('e')!=-1:112# this is an invalid lexical form, though would be accepted by Python113raiseValueError("Invalid decimal literal value %s"%v)114else:115returnDecimal(v)
116117#################################### ANY URIS ##################################################118#: set of characters allowed in a hexadecimal number119_hexc=['A','B','C','D','E','F','a','b','c','d','e','f']120#: set of numerals121_numb=['1','2','3','4','5','6','7','8','9','0']122# noinspection PyPep8Naming
124"""Rudimentary test for the AnyURI value. If it is a relative URI, then some tests are done to filter out125 mistakes. I am not sure this is the full implementation of the RFC, though, may have to be checked at some point126 later.127 @param v: the literal string defined as a URI128 @return the incoming value129 @raise ValueError: invalid URI value130 """131importurlparse132iflen(v)==0:returnv133ifurlparse.urlsplit(v)[0]!="":134# this means that there is a proper scheme, the URI should be kosher135returnv136else:137# this is meant to be a relative URI.138# If I am correct, that cannot begin with one or more "?" or ":" characters139# all others are o.k.140# if it begins with a % then it should be followed by two hexa characters,141# otherwise it is also a bug142ifv[0]=='%':143iflen(v)>=3and(v[1]in_hexcorv[1]in_numb)and(v[2]in_hexcorv[2]in_numb):144returnv145else:146raiseValueError("Invalid IRI %s"%v)147elifv[0]=='?'orv[0]==':':148raiseValueError("Invalid IRI %s"%v)149else:150returnv
155"""Rudimentary test for the base64Binary value. The problem is that the built-in b64 module functions ignore the156 fact that only a certain family of characters are allowed to appear in the lexical value, so this is checked first.157 @param v: the literal string defined as a base64encoded string158 @return the decoded (binary) content159 @raise ValueError: invalid base 64 binary value160 """161importbase64162ifv.replace('=','x').replace('+','y').replace('/','z').isalnum():163try:164returnbase64.standard_b64decode(v)165except:166raiseValueError("Invalid Base64Binary %s"%v)167else:168raiseValueError("Invalid Base64Binary %s"%v)
169170#################################### Numerical types ##################################################171#: limits for unsigned bytes172_limits_unsignedByte=[-1,256]173174#: limits for bytes175_limits_byte=[-129,128]176177#: limits for unsigned int178_limits_unsignedInt=[-1,4294967296]179180#: limits for int181_limits_int=[-2147483649,2147483648]182183#: limits for unsigned short184_limits_unsignedShort=[-1,65536]185186#: limits for short187_limits_short=[-32769,32768]188189#: limits for unsigned long190_limits_unsignedLong=[-1,18446744073709551616]191192#: limits for long193_limits_long=[-9223372036854775809,9223372036854775808]194195#: limits for positive integer196_limits_positiveInteger=[0,None]197198#: limits for non positive integer199_limits_nonPositiveInteger=[None,1]200201#: limits for non negative integer202_limits_nonNegativeInteger=[-1,None]203204#: limits for negative integer205_limits_negativeInteger=[None,0]206207# noinspection PyPep8Naming,PyBroadException
209"""Test (and convert) a generic numerical type, with a check against a lower and upper limit.210 @param v: the literal string to be converted211 @param interval: lower and upper bounds (non inclusive). If the value is None, no comparison should be done212 @param conversion: conversion function, ie, int, long, etc213 @raise ValueError: invalid value214 """215try:216i=conversion(v)217if(interval[0]isNoneorinterval[0]<i)and(interval[1]isNoneori<interval[1]):218returni219except:220pass221raiseValueError("Invalid numerical value %s"%v)
222223#################################### Double and float ##################################################224# noinspection PyPep8Naming
226"""Test and convert a double value into a Decimal or float. Raises an exception if the number is outside the permitted227 range, ie, 1.0E+310 and 1.0E-330. To be on the safe side (python does not have double!) Decimals are used228 if possible. Upper and lower values, as required by xsd, are checked (and these fixed values are the reasons229 why Decimal is used!)230231 @param v: the literal string defined as a double232 @return Decimal233 @raise ValueError: invalid value234 """235try:236value=Decimal(v)237upper=Decimal("1.0E+310")238lower=Decimal("1.0E-330")239iflower<abs(value)<upper:240# bingo241returnvalue242else:243raiseValueError("Invalid double %s"%v)244except:245# there was a problem in creating a decimal...246raiseValueError("Invalid double %s"%v)
250"""Test and convert a float value into Decimal or (python) float. Raises an exception if the number is outside the251 permitted range, ie, 1.0E+40 and 1.0E-50. (And these fixed values are the reasons why Decimal is used!)252253 @param v: the literal string defined as a float254 @return Decimal if the local python version is >= 2.4, float otherwise255 @raise ValueError: invalid value256 """257try:258value=Decimal(v)259upper=Decimal("1.0E+40")260lower=Decimal("1.0E-50")261iflower<abs(value)<upper:262# bingo263returnvalue264else:265raiseValueError("Invalid float %s"%v)266except:267# there was a problem in creating a decimal...268raiseValueError("Invalid float %s"%v)
273"""Test (and convert) hexa integer values. The number of characters should be even.274 @param v: the literal string defined as a hexa number275 @return long value276 @raise ValueError: invalid value277 """278# first of all, the number of characters must be even according to the xsd spec:279length=len(v)280if(length/2)*2!=length:281raiseValueError("Invalid hex binary number %s"%v)282returnlong(v,16)
283284#################################### Datetime, date timestamp, etc ################################285286# noinspection PyPep8Naming
288"""Test (and convert) datetime and date timestamp values.289 @param incoming_v: the literal string defined as the date and time290 @param timezone_required: whether the timezone is required (ie, for date timestamp) or not291 @return datetime292 @rtype: datetime.datetime293 @raise ValueError: invalid datetime or date timestamp294 """295296# First, handle the timezone portion, if there is any297(v,tzone)=_returnTimeZone(incoming_v)298299# Check on the timezone. For time date stamp object it is required300iftimezone_requiredandtzoneisNone:301raiseValueError("Invalid datetime %s"%incoming_v)302303# The microseconds should be handled here...304final_v=v305milliseconds=0306milpattern="(.*)(\.)([0-9]*)"307match=re.match(milpattern,v)308ifmatchisnotNone:309# we have a millisecond portion...310try:311final_v=match.groups()[0]312milliseconds=int(match.groups()[2])313except:314raiseValueError("Invalid datetime %s"%incoming_v)315#316# By now, the pattern should be clear317# This may raise an exception...318try:319tstr=time.strptime(final_v,"%Y-%m-%dT%H:%M:%S")320iftzoneisnotNone:321returndatetime.datetime(tstr.tm_year,tstr.tm_mon,tstr.tm_mday,tstr.tm_hour,tstr.tm_min,tstr.tm_sec,milliseconds,tzone)322else:323returndatetime.datetime(tstr.tm_year,tstr.tm_mon,tstr.tm_mday,tstr.tm_hour,tstr.tm_min,tstr.tm_sec,milliseconds)324except:325raiseValueError("Invalid datetime %s"%incoming_v)
329"""Test (and convert) time values.330 @param incoming_v: the literal string defined as time value331 @return time332 @rtype datetime.time333 @raise ValueError: invalid datetime or date timestamp334 """335336# First, handle the timezone portion, if there is any337(v,tzone)=_returnTimeZone(incoming_v)338339# The microseconds should be handled here...340final_v=v341milliseconds=0342milpattern="(.*)(\.)([0-9]*)"343match=re.match(milpattern,v)344ifmatchisnotNone:345# we have a millisecond portion...346try:347final_v=match.groups()[0]348milliseconds=int(match.groups()[2])349except:350raiseValueError("Invalid datetime %s"%incoming_v)351#352# By now, the pattern should be clear353# This may raise an exception...354try:355tstr=time.strptime(final_v,"%H:%M:%S")356iftzoneisnotNone:357returndatetime.time(tstr.tm_hour,tstr.tm_min,tstr.tm_sec,milliseconds,tzone)358else:359returndatetime.time(tstr.tm_hour,tstr.tm_min,tstr.tm_sec,milliseconds)360except:361raiseValueError("Invalid time %s"%incoming_v)
365"""Test (and convert) date values.366 @param incoming_v: the literal string defined as date (in iso format)367 @return date368 @return datetime.date369 @raise ValueError: invalid datetime or date timestamp370 """371372# First, handle the timezone portion, if there is any373(final_v,tzone)=_returnTimeZone(incoming_v)374375# This may raise an exception...376try:377tstr=time.strptime(final_v,"%Y-%m-%d")378returndatetime.date(tstr.tm_year,tstr.tm_mon,tstr.tm_mday)379except:380raiseValueError("Invalid date %s"%incoming_v)
381382#################################### The 'g' series for dates ############################383# The 'g' datatypes (eg, gYear) cannot be directly represented as a python datatype384# the series of methods below simply check whether the incoming string is o.k., but the385# returned value is the same as the original386# noinspection PyPep8Naming
454"""Test (and convert) XML Literal values.455 @param v: the literal string defined as an xml literal456 @return the canonical version of the same xml text457 @raise ValueError: incorrect xml string458 """459importxml.dom.minidom460try:461dom=xml.dom.minidom.parseString(v)462returndom.toxml()463except:464raiseValueError("Invalid XML Literal %s"%v)
465466#################################### language, NMTOKEN, NAME, etc #########################467#: regular expression for a 'language' datatype468_re_language="[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*"469470#: regexp for NMTOKEN. It must be used with a re.U flag (the '(?U' regexp form did not work. It may depend on the locale...)471_re_NMTOKEN="[\w:_.\-]+"472473#: characters not permitted at a starting position for Name (otherwise Name is like NMTOKEN474_re_Name_ex=['.','-']+_numb475476#: regexp for NCName. It must be used with a re.U flag (the '(?U' regexp form did not work. It may depend on the locale...)477_re_NCName="[\w_.\-]+"478479#: characters not permitted at a starting position for NCName480_re_NCName_ex=['.','-']+_numb481482# noinspection PyDefaultArgument,PyPep8Naming,PyPep8Naming
484"""Test (and convert) a generic string type, with a check against a regular expression.485 @param v: the literal string to be converted486 @param regexp: the regular expression to check against487 @param flag: flags to be used in the regular expression488 @param excludeStart: array of characters disallowed in the first position489 @return original string490 @raise ValueError: invalid value491 """492match=re.match(regexp,v,flag)493ifmatchisNoneormatch.end()!=len(v):494raiseValueError("Invalid literal %s"%v)495else:496iflen(excludeStart)>0andv[0]inexcludeStart:497raiseValueError("Invalid literal %s"%v)498returnv
499500#: Disallowed characters in a token or a normalized string, as a regexp501_re_token="[^\n\t\r]+"502503# noinspection PyPep8Naming
505"""Test (and convert) a string to a token.506 @param v: the literal string to be converted507 @return original string508 @raise ValueError: invalid value509 """510iflen(v)==0:511returnv512# filter out the case when there are new lines and similar (if there is a problem, an exception is raised)513_strToVal_Regexp(v,_re_token)514v1=' '.join(v.strip().split())515# normalize the string, and see if the result is the same:516iflen(v1)==len(v):517# no characters lost, ie, no unnecessary spaces518returnv519else:520raiseValueError("Invalid literal %s"%v)
525"""Test (and convert) a plain literal526 @param v: the literal to be converted527 @return a new RDFLib Literal with language tag528 @raise ValueError: invalid value529 """530reg="(.*)@([^@]*)"531# a plain literal must match this regexp!532match=re.match(reg,v)533ifmatchisNone:534raiseValueError("Invalid plain literal %s"%v)535else:536lit=match.groups()[0]537iflen(match.groups())==1ormatch.groups()[1]=="":538# no language tag539returnLiteral(lit)540else:541lang=match.groups()[1]542# check if this is a correct language tag. Note that can raise an exception!543try:544lang=_strToVal_Regexp(lang,_re_language)545returnLiteral(lit,lang=lang.lower())546except:547raiseValueError("Invalid plain literal %s"%v)
597"""Registering the datatypes item for RDFLib, ie, bind the dictionary values. The 'bind' method of RDFLib adds598 extra datatypes to the registered ones in RDFLib, though the table used here (ie, L{AltXSDToPYTHON}) actually overrides599 all of the default conversion routines. The method also add a Decimal entry to the PythonToXSD array of RDFLib.600 """601_toPythonMapping.update(AltXSDToPYTHON)
605"""Restore the original (ie, RDFLib) set of lexical conversion routines.606 """607_toPythonMapping.update(XSDToPython)
608609#######################################################################################610# This module can pretty much tested individually...611if__name__=='__main__':612importsys613dtype=sys.argv[1]614string=sys.argv[2]615datatype=ns_xsd[dtype]616result=AltXSDToPYTHON[datatype](string)617printtype(result)618printresult619
(Nameless) timezone object. The python datetime object requires
timezones as a specific object added to the conversion, rather than the
explicit hour and minute difference used by XSD. This class is used to
wrap around the hour/minute values.
Entry point to generate the deductive closure of a graph. The exact
choice deductive closure is controlled by a class reference. The
important initialization parameter is the closure_class: a
Class object referring to a subclass of Closure.Core.
Although this package includes a number of such subclasses (OWLRL_Semantics, RDFS_Semantics, RDFS_OWLRL_Semantics, and OWLRL_Extension), the user can use his/her own if
additional rules are implemented.
Note that owl:imports statements are not interpreted in this
class, that has to be done beforehand on the graph that is to be
expanded.
improved_datatype_generic = False
Whether the improved set of lexical-to-Python conversions should be
used for datatype handling in general, ie, not only for a
particular instance and not only for inference purposes.
closure_class (subclass of Closure.Core) - a closure class reference.
rdfs_closure (boolean) - whether RDFS rules are executed or not
axiomatic_triples (boolean) - Whether relevant axiomatic triples are added before chaining,
except for datatype axiomatic triples. Default: False.
datatype_axioms (boolean) - Whether further datatype axiomatic triples are added to the
output. Default: false.
improved_datatypes (boolean) - Whether the improved set of lexical-to-Python conversions should
be used for datatype handling. See the introduction for more
details. Default: True.
Whether the improved set of lexical-to-Python conversions should be used
for datatype handling in general, ie, not only for a particular
instance and not only for inference purposes. Default: False.
The issue is that pure literals cannot appear in subject position
according to the current rules on RDF. That means that different types of
conclusions cannot properly finish. The present trick is trying to get
around the problem as follows:
For all literals in the graph a bnode is created. The module does not
do a full D entailment but just relies on RDFLib's ability to
recognize identical literals
All those bnodes get a type Literal
All triples with literals are exchanged against a triple with the
associated bnode
The inferences are then calculated with the modified Graph. At the end
of the process, the above steps are done backwards: for all triples where
a bnode representing a literal appear in object position, a triple is
generated; however, all triples where the bnode appears in a subject
position are removed from the final graph.
_LiteralStructure
This class serves as a wrapper around rdflib's Literal, by changing
the equality function to a strict identity of datatypes and lexical
values.
1# -*- coding: utf-8 -*- 2# 3""" 4Separate module to handle literals. 5 6The issue is that pure literals cannot appear in subject position according to the current rules on RDF. That means that 7different types of conclusions cannot properly finish. The present trick is trying to get around the problem as follows: 8 9 1. For all literals in the graph a bnode is created. The module does not do a full D entailment but just relies on RDFLib's ability to recognize identical literals 10 2. All those bnodes get a type Literal 11 3. All triples with literals are exchanged against a triple with the associated bnode 12 13The inferences are then calculated with the modified Graph. At the end of the process, the above steps are done backwards: for all triples where 14a bnode representing a literal appear in object position, a triple is generated; however, all triples where the bnode appears in a 15subject position are removed from the final graph. 16 17 18@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 19@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 20@organization: U{World Wide Web Consortium<http://www.w3.org>} 21@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 22 23""" 24 25__author__='Ivan Herman' 26__contact__='Ivan Herman, ivan@w3.org' 27__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 28 29fromrdflibimportBNode 30fromrdflibimportLiteralasrdflibLiteral 31fromrdflib.namespaceimportXSDasns_xsd 32 33from.RDFSimporttype 34from.RDFSimportLiteral 35from.DatatypeHandlingimportAltXSDToPYTHON 36 37
39"""This class serves as a wrapper around rdflib's Literal, by changing the equality function to a strict 40 identity of datatypes and lexical values. 41 42 On the other hand, to implement, eg, OWL RL's datatype rules, a should be able to generate 43 an 'a sameAs b' triple, ie, the distinction should be kept. Hence this class that overrides the equality, 44 and then can be used as a key in a Python dictionary. 45 """ 46 47# noinspection PyPep8
77"""Compare to literal structure instances for equality. Here equality means in the sense of datatype values 78 @return: comparison result 79 @rtype: boolean 80 """ 81try: 82returnself.lit==other.lit 83except: 84# There might be conversion problems... 85returnFalse
113"""114 @param graph: the graph to be modified115 """116self.lit_to_bnode={}117self.bnode_to_lit={}118self.graph=graph119120to_be_removed=[]121to_be_added=[]122fortinself.graph:123(subj,pred,obj)=t124# This is supposed to be a "proper" graph, so only the obj may be a literal125ifisinstance(obj,rdflibLiteral):126# Test the validity of the datatype127ifobj.datatype:128try:129AltXSDToPYTHON[obj.datatype](str(obj))130exceptValueError:131closure.add_error("Lexical value of the literal '%s' does not match its datatype (%s)"%(str(obj),obj.datatype))132133# In any case, this should be removed:134iftnotinto_be_removed:135to_be_removed.append(t)136# Check if a BNode has already been associated with that literal137obj_st=_LiteralStructure(obj)138found=False139forlinself.lit_to_bnode.keys():140ifobj_st.lex==l.lexandobj_st.dt==l.dtandobj_st.lang==l.lang:141t1=(subj,pred,self.lit_to_bnode[l])142to_be_added.append(t1)143found=True144break145ifnotfound:146# the bnode has to be created147bn=BNode()148# store this in the internal administration149self.lit_to_bnode[obj_st]=bn150self.bnode_to_lit[bn]=obj_st151# modify the graph152to_be_added.append((subj,pred,bn))153to_be_added.append((bn,type,Literal))154# Furthermore: a plain literal should be identified with a corresponding xsd:string and vice versa, 155# cf, RDFS Semantics document156ifobj_st.dtisNoneandobj_st.langisNone:157newLit=rdflibLiteral(obj_st.lex,datatype=ns_xsd["string"])158new_obj_st=_LiteralStructure(newLit)159new_obj_st.dt=ns_xsd["string"]160bn2=BNode()161self.lit_to_bnode[new_obj_st]=bn2162self.bnode_to_lit[bn2]=new_obj_st163to_be_added.append((subj,pred,bn2))164to_be_added.append((bn2,type,Literal))165elifobj_st.dt==ns_xsd["string"]:166newLit=rdflibLiteral(obj_st.lex,datatype=None)167new_obj_st=_LiteralStructure(newLit)168# new_obj_st = _LiteralStructure(obj) # Was this the correct one, or was this an old bug?169new_obj_st.dt=None170bn2=BNode()171self.lit_to_bnode[new_obj_st]=bn2172self.bnode_to_lit[bn2]=new_obj_st173to_be_added.append((subj,pred,bn2))174to_be_added.append((bn2,type,Literal))175176# Do the real modifications177self._massageGraph(to_be_removed,to_be_added)
180"""181 This method is to be invoked at the end of the forward chain processing. It restores literals (whenever possible)182 to their original self...183 """184to_be_removed=[]185to_be_added=[]186fortinself.graph:187(subj,pred,obj)=t188# The two cases, namely when the literal appears in subject or object positions, should be treated differently189ifsubjinself.bnode_to_lit:190# well... there may be to cases here: either this is the original tuple stating that191# this bnode is a literal, or it is the result of an inference. In both cases, the tuple must192# be removed from the result without any further action193iftnotinto_be_removed:194to_be_removed.append(t)195elifobjinself.bnode_to_lit:196# This is where the exchange should take place: put back the real literal into the graph, removing the proxy one197iftnotinto_be_removed:198to_be_removed.append(t)199# This is an additional thing due to the latest change of literal handling in RDF concepts.200# If a literal is an xsd:string then a plain literal is put in its place for the purpose of serialization...201lit=self.bnode_to_lit[obj].lit202iflit.datatypeisnotNoneandlit.datatype==ns_xsd["string"]:203lit=rdflibLiteral(str(lit))204to_be_added.append((subj,pred,lit))205206# Do the real modifications207self._massageGraph(to_be_removed,to_be_added)
210"""211 Perform the removal and addition actions on the graph212 @param to_be_removed: list of tuples to be removed213 @param to_be_added : list of tuples to be added214 """215fortinto_be_removed:216self.graph.remove(t)217fortinto_be_added:218self.graph.add(t)
This class serves as a wrapper around rdflib's Literal, by changing
the equality function to a strict identity of datatypes and lexical
values.
On the other hand, to implement, eg, OWL RL's datatype rules, a should
be able to generate an 'a sameAs b' triple, ie, the distinction should be
kept. Hence this class that overrides the equality, and then can be used
as a key in a Python dictionary.
OWL and OWL2 terms. Note that the set of terms is complete, ie,
it includes all OWL 2 terms, regardless of whether the term is
used in OWL 2 RL or not.
This module is a brute force implementation of the OWL 2
RL profile.
RDFLib works with 'generalized' RDF, meaning that triples with a BNode
predicate are allowed. This is good because, eg, some of the
triples generated for RDF from an OWL 2 functional syntax might look like
'[ owl:inverseOf p]', and the RL rules would then operate on such
generalized triple. However, as a last, post processing steps, these
triples are removed from the graph before serialization to produce
'standard' RDF (which is o.k. for RL, too, because the consequent triples
are all right, generalized triples might have had a role in the deduction
steps only).
1#!/d/Bin/Python/python.exe 2# -*- coding: utf-8 -*- 3# 4""" 5This module is a C{brute force} implementation of the OWL 2 RL profile. 6 7RDFLib works with 'generalized' RDF, meaning that triples with a BNode predicate are I{allowed}. This is good because, eg, some of the 8triples generated for RDF from an OWL 2 functional syntax might look like '[ owl:inverseOf p]', and the RL rules would then operate 9on such generalized triple. However, as a last, post processing steps, these triples are removed from the graph before serialization 10to produce 'standard' RDF (which is o.k. for RL, too, because the consequent triples are all right, generalized triples might 11have had a role in the deduction steps only). 12 13@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 14@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 15@organization: U{World Wide Web Consortium<http://www.w3.org>} 16@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 17 18""" 19 20__author__='Ivan Herman' 21__contact__='Ivan Herman, ivan@w3.org' 22__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 23 24importrdflib 25fromrdflibimportBNode 26 27fromRDFClosure.RDFSimportProperty,type 28fromRDFClosure.RDFSimportsubClassOf,subPropertyOf,comment,label,domain,range 29fromRDFClosure.RDFSimportseeAlso,isDefinedBy,Datatype 30 31fromRDFClosure.OWLimport* 32fromRDFClosure.ClosureimportCore 33fromRDFClosure.AxiomaticTriplesimportOWLRL_Axiomatic_Triples,OWLRL_D_Axiomatic_Triples 34fromRDFClosure.AxiomaticTriplesimportOWLRL_Datatypes_Disjointness 35 36OWLRL_Annotation_properties=[label,comment,seeAlso,isDefinedBy,deprecated,versionInfo,priorVersion,backwardCompatibleWith,incompatibleWith] 37 38from.XsdDatatypesimportOWL_RL_Datatypes,OWL_Datatype_Subsumptions 39 40########################################################################################################################### 41 42 43## OWL-R Semantics class 44# 45# 46# As an editing help: each rule is prefixed by RULE XXXX where XXXX is the acronym given in the profile document. 47# This helps in referring back to the spec... 48# noinspection PyPep8Naming,PyPep8Naming,PyBroadException
50"""OWL 2 RL Semantics class, ie, implementation of the OWL 2 RL closure graph. 51 52 Note that the module does I{not} implement the so called Datatype entailment rules, simply because the underlying RDFLib does 53 not implement the datatypes (ie, RDFLib will not make the literal "1.00" and "1.00000" identical, although 54 even with all the ambiguities on datatypes, this I{should} be made equal...). Also, the so-called extensional entailment rules 55 (Section 7.3.1 in the RDF Semantics document) have not been implemented either. 56 57 The comments and references to the various rule follow the names as used in the U{OWL 2 RL document<http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules>}. 58 """
60""" 61 @param graph: the RDF graph to be extended 62 @type graph: rdflib.Graph 63 @param axioms: whether (non-datatype) axiomatic triples should be added or not 64 @type axioms: bool 65 @param daxioms: whether datatype axiomatic triples should be added or not 66 @type daxioms: bool 67 @param rdfs: whether RDFS inference is also done (used in subclassed only) 68 @type rdfs: boolean 69 """ 70Core.__init__(self,graph,axioms,daxioms,rdfs) 71self.bnodes=[]
74""" 75 Shorthand to get a list of values (ie, from an rdf:List structure) starting at a head 76 77 @param l: RDFLib resource, should be the head of an rdf:List 78 @return: array of resources 79 """ 80return[chforchinself.graph.items(l)]
89""" 90 Remove triples with bnode predicates. The Bnodes in the graph are collected in the first cycle run. 91 """ 92to_be_removed=[] 93forbinself.bnodes: 94fortinself.graph.triples((None,b,None)): 95iftnotinto_be_removed: 96to_be_removed.append(t) 97fortinto_be_removed: 98self.graph.remove(t)
115"""Helping method to check whether a type statement is in line with a possible116 restriction. This method is invoked by rule "cls-avf" before setting a type117 on an allValuesFrom restriction.118119 The method is a placeholder at this level. It is typically implemented by subclasses for120 extra checks, eg, for datatype facet checks.121 @param v: the resource that is to be 'typed'122 @param t: the targeted type (ie, Class)123 @return: boolean124 """125returnTrue
128"""129 Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only130 once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once131 at the beginning of the process.132133 These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2, dt-eq, dt-diff.134135 Note, however, that the dt-* are executed only partially, limited by the possibilities offered by RDFLib. These may not136 cover all the edge cases of OWL RL. Especially, dt-not-type has not (yet?) been implemented (I wonder whether RDFLib should not raise137 exception for those anyway...138 """139# noinspection PyShadowingNames140def_add_to_explicit(s,o):141ifsnotinexplicit:142explicit[s]=[]143ifonotinexplicit[s]:144explicit[s].append(o)
153154def_add_to_used_datatypes(d):155used_datatypes.add(d)156157# noinspection PyShadowingNames158def_handle_subsumptions(r,dt):159ifdtinOWL_Datatype_Subsumptions:160fornew_dtinOWL_Datatype_Subsumptions[dt]:161self.store_triple((r,type,new_dt))162self.store_triple((new_dt,type,Datatype))163_add_to_used_datatypes(new_dt)164165166# For processing later:167# implicit object->datatype relationships: these come from real literals which are represented by168# an internal bnode169implicit={}170171# explicit object->datatype relationships: those that came from an object being typed as a datatype172# or a sameAs. The values are arrays of datatypes to which the resource belong173explicit={}174175# datatypes in use by the graph (directly or indirectly). This will be used at the end to add the176# necessary disjointness statements (but not more177used_datatypes=set()178179# the real literals from the original graph:180# literals = self.literal_proxies.lit_to_bnode.keys()181182# RULE dt-type2: for all explicit literals the corresponding bnode should get the right type183# definition. The 'implicit' dictionary is also filled on the fly184# RULE dt-not-type: see whether an explicit literal is valid in terms of the defined datatype185forltinself.literal_proxies.lit_to_bnode.keys():186# note that all non-RL datatypes are ignored187iflt.dtisnotNoneandlt.dtinOWL_RL_Datatypes:188bn=self.literal_proxies.lit_to_bnode[lt]189# add the explicit typing triple190self.store_triple((bn,type,lt.dt))191ifbnnotinimplicit:192implicit[bn]=lt.dt193_add_to_used_datatypes(lt.dt)194195# for dt-not-type196# This is a dirty trick: rdflib's Literal includes a method that raises an exception if the197# lexical value cannot be mapped on the value space.198try:199val=lt.lit.toPython()200except:201self.add_error("Literal's lexical value and datatype do not match: (%s,%s)"%(lt.lex,lt.dt))202203# RULE dt-diff204# RULE dt-eq205# Try to compare literals whether they are different or not. If they are different, then an explicit206# different from statement should be added, if they are identical, then an equality should be added207forlt1inself.literal_proxies.lit_to_bnode.keys():208forlt2inself.literal_proxies.lit_to_bnode.keys():209iflt1!=lt2:210try:211lt1_d=lt1.lit.toPython()212lt2_d=lt2.lit.toPython()213#if lt1_d != lt2_d :214# self.store_triple((self.literal_proxies.lit_to_bnode[lt1], differentFrom, self.literal_proxies.lit_to_bnode[lt2]))215#else :216# self.store_triple((self.literal_proxies.lit_to_bnode[lt1], sameAs, self.literal_proxies.lit_to_bnode[lt2]))217except:218# there may be a problem with one of the python conversion, but that should have been taken219# care of already220pass221222# Other datatype definitions can come from explicitly defining some nodes as datatypes (though rarely used,223# it is perfectly possible...224# there may be explicit relationships set in the graph, too!225for(s,p,o)inself.graph.triples((None,type,None)):226ifoinOWL_RL_Datatypes:227_add_to_used_datatypes(o)228ifsnotinimplicit:229_add_to_explicit(s,o)230231# Finally, there may be sameAs statements that bind nodes to some of the existing ones. This does not introduce232# new datatypes, so the used_datatypes array does not get extended233for(s,p,o)inself.graph.triples((None,sameAs,None)):234ifoinimplicit:235_add_to_explicit(s,implicit[o])236# note that s in implicit would mean that the original graph has237# a literal in subject position which is not allowed at the moment, so I do not bother238ifoinexplicit:239_append_to_explicit(s,o)240ifsinexplicit:241_append_to_explicit(o,s)242243# what we have now:244# explicit+implicit contains all the resources of type datatype;245# implicit contains those that are given by an explicit literal246# explicit contains those that are given by general resources, and there can be a whole array for each entry247248# RULE dt-type1: add a Datatype typing for all those249# Note: the strict interpretation of OWL RL is to do that for all allowed datatypes, but this is250# under discussion right now. The optimized version uses only what is really in use251fordtinOWL_RL_Datatypes:252self.store_triple((dt,type,Datatype))253fordtsinexplicit.values():254fordtindts:255self.store_triple((dt,type,Datatype))256257# Datatype reasoning means that certain datatypes are subtypes of one another.258# I could simply generate the extra subclass relationships into the graph and let the generic259# process work its way, but it seems to be an overkill. Instead, I prefer to add the explicit typing260# into the graph 'manually'261forrinexplicit:262# these are the datatypes that this resource has263dtypes=explicit[r]264fordtindtypes:265_handle_subsumptions(r,dt)266267forrinimplicit:268dt=implicit[r]269_handle_subsumptions(r,dt)270271# Last step: add the datatype disjointness relationships. This is done only for272# - 'top' level datatypes273# - used in the graph274fortinOWLRL_Datatypes_Disjointness:275(l,pred,r)=t276iflinused_datatypesandrinused_datatypes:277self.store_triple(t)278
294"""295 Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only296 once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once297 at the beginning of the process.298299 These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2, dt-eq, dt-diff.300 """301self._one_time_rules_misc()302self._one_time_rules_datatypes()
305"""306 Go through the various rule groups, as defined in the OWL-RL profile text and implemented via307 local methods. (The calling cycle takes every tuple in the graph.)308 @param t: a triple (in the form of a tuple)309 @param cycle_num: which cycle are we in, starting with 1. This value is forwarded to all local rules; it is also used310 locally to collect the bnodes in the graph.311 """312ifcycle_num==1:313forrint:314ifisinstance(r,BNode)andrnotinself.bnodes:315self.bnodes.append(r)316317self._properties(t,cycle_num)318self._equality(t,cycle_num)319self._classes(t,cycle_num)320self._class_axioms(t,cycle_num)321self._schema_vocabulary(t,cycle_num)
324"""325 Implementation of the property chain axiom, invoked from inside the property axiom handler. This is the326 implementation of rule prp-spo2, taken aside for an easier readability of the code. """327chain=self._list(x)328# The complication is that, at each step of the chain, there may be spawns, leading to a multitude329# of 'sub' chains:-(330iflen(chain)>0:331for(u1,_y,_z)inself.graph.triples((None,chain[0],None)):332# At least the chain can be started, because the leftmost property has at least333# one element in its extension334finalList=[(u1,_z)]335chainExists=True336forpiinchain[1:]:337newList=[]338for(_u,ui)infinalList:339foruinself.graph.objects(ui,pi):340# what is stored is only last entry with u1, the intermediate results341# are not of interest342newList.append((u1,u))343# I have now, in new list, all the intermediate results344# until pi345# if new list is empty, that means that is a blind alley346iflen(newList)==0:347chainExists=False348break349else:350finalList=newList351ifchainExists:352for(_u,un)infinalList:353self.store_triple((u1,p,un))
356"""357 Table 4: Semantics of equality. Essentially, the eq-* rules.358 @param triple: triple to work on359 @param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.360 """361# In many of the 'if' branches, corresponding to rules in the document,362# the branch begins by a renaming of variables (eg, pp,c = s,o).363# There is no programming reasons for doing that, but by renaming the364# variables it becomes easier to compare the declarative rules365# in the document with the implementation366s,p,o=triple367# RULE eq-ref368self.store_triple((s,sameAs,s))369self.store_triple((o,sameAs,o))370self.store_triple((p,sameAs,p))371ifp==sameAs:372x,y=s,o373# RULE eq-sym374self.store_triple((y,sameAs,x))375# RULE eq-trans376forzinself.graph.objects(y,sameAs):377self.store_triple((x,sameAs,z))378# RULE eq-rep-s379forpp,ooinself.graph.predicate_objects(s):380self.store_triple((o,pp,oo))381# RULE eq-rep-p382forss,ooinself.graph.subject_objects(s):383self.store_triple((ss,o,oo))384# RULE eq-rep-o385forss,ppinself.graph.subject_predicates(o):386self.store_triple((ss,pp,s))387# RULE eq-diff1388if(s,differentFrom,o)inself.graphor(o,differentFrom,s)inself.graph:389s_e=self._get_resource_or_literal(s)390o_e=self._get_resource_or_literal(o)391self.add_error("'sameAs' and 'differentFrom' cannot be used on the same subject-object pair: (%s, %s)"%(s_e,o_e))392393# RULES eq-diff2 and eq-diff3394ifp==typeando==AllDifferent:395x=s396# the objects method are generators, we cannot simply concatenate them. So we turn the results397# into lists first. (Otherwise the body of the for loops should be repeated verbatim, which398# is silly and error prone...399m1=[iforiinself.graph.objects(x,members)]400m2=[iforiinself.graph.objects(x,distinctMembers)]401foryinm1+m2:402zis=self._list(y)403foriinxrange(0,len(zis)-1):404zi=zis[i]405forjinxrange(i+1,len(zis)-1):406zj=zis[j]407if((zi,sameAs,zj)inself.graphor(zj,sameAs,zi)inself.graph)andzi!=zj:408self.add_error("'sameAs' and 'AllDifferent' cannot be used on the same subject-object pair: (%s, %s)"%(zi,zj))
411"""412 Table 5: The Semantics of Axioms about Properties. Essentially, the prp-* rules.413 @param triple: triple to work on414 @param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.415 """416# In many of the 'if' branches, corresponding to rules in the document,417# the branch begins by a renaming of variables (eg, pp,c = s,o).418# There is no programming reasons for doing that, but by renaming the419# variables it becomes easier to compare the declarative rules420# in the document with the implementation421p,t,o=triple422423# RULE prp-ap424ifcycle_num==1andtinOWLRL_Annotation_properties:425self.store_triple((t,type,AnnotationProperty))426427# RULE prp-dom428ift==domain:429forx,yinself.graph.subject_objects(p):430self.store_triple((x,type,o))431432# RULE prp-rng433elift==range:434forx,yinself.graph.subject_objects(p):435self.store_triple((y,type,o))436437elift==type:438# RULE prp-fp439ifo==FunctionalProperty:440# Property axiom #3441forx,y1inself.graph.subject_objects(p):442fory2inself.graph.objects(x,p):443# Optimization: if the two resources are identical, the samAs is already444# taken place somewhere else, unnecessary to add it here445ify1!=y2:446self.store_triple((y1,sameAs,y2))447448# RULE prp-ifp449elifo==InverseFunctionalProperty:450forx1,yinself.graph.subject_objects(p):451forx2inself.graph.subjects(p,y):452# Optimization: if the two resources are identical, the samAs is already453# taken place somewhere else, unnecessary to add it here454ifx1!=x2:455self.store_triple((x1,sameAs,x2))456457# RULE prp-irp458elifo==IrreflexiveProperty:459forx,yinself.graph.subject_objects(p):460ifx==y:461self.add_error("Irreflexive property used on %s with %s"%(x,p))462463# RULE prp-symp464elifo==SymmetricProperty:465forx,yinself.graph.subject_objects(p):466self.store_triple((y,p,x))467468# RULE prp-asyp469elifo==AsymmetricProperty:470forx,yinself.graph.subject_objects(p):471if(y,p,x)inself.graph:472self.add_error("Erroneous usage of asymmetric property %s on %s and %s"%(p,x,y))473474# RULE prp-trp475elifo==TransitiveProperty:476forx,yinself.graph.subject_objects(p):477forzinself.graph.objects(y,p):478self.store_triple((x,p,z))479480#481# Breaking the order here, I take some additional rules here to the branch checking the type...482#483# RULE prp-adp484elifo==AllDisjointProperties:485x=p486foryinself.graph.objects(x,members):487pis=self._list(y)488foriinxrange(0,len(pis)-1):489pi=pis[i]490forjinxrange(i+1,len(pis)-1):491pj=pis[j]492forx,yinself.graph.subject_objects(pi):493if(x,pj,y)inself.graph:494self.add_error("Disjoint properties in an 'AllDisjointProperties' are not really disjoint: (%s, %s,%s) and (%s,%s,%s)"%(x,pi,y,x,pj,y))495496# RULE prp-spo1497elift==subPropertyOf:498p1,p2=p,o499forx,yinself.graph.subject_objects(p1):500self.store_triple((x,p2,y))501502# RULE prp-spo2503elift==propertyChainAxiom:504self._property_chain(p,o)505506# RULES prp-eqp1 and prp-eqp2507elift==equivalentProperty:508p1,p2=p,o509# Optimization: it clearly does not make sense to run these510# if the two properties are identical (a separate axiom511# does create an equivalent property relations among identical512# properties, too...)513ifp1!=p2:514# RULE prp-eqp1515forx,yinself.graph.subject_objects(p1):516self.store_triple((x,p2,y))517# RULE prp-eqp2518forx,yinself.graph.subject_objects(p2):519self.store_triple((x,p1,y))520521# RULE prp-pdw522elift==propertyDisjointWith:523p1,p2=p,o524forx,yinself.graph.subject_objects(p1):525if(x,p2,y)inself.graph:526self.add_error("Erroneous usage of disjoint properties %s and %s on %s and %s"%(p1,p2,x,y))527528529# RULES prp-inv1 and prp-inv2530elift==inverseOf:531p1,p2=p,o532# RULE prp-inv1533forx,yinself.graph.subject_objects(p1):534self.store_triple((y,p2,x))535# RULE prp-inv2536forx,yinself.graph.subject_objects(p2):537self.store_triple((y,p1,x))538539# RULE prp-key540elift==hasKey:541c,u=p,o542pis=self._list(u)543iflen(pis)>0:544forxinself.graph.subjects(type,c):545# "Calculate" the keys for 'x'. The complication is that there can be various combinations546# of the keys, and that is the structure one has to build up here...547#548# The final list will be a list of lists, with each constituents being the possible combinations of the549# key values.550# startup the list551finalList=[[zi]forziinself.graph.objects(x,pis[0])]552forpiinpis[1:]:553newList=[]554forziinself.graph.objects(x,pi):555newList=newList+[l+[zi]forlinfinalList]556finalList=newList557558# I am not sure this can happen, but better safe then sorry... ruling out559# the value lists whose length are not kosher560# (To be checked whether this is necessary in the first place)561valueList=[lforlinfinalListiflen(l)==len(pis)]562563# Now we can look for the y-s, to see if they have the same key values564foryinself.graph.subjects(type,c):565# rule out the existing equivalences566ifnot(y==xor(y,sameAs,x)inself.graphor(x,sameAs,y)inself.graph):567# 'calculate' the keys for the y values and see if there is a match568forvalsinvalueList:569same=True570foriinxrange(0,len(pis)-1):571if(y,pis[i],vals[i])notinself.graph:572same=False573# No use going with this property line574break575ifsame:576self.store_triple((x,sameAs,y))577# Look for the next 'y', this branch is finished, no reason to continue578break579580# RULES prp-npa1 and prp-npa2581elift==sourceIndividual:582x,i1=p,o583forp1inself.graph.objects(x,assertionProperty):584fori2inself.graph.objects(x,targetIndividual):585if(i1,p1,i2)inself.graph:586self.add_error("Negative (object) property assertion violated for: (%s, %s, %s)"%(i1,p1,i2))587fori2inself.graph.objects(x,targetValue):588if(i1,p1,i2)inself.graph:589self.add_error("Negative (datatype) property assertion violated for: (%s, %s, %s)"%(i1,p1,self.get_literal_value(i2)))
592"""593 Table 6: The Semantics of Classes. Essentially, the cls-* rules594 @param triple: triple to work on595 @param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.596 """597# In many of the 'if' branches, corresponding to rules in the document,598# the branch begins by a renaming of variables (eg, pp,c = s,o).599# There is no programming reasons for doing that, but by renaming the600# variables it becomes easier to compare the declarative rules601# in the document with the implementation602c,p,x=triple603604# RULE cls-nothing2605ifp==typeandx==Nothing:606self.add_error("%s is defined of type 'Nothing'"%c)607608# RULES cls-int1 and cls-int2609ifp==intersectionOf:610classes=self._list(x)611# RULE cls-int1612# Optimization: by looking at the members of class[0] right away one613# reduces the search spaces a bit. Individuals not in that class614# are without interest anyway615# I am not sure how empty lists are sanctioned, so having an extra check616# on that does not hurt..617iflen(classes)>0:618foryinself.graph.subjects(type,classes[0]):619ifFalsenotin[(y,type,cl)inself.graphforclinclasses[1:]]:620self.store_triple((y,type,c))621# RULE cls-int2622foryinself.graph.subjects(type,c):623forclinclasses:624self.store_triple((y,type,cl))625626# RULE cls-uni627elifp==unionOf:628forclinself._list(x):629foryinself.graph.subjects(type,cl):630self.store_triple((y,type,c))631632# RULE cls-comm633elifp==complementOf:634c1,c2=c,x635forx1inself.graph.subjects(type,c1):636if(x1,type,c2)inself.graph:637self.add_error("Violation of complementarity for classes %s and %s on element %s"%(c1,c2,x))638639# RULES cls-svf1 and cls=svf2640elifp==someValuesFrom:641xx,y=c,x642# RULE cls-svf1643# RULE cls-svf2644forppinself.graph.objects(xx,onProperty):645foru,vinself.graph.subject_objects(pp):646ify==Thingor(v,type,y)inself.graph:647self.store_triple((u,type,xx))648649# RULE cls-avf650elifp==allValuesFrom:651xx,y=c,x652forppinself.graph.objects(xx,onProperty):653foruinself.graph.subjects(type,xx):654forvinself.graph.objects(u,pp):655ifself.restriction_typing_check(v,y):656self.store_triple((v,type,y))657else:658self.add_error("Violation of type restriction for allValuesFrom in %s for datatype %s on value %s"%(pp,y,self._get_resource_or_literal(v)))659660# RULES cls-hv1 and cls-hv2661elifp==hasValue:662xx,y=c,x663forppinself.graph.objects(xx,onProperty):664# RULE cls-hv1665foruinself.graph.subjects(type,xx):666self.store_triple((u,pp,y))667# RULE cls-hv2668foruinself.graph.subjects(pp,y):669self.store_triple((u,type,xx))670671# RULES cls-maxc1 and cls-maxc1672elifp==maxCardinality:673# This one is a bit complicated, because the literals have been674# exchanged against bnodes...675#676# The construct should lead to an integer. Something may go wrong along the line677# leading to an exception...678val=-1679try:680val=int(self.literal_proxies.bnode_to_lit[x].lit)681except:682pass683xx=c684ifval==0:685# RULE cls-maxc1686forppinself.graph.objects(xx,onProperty):687foru,yinself.graph.subject_objects(pp):688# This should not occur:689if(u,type,xx)inself.graph:690self.add_error("Erroneous usage of maximum cardinality with %s, %s"%(xx,y))691elifval==1:692# RULE cls-maxc2693forppinself.graph.objects(xx,onProperty):694foru,y1inself.graph.subject_objects(pp):695if(u,type,xx)inself.graph:696fory2inself.graph.objects(u,pp):697ify1!=y2:698self.store_triple((y1,sameAs,y2))699700# RULES cls-maxqc1, cls-maxqc2, cls-maxqc3, cls-maxqc4701elifp==maxQualifiedCardinality:702# This one is a bit complicated, because the literals have been703# exchanged against bnodes...704#705# The construct should lead to an integer. Something may go wrong along the line706# leading to an exception...707val=-1708try:709val=int(self.literal_proxies.bnode_to_lit[x].lit)710except:711pass712xx=c713ifval==0:714# RULES cls-maxqc1 and cls-maxqc2 folded in one715forppinself.graph.objects(xx,onProperty):716forccinself.graph.objects(xx,onClass):717foru,yinself.graph.subject_objects(pp):718# This should not occur:719if(u,type,xx)inself.graphand(cc==Thingor(y,type,cc)inself.graph):720self.add_error("Erroneous usage of maximum qualified cardinality with %s, %s, and %s"%(xx,cc,y))721elifval==1:722# RULE cls-maxqc3 and cls-maxqc4 folded in one723forppinself.graph.objects(xx,onProperty):724forccinself.graph.objects(xx,onClass):725foru,y1inself.graph.subject_objects(pp):726if(u,type,xx)inself.graph:727ifcc==Thing:728fory2inself.graph.objects(u,pp):729ify1!=y2:730self.store_triple((y1,sameAs,y2))731else:732if(y1,type,cc)inself.graph:733fory2inself.graph.objects(u,pp):734ify1!=y2and(y2,type,cc)inself.graph:735self.store_triple((y1,sameAs,y2))736737# RULE cls-oo738elifp==oneOf:739foryinself._list(x):740self.store_triple((y,type,c))
743"""744 Table 7: Class Axioms. Essentially, the cax-* rules.745 @param triple: triple to work on746 @param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.747 """748# In many of the 'if' branches, corresponding to rules in the document,749# the branch begins by a renaming of variables (eg, pp,c = s,o).750# There is no programming reasons for doing that, but by renaming the751# variables it becomes easier to compare the declarative rules752# in the document with the implementation753c1,p,c2=triple754# RULE cax-sco755ifp==subClassOf:756# Other axioms sets classes to be subclasses of themselves, to one can optimize the trivial case757ifc1!=c2:758forxinself.graph.subjects(type,c1):759self.store_triple((x,type,c2))760761# RULES cax-eqc1 and cax-eqc1762# Other axioms set classes to be equivalent to themselves, one can optimize the trivial case763elifp==equivalentClassandc1!=c2:764# RULE cax-eqc1765forxinself.graph.subjects(type,c1):766self.store_triple((x,type,c2))767# RULE cax-eqc1768forxinself.graph.subjects(type,c2):769self.store_triple((x,type,c1))770771# RULE cax-dw772elifp==disjointWith:773forxinself.graph.subjects(type,c1):774if(x,type,c2)inself.graph:775self.add_error("Disjoint classes %s and %s have a common individual %s"%(c1,c2,self._get_resource_or_literal(x)))776777# RULE cax-adc778elifp==typeandc2==AllDisjointClasses:779x=c1780foryinself.graph.objects(x,members):781classes=self._list(y)782iflen(classes)>0:783foriinxrange(0,len(classes)-1):784cl1=classes[i]785forzinself.graph.subjects(type,cl1):786forcl2inclasses[(i+1):]:787if(z,type,cl2)inself.graph:788self.add_error("Disjoint classes %s and %s have a common individual %s"%(cl1,cl2,z))
791"""792 Table 9: The Semantics of Schema Vocabulary. Essentially, the scm-* rules793 @param triple: triple to work on794 @param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.795 """796# In many of the 'if' branches, corresponding to rules in the document,797# the branch begins by a renaming of variables (eg, pp,c = s,o).798# There is no programming reasons for doing that, but by renaming the799# variables it becomes easier to compare the declarative rules800# in the document with the implementation801s,p,o=triple802803# RULE scm-cls804ifp==typeando==OWLClass:805c=s806self.store_triple((c,subClassOf,c))807self.store_triple((c,equivalentClass,c))808self.store_triple((c,subClassOf,Thing))809self.store_triple((Nothing,subClassOf,c))810811# RULE scm-sco812# Rule scm-eqc2813elifp==subClassOf:814c1,c2=s,o815# RULE scm-sco816# Optimize out the trivial identity case (set elsewhere already)817ifc1!=c2:818forc3inself.graph.objects(c2,subClassOf):819# Another axiom already sets that...820ifc1!=c3:self.store_triple((c1,subClassOf,c3))821# RULE scm-eqc2822if(c2,subClassOf,c1)inself.graph:823self.store_triple((c1,equivalentClass,c2))824825# RULE scm-eqc826elifp==equivalentClassands!=o:827c1,c2=s,o828self.store_triple((c1,subClassOf,c2))829self.store_triple((c2,subClassOf,c1))830831# RULE scm-op and RULE scm-dp folded together832# There is a bit of a cheating here: 'Property' is not, strictly speaking, in the rule set!833elifp==typeand(o==ObjectPropertyoro==DatatypePropertyoro==Property):834pp=s835self.store_triple((pp,subPropertyOf,pp))836self.store_triple((pp,equivalentProperty,pp))837838# RULE scm-spo839# RULE scm-eqp2840elifp==subPropertyOfands!=o:841p1,p2=s,o842# Optimize out the trivial identity case (set elsewhere already)843# RULE scm-spo844ifp1!=p2:845forp3inself.graph.objects(p2,subPropertyOf):846ifp1!=p3:847self.store_triple((p1,subPropertyOf,p3))848849#RULE scm-eqp2850if(p2,subPropertyOf,p1)inself.graph:851self.store_triple((p1,equivalentProperty,p2))852853# RULE scm-eqp854# Optimize out the trivial identity case (set elsewhere already)855elifp==equivalentPropertyands!=o:856p1,p2=s,o857self.store_triple((p1,subPropertyOf,p2))858self.store_triple((p2,subPropertyOf,p1))859860# RULES scm-dom1 and scm-dom2861elifp==domain:862# RULE scm-dom1863pp,c1=s,o864for(_x,_y,c2)inself.graph.triples((c1,subClassOf,None)):865ifc1!=c2:866self.store_triple((pp,domain,c2))867# RULE scm-dom1868p2,c=s,o869for(p1,_x,_y)inself.graph.triples((None,subPropertyOf,p2)):870ifp1!=p2:871self.store_triple((p1,domain,c))872873# RULES scm-rng1 and scm-rng2874elifp==range:875# RULE scm-rng1876pp,c1=s,o877for(_x,_y,c2)inself.graph.triples((c1,subClassOf,None)):878ifc1!=c2:self.store_triple((pp,range,c2))879# RULE scm-rng1880p2,c=s,o881for(p1,_x,_y)inself.graph.triples((None,subPropertyOf,p2)):882ifp1!=p2:self.store_triple((p1,range,c))883884# RULE scm-hv885elifp==hasValue:886c1,i=s,o887forp1inself.graph.objects(c1,onProperty):888forc2inself.graph.subjects(hasValue,i):889forp2inself.graph.objects(c2,onProperty):890if(p1,subPropertyOf,p2)inself.graph:891self.store_triple((c1,subClassOf,c2))892893# RULES scm-svf1 and scm-svf2894elifp==someValuesFrom:895# RULE scm-svf1896c1,y1=s,o897forppinself.graph.objects(c1,onProperty):898forc2inself.graph.subjects(onProperty,pp):899fory2inself.graph.objects(c2,someValuesFrom):900if(y1,subClassOf,y2)inself.graph:901self.store_triple((c1,subClassOf,c2))902903# RULE scm-svf2904c1,y=s,o905forp1inself.graph.objects(c1,onProperty):906forc2inself.graph.subjects(someValuesFrom,y):907forp2inself.graph.objects(c2,onProperty):908if(p1,subPropertyOf,p2)inself.graph:909self.store_triple((c1,subClassOf,c2))910911# RULES scm-avf1 and scm-avf2912elifp==allValuesFrom:913# RULE scm-avf1914c1,y1=s,o915forppinself.graph.objects(c1,onProperty):916forc2inself.graph.subjects(onProperty,pp):917fory2inself.graph.objects(c2,allValuesFrom):918if(y1,subClassOf,y2)inself.graph:919self.store_triple((c1,subClassOf,c2))920921# RULE scm-avf2922c1,y=s,o923forp1inself.graph.objects(c1,onProperty):924forc2inself.graph.subjects(allValuesFrom,y):925forp2inself.graph.objects(c2,onProperty):926if(p1,subPropertyOf,p2)inself.graph:927self.store_triple((c2,subClassOf,c1))928929# RULE scm-int930elifp==intersectionOf:931c,x=s,o932forciinself._list(x):933self.store_triple((c,subClassOf,ci))934935# RULE scm-uni936elifp==unionOf:937c,x=s,o938forciinself._list(x):939self.store_triple((ci,subClassOf,c))
OWL 2 RL Semantics class, ie, implementation of the OWL 2 RL closure
graph.
Note that the module does not implement the so called Datatype
entailment rules, simply because the underlying RDFLib does not implement
the datatypes (ie, RDFLib will not make the literal "1.00" and
"1.00000" identical, although even with all the ambiguities on
datatypes, this should be made equal...). Also, the so-called
extensional entailment rules (Section 7.3.1 in the RDF Semantics
document) have not been implemented either.
The comments and references to the various rule follow the names as
used in the OWL 2 RL document.
_one_time_rules_datatypes(self)
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to
add these in a cycle.
one_time_rules(self)
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to
add these in a cycle.
Helping method to check whether a type statement is in line with a
possible restriction. This method is invoked by rule "cls-avf"
before setting a type on an allValuesFrom restriction.
The method is a placeholder at this level. It is typically implemented
by subclasses for extra checks, eg, for datatype facet checks.
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to add
these in a cycle. These are performed by this method that is invoked only
once at the beginning of the process.
These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2,
dt-eq, dt-diff.
Note, however, that the dt-* are executed only partially, limited by
the possibilities offered by RDFLib. These may not cover all the edge
cases of OWL RL. Especially, dt-not-type has not (yet?) been implemented
(I wonder whether RDFLib should not raise exception for those
anyway...
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to add
these in a cycle. These are performed by this method that is invoked only
once at the beginning of the process.
These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2,
dt-eq, dt-diff.
Go through the various rule groups, as defined in the OWL-RL profile
text and implemented via local methods. (The calling cycle takes every
tuple in the graph.)
Parameters:
t - a triple (in the form of a tuple)
cycle_num - which cycle are we in, starting with 1. This value is forwarded
to all local rules; it is also used locally to collect the bnodes
in the graph.
Implementation of the property chain axiom, invoked from inside the
property axiom handler. This is the implementation of rule prp-spo2,
taken aside for an easier readability of the code.
Extension to OWL 2 RL, ie, some additional rules added to the system
from OWL 2 Full. It is implemented through the OWLRL_Extension class, whose reference has to be passed
to the relevant semantic class (ie, either the OWL 2 RL or the combined
closure class) as an 'extension'.
According to the OWL spec: numerator must be an integer, denominator a
positive integer (ie, xsd['integer'] type), and the denominator should
not have a '+' sign.
Parameters:
v - the literal string defined as boolean @return corresponding
Rational value
61"""Converting a string to a rational. 62 63 According to the OWL spec: numerator must be an integer, denominator a positive integer (ie, xsd['integer'] type), and the denominator 64 should not have a '+' sign. 65 66 @param v: the literal string defined as boolean 67 @return corresponding Rational value 68 @rtype: Rational 69 @raise ValueError: invalid rational string literal 70 """ 71try: 72r=v.split('/') 73iflen(r)==2: 74n_str=r[0] 75d_str=r[1] 76else: 77n_str=r[0] 78d_str="1" 79ifd_str.strip()[0]=='+': 80raiseValueError("Invalid Rational literal value %s"%v) 81else: 82returnRational(AltXSDToPYTHON[ns_xsd["integer"]](n_str),AltXSDToPYTHON[ns_xsd["positiveInteger"]](d_str)) 83except: 84raiseValueError("Invalid Rational literal value %s"%v)
91""" 92 Additional rules to OWL 2 RL. The initialization method also adds the C{owl:rational} datatype to the set of allowed 93 datatypes with the L{_strToRational} function as a conversion between the literal form and a Rational. The C{xsd:decimal} datatype 94 is also set to be a subclass of C{owl:rational}. Furthermore, the restricted datatypes are extracted from the graph 95 using a L{separate method in a different module<RestrictedDatatype.extract_faceted_datatypes>}, and all those datatypes are also 96 added to the set of allowed datatypes. In the case of the restricted datatypes and extra subsumption relationship is set up 97 between the restricted and the base datatypes. 98 99 @cvar extra_axioms: additional axioms that have to be added to the deductive closure (in case the axiomatic triples are required)100 @ivar restricted_datatypes : list of the datatype restriction101 @type restricted_datatypes : array of L{restricted datatype<RestrictedDatatype.RestrictedDatatype>} instances102 """103extra_axioms=[104(hasSelf,rdfType,Property),105(hasSelf,domain,Property),106]
134"""135 A one-time-rule: all the literals are checked whether they are (a) of type restricted by a136 faceted (restricted) datatype and (b) whether137 the corresponding value abides to the restrictions. If true, then the literal gets an extra138 tag as being of type of the restricted datatype, too.139 """140forrtinself.restricted_datatypes:141# This is a recorded restriction. The base type is:142base_type=rt.base_type143# Look through all the literals; more precisely, through the144# proxy bnodes:145forbninself.literal_proxies.bnode_to_lit:146# check if the type of that proxy matches. Note that this also takes147# into account the subsumption datatypes, that have been taken148# care of by the 'regular' OWL RL process149if(bn,rdfType,base_type)inself.graph:150# yep, that is a good candidate!151lt=self.literal_proxies.bnode_to_lit[bn]152try:153# the conversion or the check may go wrong and raise an exception; then simply move on154value=lt.lit.toPython()155ifrt.checkValue(value):156# yep, this is also of type 'rt'157self.store_triple((bn,rdfType,rt.datatype))158except:159continue
162"""Helping method to check whether a type statement is in line with a possible163 restriction. This method is invoked by rule "cls-avf" before setting a type164 on an allValuesFrom restriction.165166 The method is a placeholder at this level. It is typically implemented by subclasses for167 extra checks, eg, for datatype facet checks.168 @param v: the resource that is to be 'typed'169 @param t: the targeted type (ie, Class)170 @return: boolean171 """172# Look through the restricted datatypes to see if 't' corresponds to one of those...173# There are a bunch of possible exceptions here with datatypes, but they can all174# be ignored...175try:176forrtinself.restricted_datatypes:177ifrt.datatype==t:178# bingo179ifvinself.literal_proxies.bnode_to_lit:180returnrt.checkValue(self.literal_proxies.bnode_to_lit[v].lit.toPython())181else:182returnTrue183# if we got here, no restriction applies184returnTrue185except:186returnTrue
189"""190 This method is invoked only once at the beginning, and prior of, the forward chaining process.191192 At present, only the L{subsumption} of restricted datatypes<_subsume_restricted_datatypes>} is performed.193 """194RDFS_OWLRL_Semantics.one_time_rules(self)195# it is important to flush the triples at this point, because196# the handling of the restriction datatypes rely on the datatype197# subsumption triples added by the superclass198self.flush_stored_triples()199self._subsume_restricted_datatypes()
202"""203 Add the L{extra axioms<OWLRL_Extension.extra_axioms>}, related to the self restrictions.204 """205RDFS_OWLRL_Semantics.add_axioms(self)206fortinself.extra_axioms:self.graph.add(t)
209"""210 Go through the additional rules implemented by this module.211 @param t: a triple (in the form of a tuple)212 @param cycle_num: which cycle are we in, starting with 1. This value is forwarded to all local rules; it is also used213 locally to collect the bnodes in the graph.214 """215RDFS_OWLRL_Semantics.rules(self,t,cycle_num)216z,q,x=t217ifq==hasSelf:218forpinself.graph.objects(z,onProperty):219foryinself.graph.subjects(rdfType,z):220self.store_triple((y,p,y))221fory1,y2inself.graph.subject_objects(p):222ify1==y2:223self.store_triple((y1,rdfType,z))
228"""229 This Class adds only one feature to L{OWLRL_Extension}: to initialize with a trimming flag set to C{True} by default. 230231 This is pretty experimental and probably contentious: this class I{removes} a number of triples from the Graph at the very end of the processing steps.232 These triples are either the by-products of the deductive closure calculation or are axiom like triples that are added following the rules of OWL 2 RL.233 While these triples I{are necessary} for the correct inference of really 'useful' triples, they may not be of interest for the application234 for the end result. The triples that are removed are of the form (following a SPARQL-like notation):235236 - C{?x owl:sameAs ?x}, C{?x rdfs:subClassOf ?x}, C{?x rdfs:subPropertyOf ?x}, C{?x owl:equivalentClass ?x} type triples237 - C{?x rdfs:subClassOf rdf:Resource}, C{?x rdfs:subClassOf owl:Thing}, C{?x rdf:type rdf:Resource}, C{owl:Nothing rdfs:subClassOf ?x} type triples238 - For a datatype that does I{not} appear explicitly in a type assignments (ie, in a C{?x rdf:type dt}) the corresponding C{dt rdf:type owl:Datatype} and C{dt rdf:type owl:DataRange} triples, as well as the disjointness statements with other datatypes239 - annotation property axioms240 - a number of axiomatic triples on C{owl:Thing}, C{owl:Nothing} and C{rdf:Resource} (eg, C{owl:Nothing rdf:type owl:Class}, C{owl:Thing owl:equivalentClass rdf:Resource}, etc.)241242 Trimming is the only feature of this class, done in the L{post_process} step. If users extend L{OWLRL_Extension}, this class can be safely mixed in via multiple243 inheritance.244 """
Additional rules to OWL 2 RL. The initialization method also adds the
owl:rational datatype to the set of allowed datatypes with
the _strToRational function as a
conversion between the literal form and a Rational. The
xsd:decimal datatype is also set to be a subclass of
owl:rational. Furthermore, the restricted datatypes are
extracted from the graph using a separate method in a different module, and all those
datatypes are also added to the set of allowed datatypes. In the case of
the restricted datatypes and extra subsumption relationship is set up
between the restricted and the base datatypes.
_subsume_restricted_datatypes(self)
A one-time-rule: all the literals are checked whether they are (a) of
type restricted by a faceted (restricted) datatype and (b) whether
the corresponding value abides to the restrictions.
extra_axioms = [(rdflib.term.URIRef(u'http://www.w3.org/2002/0...
additional axioms that have to be added to the deductive closure (in
case the axiomatic triples are required)
A one-time-rule: all the literals are checked whether they are (a) of
type restricted by a faceted (restricted) datatype and (b) whether the
corresponding value abides to the restrictions. If true, then the literal
gets an extra tag as being of type of the restricted datatype, too.
This method is invoked only once at the beginning, and prior of, the forward chaining process.
At present, only the L{subsumption} of restricted datatypes<_subsume_restricted_datatypes>} is performed.
Helping method to check whether a type statement is in line with a
possible restriction. This method is invoked by rule "cls-avf"
before setting a type on an allValuesFrom restriction.
The method is a placeholder at this level. It is typically implemented
by subclasses for extra checks, eg, for datatype facet checks.
Go through the additional rules implemented by this module.
Parameters:
t - a triple (in the form of a tuple)
cycle_num - which cycle are we in, starting with 1. This value is forwarded
to all local rules; it is also used locally to collect the bnodes
in the graph.
This Class adds only one feature to OWLRL_Extension: to initialize with a trimming flag set
to True by default.
This is pretty experimental and probably contentious: this class
removes a number of triples from the Graph at the very end of the
processing steps. These triples are either the by-products of the
deductive closure calculation or are axiom like triples that are added
following the rules of OWL 2 RL. While these triples are necessary
for the correct inference of really 'useful' triples, they may not be of
interest for the application for the end result. The triples that are
removed are of the form (following a SPARQL-like notation):
For a datatype that does not appear explicitly in a type
assignments (ie, in a ?x rdf:type dt) the corresponding
dt rdf:type owl:Datatype and dt rdf:type
owl:DataRange triples, as well as the disjointness statements
with other datatypes
annotation property axioms
a number of axiomatic triples on owl:Thing,
owl:Nothing and rdf:Resource (eg,
owl:Nothing rdf:type owl:Class, owl:Thing
owl:equivalentClass rdf:Resource, etc.)
Trimming is the only feature of this class, done in the post_process step. If users extend OWLRL_Extension, this class can be safely mixed in via
multiple inheritance.
1#!/d/Bin/Python/python.exe 2# -*- coding: utf-8 -*- 3# 4""" 5This module is brute force implementation of the RDFS semantics on the top of RDFLib (with some caveats, see in the introductory text). 6 7 8@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 9@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 10@organization: U{World Wide Web Consortium<http://www.w3.org>} 11@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 12 13""" 14 15__author__='Ivan Herman' 16__contact__='Ivan Herman, ivan@w3.org' 17__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 18 19fromRDFClosure.RDFSimportProperty,type 20fromRDFClosure.RDFSimportResource,Class,subClassOf,subPropertyOf,domain,range 21fromRDFClosure.RDFSimportLiteral,ContainerMembershipProperty,member,Datatype 22# noinspection PyPep8Naming 23fromRDFClosure.RDFSimportRDFNSasns_rdf 24 25fromRDFClosure.ClosureimportCore 26fromRDFClosure.AxiomaticTriplesimportRDFS_Axiomatic_Triples,RDFS_D_Axiomatic_Triples 27 28 29###################################################################################################### 30 31## RDFS Semantics class 32# noinspection PyPep8Naming
34"""RDFS Semantics class, ie, implementation of the RDFS closure graph. 35 36 Note that the module does I{not} implement the so called Datatype entailment rules, simply because the underlying RDFLib does 37 not implement the datatypes (ie, RDFLib will not make the literal "1.00" and "1.00000" identical, although 38 even with all the ambiguities on datatypes, this I{should} be made equal...). Also, the so-called extensional entailment rules 39 (Section 7.3.1 in the RDF Semantics document) have not been implemented either. 40 41 The comments and references to the various rule follow the names as used in the U{RDF Semantics document<http://www.w3.org/TR/rdf-mt/>}. 42 """
44""" 45 @param graph: the RDF graph to be extended 46 @type graph: rdflib.Graph 47 @param axioms: whether (non-datatype) axiomatic triples should be added or not 48 @type axioms: bool 49 @param daxioms: whether datatype axiomatic triples should be added or not 50 @type daxioms: bool 51 @param rdfs: whether RDFS inference is also done (used in subclassed only) 52 @type rdfs: boolean 53 """ 54Core.__init__(self,graph,axioms,daxioms,rdfs)
69"""This is not really complete, because it just uses the comparison possibilities that rdflib provides.""" 70literals=self.literal_proxies.lit_to_bnode.keys() 71# #1 72forltinliterals: 73iflt.dtisnotNone: 74self.graph.add((self.literal_proxies.lit_to_bnode[lt],type,lt.dt)) 75 76fortinRDFS_D_Axiomatic_Triples: 77self.graph.add(t)
81"""Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only 82 once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once 83 at the beginning of the process. 84 85 In this case this is related to a 'hidden' same as rules on literals with identical values (though different lexical values) 86 """ 87# There is also a hidden sameAs rule in RDF Semantics: if a literal appears in a triple, and another one has the same value, 88# then the triple should be duplicated with the other value. 89forlt1inself.literal_proxies.lit_to_bnode.keys(): 90forlt2inself.literal_proxies.lit_to_bnode.keys(): 91iflt1!=lt2: 92try: 93lt1_d=lt1.lit.toPython() 94lt2_d=lt2.lit.toPython() 95iflt1_d==lt2_d: 96# In OWL, this line is simply stating a sameAs for the corresponding BNodes, and then let 97# the usual rules take effect. In RDFS this is not possible, so the sameAs rule is, essentially 98# replicated... 99bn1=self.literal_proxies.lit_to_bnode[lt1]100bn2=self.literal_proxies.lit_to_bnode[lt2]101for(s,p,o)inself.graph.triples((None,None,bn1)):102self.graph.add((s,p,bn2))103except:104# there may be a problem with one of the python conversions; the rule is imply ignored105#raise e106pass
RDFS Semantics class, ie, implementation of the RDFS closure
graph.
Note that the module does not implement the so called Datatype
entailment rules, simply because the underlying RDFLib does not implement
the datatypes (ie, RDFLib will not make the literal "1.00" and
"1.00000" identical, although even with all the ambiguities on
datatypes, this should be made equal...). Also, the so-called
extensional entailment rules (Section 7.3.1 in the RDF Semantics
document) have not been implemented either.
The comments and references to the various rule follow the names as
used in the RDF
Semantics document.
one_time_rules(self)
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to
add these in a cycle.
Some of the rules in the rule set are axiomatic in nature, meaning
that they really have to be added only once, there is no reason to add
these in a cycle. These are performed by this method that is invoked only
once at the beginning of the process.
In this case this is related to a 'hidden' same as rules on literals
with identical values (though different lexical values)
In the case above the system can then infer that ex:q is
also of type ex:RE.
Datatype restrictions are used by the OWL
RL Extensions extension class.
The implementation is not 100% complete. Some things that an ideal
implementation should do are not done yet like:
checking whether a facet is of a datatype that is allowed for that
facet
handling of non-literals in the facets (ie, if the resource is
defined to be of type literal, but whose value is defined via a
separate 'owl:sameAs' somewhere else)
_lang_range_check(range,
lang)
Implementation of the extended filtering algorithm, as defined in
point 3.3.2, of RFC 4647, on matching language ranges and language
tags.
This method is used to convert a string to a value with facet
checking. RDF Literals are converted to Python values using this method;
if there is a problem, an exception is raised (and caught higher up to
generate an error message).
The method is the equivalent of all the methods in the DatatypeHandling module, and is registered to the system
run time, as new restricted datatypes are discovered.
(Technically, the registration is done via a lambda v:
_lit_to_value(self,v) setting from within a RestrictedDatatype instance)
Implementation of the extended filtering algorithm, as defined in
point 3.3.2, of RFC 4647, on matching language ranges and language
tags. Needed to handle the rdf:PlainLiteral datatype.
1# -*- coding: utf-8 -*- 2# 3""" 4Module to datatype restrictions, ie, data ranges. 5 6The module implements the following aspects of datatype restrictions: 7 8 - a new datatype is created run-time and added to the allowed and accepted datatypes; literals are checked whether they abide to the restrictions 9 - the new datatype is defined to be a 'subClass' of the restricted datatype 10 - literals of the restricted datatype and that abide to the restrictions defined by the facets are also assigned to be of the new type 11 12The last item is important to handle the following structures:: 13 ex:RE a owl:Restriction ; 14 owl:onProperty ex:p ; 15 owl:someValuesFrom [ 16 a rdfs:Datatype ; 17 owl:onDatatype xsd:string ; 18 owl:withRestrictions ( 19 [ xsd:minLength "3"^^xsd:integer ] 20 [ xsd:maxLength "6"^^xsd:integer ] 21 ) 22 ] 23 . 24 ex:q ex:p "abcd"^^xsd:string. 25In the case above the system can then infer that C{ex:q} is also of type C{ex:RE}. 26 27Datatype restrictions are used by the L{OWL RL Extensions<OWLRLExtras.OWLRL_Extension>} extension class. 28 29The implementation is not 100% complete. Some things that an ideal implementation should do are not done yet like: 30 31 - checking whether a facet is of a datatype that is allowed for that facet 32 - handling of non-literals in the facets (ie, if the resource is defined to be of type literal, but whose value 33 is defined via a separate 'owl:sameAs' somewhere else) 34 35@requires: U{RDFLib<https://github.com/RDFLib/rdflib>}, 4.0.0 and higher 36@license: This software is available for use under the U{W3C Software License<http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231>} 37@organization: U{World Wide Web Consortium<http://www.w3.org>} 38@author: U{Ivan Herman<a href="http://www.w3.org/People/Ivan/">} 39 40""" 41 42__author__='Ivan Herman' 43__contact__='Ivan Herman, ivan@w3.org' 44__license__=u'W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231' 45 46importre 47 48fromOWLimport* 49# noinspection PyPep8Naming,PyPep8Naming 50fromOWLimportOWLNSasns_owl 51fromRDFClosure.RDFSimportDatatype 52fromRDFClosure.RDFSimporttype 53# noinspection PyPep8Naming 54fromRDFClosure.RDFSimportRDFNSasns_rdf 55 56fromrdflibimportLiteralasrdflibLiteral 57# noinspection PyPep8Naming 58fromrdflib.namespaceimportXSDasns_xsd 59 60fromDatatypeHandlingimportAltXSDToPYTHON 61 62#: Constant for datatypes using min, max (inclusive and exclusive): 63MIN_MAX=0 64#: Constant for datatypes using length, minLength, and maxLength (and nothing else) 65LENGTH=1 66#: Constant for datatypes using length, minLength, maxLength, and pattern 67LENGTH_AND_PATTERN=2 68#: Constant for datatypes using length, minLength, maxLength, pattern, and lang range 69LENGTH_PATTERN_LRANGE=3 70 71#: Dictionary of all the datatypes, keyed by category 72Datatypes_per_facets={ 73MIN_MAX:[ns_owl["rational"],ns_xsd["decimal"],ns_xsd["integer"], 74ns_xsd["nonNegativeInteger"],ns_xsd["nonPositiveInteger"], 75ns_xsd["positiveInteger"],ns_xsd["negativeInteger"], 76ns_xsd["long"],ns_xsd["short"],ns_xsd["byte"], 77ns_xsd["unsignedLong"],ns_xsd["unsignedInt"],ns_xsd["unsignedShort"],ns_xsd["unsignedByte"], 78ns_xsd["double"],ns_xsd["float"], 79ns_xsd["dateTime"],ns_xsd["dateTimeStamp"],ns_xsd["time"],ns_xsd["date"] 80], 81LENGTH:[ns_xsd["hexBinary"],ns_xsd["base64Binary"]], 82LENGTH_AND_PATTERN:[ns_xsd["anyURI"],ns_xsd["string"],ns_xsd["NMTOKEN"],ns_xsd["Name"],ns_xsd["NCName"], 83ns_xsd["language"],ns_xsd["normalizedString"] 84], 85LENGTH_PATTERN_LRANGE:[ns_rdf["plainLiteral"]] 86} 87 88#: a simple list containing C{all} datatypes that may have a facet 89facetable_datatypes=reduce(lambdax,y:x+y,Datatypes_per_facets.values()) 90 91####################################################################################################### 92
94""" 95 This method is used to convert a string to a value with facet checking. RDF Literals are converted to 96 Python values using this method; if there is a problem, an exception is raised (and caught higher 97 up to generate an error message). 98 99 The method is the equivalent of all the methods in the L{DatatypeHandling} module, and is registered100 to the system run time, as new restricted datatypes are discovered.101102 (Technically, the registration is done via a C{lambda v: _lit_to_value(self,v)} setting from within a103 L{RestrictedDatatype} instance)104 @param dt: faceted datatype105 @type dt: L{RestrictedDatatype}106 @param v: literal to be converted and checked107 @raise ValueError: invalid literal value108 """109# This may raise an exception...110value=dt.converter(v)111112# look at the different facet categories and try to find which is113# is, if any, the one that is of relevant for this literal114forcatinDatatypes_per_facets.keys():115ifdt.base_typeinDatatypes_per_facets[cat]:116# yep, this is to be checked.117ifnotdt.checkValue(value):118raiseValueError("Literal value %s does not fit the faceted datatype %s"%(v,dt))119# got here, everything should be fine120returnvalue
124"""125 Implementation of the extended filtering algorithm, as defined in point 3.3.2,126 of U{RFC 4647<http://www.rfc-editor.org/rfc/rfc4647.txt>}, on matching language ranges and language tags.127 Needed to handle the C{rdf:PlainLiteral} datatype.128 @param range: language range129 @param lang: language tag130 @rtype: boolean131 """132def_match(r,l):133"""Matching of a range and language item: either range is a wildcard or the two are equal134 @param r: language range item135 @param l: language tag item136 @rtype: boolean137 """138returnr=='*'orr==l
167"""168 Extractions of restricted (ie, faceted) datatypes from the graph.169 @param core: the core closure instance that is being handled170 @type core: L{Closure.Core}171 @param graph: RDFLib graph172 @return: array of L{RestrictedDatatype} instances173 """174retval=[]175fordtypeingraph.subjects(type,Datatype):176base_type=None177facets=[]178try:179base_types=[xforxingraph.objects(dtype,onDatatype)]180iflen(base_types)>0:181iflen(base_types)>1:182raiseException("Several base datatype for the same restriction %s"%dtype)183else:184base_type=base_types[0]185ifbase_typeinfacetable_datatypes:186rlists=[xforxingraph.objects(dtype,withRestrictions)]187iflen(rlists)>1:188raiseException("More than one facet lists for the same restriction %s"%dtype)189eliflen(rlists)>0:190final_facets=[]191forringraph.items(rlists[0]):192for(facet,lit)ingraph.predicate_objects(r):193ifisinstance(lit,rdflibLiteral):194# the python value of the literal should be extracted195# note that this call may lead to an exception, but that is fine,196# it is caught some lines below anyway...197try:198iflit.datatypeisNoneorlit.datatype==ns_xsd["string"]:199final_facets.append((facet,str(lit)))200else:201final_facets.append((facet,AltXSDToPYTHON[lit.datatype](str(lit))))202exceptException,msg:203core.add_error(msg)204continue205# We do have everything we need:206new_datatype=RestrictedDatatype(dtype,base_type,final_facets)207retval.append(new_datatype)208exceptException,msg:209#import sys210#print sys.exc_info()211#print sys.exc_type212#print sys.exc_value213#print sys.exc_traceback214core.add_error(msg)215continue216returnretval
221"""An 'abstract' superclass for datatype restrictions. The instance variables listed here are222 used in general, without the specificities of the concrete restricted datatype.223224 This module defines the L{RestrictedDatatype} class that corresponds to the datatypes and their restrictions225 defined in the OWL 2 standard. Other modules may subclass this class to define new datatypes with restrictions.226 @ivar type_uri : the URI for this datatype227 @ivar base_type : URI of the datatype that is restricted228 @ivar toPython : function to convert a Literal of the specified type to a Python value. 229 """
236"""237 Check whether the (python) value abides to the constraints defined by the current facets.238 @param value: the value to be checked239 @rtype: boolean240 """241raiseException("This class should not be used by itself, only via its subclasses!")
245"""246 Implementation of a datatype with facets, ie, datatype with restrictions.247248 @ivar datatype : the URI for this datatype249 @ivar base_type : URI of the datatype that is restricted250 @ivar converter : method to convert a literal of the base type to a Python value (drawn from L{DatatypeHandling.AltXSDToPYTHON})251 @ivar minExclusive : value for the C{xsd:minExclusive} facet, initialized to C{None} and set to the right value if a facet is around252 @ivar minInclusive : value for the C{xsd:minInclusive} facet, initialized to C{None} and set to the right value if a facet is around253 @ivar maxExclusive : value for the C{xsd:maxExclusive} facet, initialized to C{None} and set to the right value if a facet is around254 @ivar maxInclusive : value for the C{xsd:maxInclusive} facet, initialized to C{None} and set to the right value if a facet is around255 @ivar minLength : value for the C{xsd:minLength} facet, initialized to C{None} and set to the right value if a facet is around256 @ivar maxLength : value for the C{xsd:maxLength} facet, initialized to C{None} and set to the right value if a facet is around257 @ivar length : value for the C{xsd:length} facet, initialized to C{None} and set to the right value if a facet is around258 @ivar pattern : array of patterns for the C{xsd:pattern} facet, initialized to C{[]} and set to the right value if a facet is around259 @ivar langRange : array of language ranges for the C{rdf:langRange} facet, initialized to C{[]} and set to the right value if a facet is around260 @ivar check_methods : list of class methods that are relevant for the given C{base_type}261 @ivar toPython : function to convert a Literal of the specified type to a Python value. Is defined by C{lambda v : _lit_to_value(self, v)}, see L{_lit_to_value} 262 """263
323"""324 Check whether the (python) value abides to the constraints defined by the current facets.325 @param value: the value to be checked326 @rtype: boolean327 """328formethodinself.check_methods:329ifnotmethod(self,value):330returnFalse331returnTrue
334"""335 Check the (python) value against min exclusive facet.336 @param value: the value to be checked337 @rtype: boolean338 """339ifself.minExclusiveisnotNone:340returnself.minExclusive<value341else:342returnTrue
345"""346 Check the (python) value against min inclusive facet.347 @param value: the value to be checked348 @rtype: boolean349 """350ifself.minInclusiveisnotNone:351returnself.minInclusive<=value352else:353returnTrue
356"""357 Check the (python) value against max exclusive facet.358 @param value: the value to be checked359 @rtype: boolean360 """361ifself.maxExclusiveisnotNone:362returnvalue<self.maxExclusive363else:364returnTrue
367"""368 Check the (python) value against max inclusive facet.369 @param value: the value to be checked370 @rtype: boolean371 """372ifself.maxInclusiveisnotNone:373returnvalue<=self.maxInclusive374else:375returnTrue
378"""379 Check the (python) value against minimum length facet.380 @param value: the value to be checked381 @rtype: boolean382 """383ifisinstance(value,rdflibLiteral):384val=str(value)385else:386val=value387ifself.minLengthisnotNone:388returnself.minLength<=len(val)389else:390returnTrue
393"""394 Check the (python) value against maximum length facet.395 @param value: the value to be checked396 @rtype: boolean397 """398ifisinstance(value,rdflibLiteral):399val=str(value)400else:401val=value402ifself.maxLengthisnotNone:403returnself.maxLength>=len(val)404else:405returnTrue
408"""409 Check the (python) value against exact length facet.410 @param value: the value to be checked411 @rtype: boolean412 """413ifisinstance(value,rdflibLiteral):414val=str(value)415else:416val=value417ifself.lengthisnotNone:418returnself.length==len(val)419else:420returnTrue
423"""424 Check the (python) value against array of regular expressions.425 @param value: the value to be checked426 @rtype: boolean427 """428ifisinstance(value,rdflibLiteral):429val=str(value)430else:431val=value432forpinself.pattern:433ifp.match(val)isNone:434returnFalse435returnTrue
438"""439 Check the (python) value against array of language ranges.440 @param value: the value to be checked441 @rtype: boolean442 """443ifisinstance(value,rdflibLiteral):444lang=value.language445else:446returnFalse447forrinself.langRange:448ifnot_lang_range_check(r,lang):449returnFalse450returnTrue
An 'abstract' superclass for datatype restrictions. The instance
variables listed here are used in general, without the specificities of
the concrete restricted datatype.
This module defines the RestrictedDatatype class that corresponds to the
datatypes and their restrictions defined in the OWL 2 standard. Other
modules may subclass this class to define new datatypes with
restrictions.
RDFClosure.Literals._LiteralStructure:
This class serves as a wrapper around rdflib's Literal, by changing
the equality function to a strict identity of datatypes and lexical
values.
object:
The most base type
datetime.tzinfo:
Abstract base class for time zone info objects.
OWL-RL-7.1.4/Doc_OLD/crarr.png 0000664 0000000 0000000 00000000524 15042011661 0015516 0 ustar 00root root 0000000 0000000 PNG
IHDR
eE ,tEXtCreation Time Tue 22 Aug 2006 00:43:10 -0500` X tIME)} pHYs nu> gAMA a EPLTEðf4sW ЊrD`@ bCܖX{`,lNo@xdE螊dƴ~Twv tRNS @f MIDATxc`@0&+ (;; /EXؑ? n b;'+Y# (r<" IENDB` OWL-RL-7.1.4/Doc_OLD/epydoc.css 0000664 0000000 0000000 00000036617 15042011661 0015710 0 ustar 00root root 0000000 0000000
/* Epydoc CSS Stylesheet
*
* This stylesheet can be used to customize the appearance of epydoc's
* HTML output.
*
*/
/* Default Colors & Styles
* - Set the default foreground & background color with 'body'; and
* link colors with 'a:link' and 'a:visited'.
* - Use bold for decision list terms.
* - The heading styles defined here are used for headings *within*
* docstring descriptions. All headings used by epydoc itself use
* either class='epydoc' or class='toc' (CSS styles for both
* defined below).
*/
body { background: #ffffff; color: #000000; }
a:link { color: #0000ff; }
a:visited { color: #204080; }
dt { font-weight: bold; }
h1 { font-size: +140%;
font-style: italic;
font-weight: bold;
background: #cccc99; /* #EFEBCE; #005a9c; */
color: white;
margin-bottom: 0.5em;
}
h2 { font-size: +125%; font-style: italic;
font-weight: bold; }
h3 { font-size: +110%; font-style: italic;
font-weight: normal; }
code { font-size: 100%; }
/* Page Header & Footer
* - The standard page header consists of a navigation bar (with
* pointers to standard pages such as 'home' and 'trees'); a
* breadcrumbs list, which can be used to navigate to containing
* classes or modules; options links, to show/hide private
* variables and to show/hide frames; and a page title (using
*
). The page title may be followed by a link to the
* corresponding source code (using 'span.codelink').
* - The footer consists of a navigation bar, a timestamp, and a
* pointer to epydoc's homepage.
*/
h1.epydoc { margin: 0; font-size: +140%; font-weight: bold; }
h2.epydoc { font-size: +130%; font-weight: bold; }
h3.epydoc { font-size: +115%; font-weight: bold; }
td h3.epydoc { font-size: +115%; font-weight: bold;
margin-bottom: 0; }
table.navbar { background: #cccc99; color: #000000;
border: 2px groove #c0d0d0; }
table.navbar table { color: #000000; }
th.navbar-select { background: #70b0ff;
color: #000000; }
table.navbar a { text-decoration: none; }
table.navbar a:link { color: #0000ff; }
table.navbar a:visited { color: #204080; }
span.breadcrumbs { font-size: 85%; font-weight: bold; }
span.options { font-size: 70%; }
span.codelink { font-size: 85%; }
td.footer { font-size: 85%; }
/* Table Headers
* - Each summary table and details section begins with a 'header'
* row. This row contains a section title (marked by
* 'span.table-header') as well as a show/hide private link
* (marked by 'span.options', defined above).
* - Summary tables that contain user-defined groups mark those
* groups using 'group header' rows.
*/
td.table-header { background: #EFEBCE; color: #000000;
border: 1px solid #608090; }
td.table-header table { color: #000000; }
td.table-header table a:link { color: #0000ff; }
td.table-header table a:visited { color: #204080; }
span.table-header { font-size: 120%; font-weight: bold; }
th.group-header { background: #c0e0f8; color: #000000;
text-align: left; font-style: italic;
font-size: 115%;
border: 1px solid #608090; }
/* Summary Tables (functions, variables, etc)
* - Each object is described by a single row of the table with
* two cells. The left cell gives the object's type, and is
* marked with 'code.summary-type'. The right cell gives the
* object's name and a summary description.
* - CSS styles for the table's header and group headers are
* defined above, under 'Table Headers'
*/
table.summary { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin-bottom: 0.5em; }
td.summary { border: 1px solid #608090; }
code.summary-type { font-size: 85%; }
table.summary a:link { color: #0000ff; }
table.summary a:visited { color: #204080; }
/* Details Tables (functions, variables, etc)
* - Each object is described in its own div.
* - A single-row summary table w/ table-header is used as
* a header for each details section (CSS style for table-header
* is defined above, under 'Table Headers').
*/
table.details { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
table.details table { color: #000000; }
table.details a:link { color: #0000ff; }
table.details a:visited { color: #204080; }
/* Fields */
dl.fields { margin-left: 2em; margin-top: 1em;
margin-bottom: 1em; }
dl.fields dd ul { margin-left: 0em; padding-left: 0em; }
div.fields { margin-left: 2em; }
div.fields p { margin-bottom: 0.5em; }
/* Index tables (identifier index, term index, etc)
* - link-index is used for indices containing lists of links
* (namely, the identifier index & term index).
* - index-where is used in link indices for the text indicating
* the container/source for each link.
* - metadata-index is used for indices containing metadata
* extracted from fields (namely, the bug index & todo index).
*/
table.link-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090; }
td.link-index { border-width: 0px; }
table.link-index a:link { color: #0000ff; }
table.link-index a:visited { color: #204080; }
span.index-where { font-size: 70%; }
table.metadata-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
td.metadata-index { border-width: 1px; border-style: solid; }
table.metadata-index a:link { color: #0000ff; }
table.metadata-index a:visited { color: #204080; }
/* Function signatures
* - sig* is used for the signature in the details section.
* - .summary-sig* is used for the signature in the summary
* table, and when listing property accessor functions.
* */
.sig-name { color: #006080; }
.sig-arg { color: #008060; }
.sig-default { color: #602000; }
.summary-sig { font-family: monospace; }
.summary-sig-name { color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:link
{ color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:visited
{ color: #006080; font-weight: bold; }
.summary-sig-arg { color: #006040; }
.summary-sig-default { color: #501800; }
/* To render variables, classes etc. like functions */
table.summary .summary-name { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:link { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:visited { color: #006080; font-weight: bold;
font-family: monospace; }
/* Variable values
* - In the 'variable details' sections, each varaible's value is
* listed in a 'pre.variable' box. The width of this box is
* restricted to 80 chars; if the value's repr is longer than
* this it will be wrapped, using a backslash marked with
* class 'variable-linewrap'. If the value's repr is longer
* than 3 lines, the rest will be ellided; and an ellipsis
* marker ('...' marked with 'variable-ellipsis') will be used.
* - If the value is a string, its quote marks will be marked
* with 'variable-quote'.
* - If the variable is a regexp, it is syntax-highlighted using
* the re* CSS classes.
*/
pre.variable { padding: .5em; margin: 0;
background: #dce4ec; color: #000000;
border: 1px solid #708890; }
.variable-linewrap { color: #604000; font-weight: bold; }
.variable-ellipsis { color: #604000; font-weight: bold; }
.variable-quote { color: #604000; font-weight: bold; }
.variable-group { color: #008000; font-weight: bold; }
.variable-op { color: #604000; font-weight: bold; }
.variable-string { color: #006030; }
.variable-unknown { color: #a00000; font-weight: bold; }
.re { color: #000000; }
.re-char { color: #006030; }
.re-op { color: #600000; }
.re-group { color: #003060; }
.re-ref { color: #404040; }
/* Base tree
* - Used by class pages to display the base class hierarchy.
*/
pre.base-tree { font-size: 80%; margin: 0; }
/* Frames-based table of contents headers
* - Consists of two frames: one for selecting modules; and
* the other listing the contents of the selected module.
* - h1.toc is used for each frame's heading
* - h2.toc is used for subheadings within each frame.
*/
h1.toc { text-align: center; font-size: 105%;
margin: 0; font-weight: bold;
padding: 0; }
h2.toc { font-size: 100%; font-weight: bold;
margin: 0.5em 0 0 -0.3em; }
/* Syntax Highlighting for Source Code
* - doctest examples are displayed in a 'pre.py-doctest' block.
* If the example is in a details table entry, then it will use
* the colors specified by the 'table pre.py-doctest' line.
* - Source code listings are displayed in a 'pre.py-src' block.
* Each line is marked with 'span.py-line' (used to draw a line
* down the left margin, separating the code from the line
* numbers). Line numbers are displayed with 'span.py-lineno'.
* The expand/collapse block toggle button is displayed with
* 'a.py-toggle' (Note: the CSS style for 'a.py-toggle' should not
* modify the font size of the text.)
* - If a source code page is opened with an anchor, then the
* corresponding code block will be highlighted. The code
* block's header is highlighted with 'py-highlight-hdr'; and
* the code block's body is highlighted with 'py-highlight'.
* - The remaining py-* classes are used to perform syntax
* highlighting (py-string for string literals, py-name for names,
* etc.)
*/
pre.py-doctest { padding: .5em; margin: 1em;
background: #e8f0f8; color: #000000;
border: 1px solid #708890; }
table pre.py-doctest { background: #dce4ec;
color: #000000; }
pre.py-src { border: 2px solid #000000;
background: #f0f0f0; color: #000000; }
.py-line { border-left: 2px solid #000000;
margin-left: .2em; padding-left: .4em; }
.py-lineno { font-style: italic; font-size: 90%;
padding-left: .5em; }
a.py-toggle { text-decoration: none; }
div.py-highlight-hdr { border-top: 2px solid #000000;
border-bottom: 2px solid #000000;
background: #d8e8e8; }
div.py-highlight { border-bottom: 2px solid #000000;
background: #d0e0e0; }
.py-prompt { color: #005050; font-weight: bold;}
.py-more { color: #005050; font-weight: bold;}
.py-string { color: #006030; }
.py-comment { color: #003060; }
.py-keyword { color: #600000; }
.py-output { color: #404040; }
.py-name { color: #000050; }
.py-name:link { color: #000050 !important; }
.py-name:visited { color: #000050 !important; }
.py-number { color: #005000; }
.py-defname { color: #000060; font-weight: bold; }
.py-def-name { color: #000060; font-weight: bold; }
.py-base-class { color: #000060; }
.py-param { color: #000060; }
.py-docstring { color: #006030; }
.py-decorator { color: #804020; }
/* Use this if you don't want links to names underlined: */
/*a.py-name { text-decoration: none; }*/
/* Graphs & Diagrams
* - These CSS styles are used for graphs & diagrams generated using
* Graphviz dot. 'img.graph-without-title' is used for bare
* diagrams (to remove the border created by making the image
* clickable).
*/
img.graph-without-title { border: none; }
img.graph-with-title { border: 1px solid #000000; }
span.graph-title { font-weight: bold; }
span.graph-caption { }
/* General-purpose classes
* - 'p.indent-wrapped-lines' defines a paragraph whose first line
* is not indented, but whose subsequent lines are.
* - The 'nomargin-top' class is used to remove the top margin (e.g.
* from lists). The 'nomargin' class is used to remove both the
* top and bottom margin (but not the left or right margin --
* for lists, that would cause the bullets to disappear.)
*/
p.indent-wrapped-lines { padding: 0 0 0 7em; text-indent: -7em;
margin: 0; }
.nomargin-top { margin-top: 0; }
.nomargin { margin-top: 0; margin-bottom: 0; }
/* HTML Log */
div.log-block { padding: 0; margin: .5em 0 .5em 0;
background: #e8f0f8; color: #000000;
border: 1px solid #000000; }
div.log-error { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffb0b0; color: #000000;
border: 1px solid #000000; }
div.log-warning { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffffb0; color: #000000;
border: 1px solid #000000; }
div.log-info { padding: .1em .3em .1em .3em; margin: 4px;
background: #b0ffb0; color: #000000;
border: 1px solid #000000; }
h2.log-hdr { background: #70b0ff; color: #000000;
margin: 0; padding: 0em 0.5em 0em 0.5em;
border-bottom: 1px solid #000000; font-size: 110%; }
p.log { font-weight: bold; margin: .5em 0 .5em 0; }
tr.opt-changed { color: #000000; font-weight: bold; }
tr.opt-default { color: #606060; }
pre.log { margin: 0; padding: 0; padding-left: 1em; }
OWL-RL-7.1.4/Doc_OLD/epydoc.js 0000664 0000000 0000000 00000024525 15042011661 0015527 0 ustar 00root root 0000000 0000000 function toggle_private() {
// Search for any private/public links on this page. Store
// their old text in "cmd," so we will know what action to
// take; and change their text to the opposite action.
var cmd = "?";
var elts = document.getElementsByTagName("a");
for(var i=0; i... ";
elt.innerHTML = s;
}
}
function toggle(id) {
elt = document.getElementById(id+"-toggle");
if (elt.innerHTML == "-")
collapse(id);
else
expand(id);
return false;
}
function highlight(id) {
var elt = document.getElementById(id+"-def");
if (elt) elt.className = "py-highlight-hdr";
var elt = document.getElementById(id+"-expanded");
if (elt) elt.className = "py-highlight";
var elt = document.getElementById(id+"-collapsed");
if (elt) elt.className = "py-highlight";
}
function num_lines(s) {
var n = 1;
var pos = s.indexOf("\n");
while ( pos > 0) {
n += 1;
pos = s.indexOf("\n", pos+1);
}
return n;
}
// Collapse all blocks that mave more than `min_lines` lines.
function collapse_all(min_lines) {
var elts = document.getElementsByTagName("div");
for (var i=0; i 0)
if (elt.id.substring(split, elt.id.length) == "-expanded")
if (num_lines(elt.innerHTML) > min_lines)
collapse(elt.id.substring(0, split));
}
}
function expandto(href) {
var start = href.indexOf("#")+1;
if (start != 0 && start != href.length) {
if (href.substring(start, href.length) != "-") {
collapse_all(4);
pos = href.indexOf(".", start);
while (pos != -1) {
var id = href.substring(start, pos);
expand(id);
pos = href.indexOf(".", pos+1);
}
var id = href.substring(start, href.length);
expand(id);
highlight(id);
}
}
}
function kill_doclink(id) {
var parent = document.getElementById(id);
parent.removeChild(parent.childNodes.item(0));
}
function auto_kill_doclink(ev) {
if (!ev) var ev = window.event;
if (!this.contains(ev.toElement)) {
var parent = document.getElementById(this.parentID);
parent.removeChild(parent.childNodes.item(0));
}
}
function doclink(id, name, targets_id) {
var elt = document.getElementById(id);
// If we already opened the box, then destroy it.
// (This case should never occur, but leave it in just in case.)
if (elt.childNodes.length > 1) {
elt.removeChild(elt.childNodes.item(0));
}
else {
// The outer box: relative + inline positioning.
var box1 = document.createElement("div");
box1.style.position = "relative";
box1.style.display = "inline";
box1.style.top = 0;
box1.style.left = 0;
// A shadow for fun
var shadow = document.createElement("div");
shadow.style.position = "absolute";
shadow.style.left = "-1.3em";
shadow.style.top = "-1.3em";
shadow.style.background = "#404040";
// The inner box: absolute positioning.
var box2 = document.createElement("div");
box2.style.position = "relative";
box2.style.border = "1px solid #a0a0a0";
box2.style.left = "-.2em";
box2.style.top = "-.2em";
box2.style.background = "white";
box2.style.padding = ".3em .4em .3em .4em";
box2.style.fontStyle = "normal";
box2.onmouseout=auto_kill_doclink;
box2.parentID = id;
// Get the targets
var targets_elt = document.getElementById(targets_id);
var targets = targets_elt.getAttribute("targets");
var links = "";
target_list = targets.split(",");
for (var i=0; i" +
target[0] + "";
}
// Put it all together.
elt.insertBefore(box1, elt.childNodes.item(0));
//box1.appendChild(box2);
box1.appendChild(shadow);
shadow.appendChild(box2);
box2.innerHTML =
"Which "+name+" do you want to see documentation for?" +
"
";
}
return false;
}
function get_anchor() {
var href = location.href;
var start = href.indexOf("#")+1;
if ((start != 0) && (start != href.length))
return href.substring(start, href.length);
}
function redirect_url(dottedName) {
// Scan through each element of the "pages" list, and check
// if "name" matches with any of them.
for (var i=0; i-m" or "-c";
// extract the portion & compare it to dottedName.
var pagename = pages[i].substring(0, pages[i].length-2);
if (pagename == dottedName.substring(0,pagename.length)) {
// We've found a page that matches `dottedName`;
// construct its URL, using leftover `dottedName`
// content to form an anchor.
var pagetype = pages[i].charAt(pages[i].length-1);
var url = pagename + ((pagetype=="m")?"-module.html":
"-class.html");
if (dottedName.length > pagename.length)
url += "#" + dottedName.substring(pagename.length+1,
dottedName.length);
return url;
}
}
}
OWL-RL-7.1.4/Doc_OLD/frames.html 0000664 0000000 0000000 00000001120 15042011661 0016033 0 ustar 00root root 0000000 0000000
API Documentation
OWL-RL-7.1.4/Doc_OLD/help.html 0000664 0000000 0000000 00000024737 15042011661 0015531 0 ustar 00root root 0000000 0000000
Help
This document contains the API (Application Programming Interface)
documentation for this project. Documentation for the Python
objects defined by the project is divided into separate pages for each
package, module, and class. The API documentation also includes two
pages containing information about the project as a whole: a trees
page, and an index page.
Object Documentation
Each Package Documentation page contains:
A description of the package.
A list of the modules and sub-packages contained by the
package.
A summary of the classes defined by the package.
A summary of the functions defined by the package.
A summary of the variables defined by the package.
A detailed description of each function defined by the
package.
A detailed description of each variable defined by the
package.
Each Module Documentation page contains:
A description of the module.
A summary of the classes defined by the module.
A summary of the functions defined by the module.
A summary of the variables defined by the module.
A detailed description of each function defined by the
module.
A detailed description of each variable defined by the
module.
Each Class Documentation page contains:
A class inheritance diagram.
A list of known subclasses.
A description of the class.
A summary of the methods defined by the class.
A summary of the instance variables defined by the class.
A summary of the class (static) variables defined by the
class.
A detailed description of each method defined by the
class.
A detailed description of each instance variable defined by the
class.
A detailed description of each class (static) variable defined
by the class.
Project Documentation
The Trees page contains the module and class hierarchies:
The module hierarchy lists every package and module, with
modules grouped into packages. At the top level, and within each
package, modules and sub-packages are listed alphabetically.
The class hierarchy lists every class, grouped by base
class. If a class has more than one base class, then it will be
listed under each base class. At the top level, and under each base
class, classes are listed alphabetically.
The Index page contains indices of terms and
identifiers:
The term index lists every term indexed by any object's
documentation. For each term, the index provides links to each
place where the term is indexed.
The identifier index lists the (short) name of every package,
module, class, method, function, variable, and parameter. For each
identifier, the index provides a short description, and a link to
its documentation.
The Table of Contents
The table of contents occupies the two frames on the left side of
the window. The upper-left frame displays the project
contents, and the lower-left frame displays the module
contents:
Project Contents...
API Documentation Frame
Module Contents ...
The project contents frame contains a list of all packages
and modules that are defined by the project. Clicking on an entry
will display its contents in the module contents frame. Clicking on a
special entry, labeled "Everything," will display the contents of
the entire project.
The module contents frame contains a list of every
submodule, class, type, exception, function, and variable defined by a
module or package. Clicking on an entry will display its
documentation in the API documentation frame. Clicking on the name of
the module, at the top of the frame, will display the documentation
for the module itself.
The "frames" and "no frames" buttons below the top
navigation bar can be used to control whether the table of contents is
displayed or not.
The Navigation Bar
A navigation bar is located at the top and bottom of every page.
It indicates what type of page you are currently viewing, and allows
you to go to related pages. The following table describes the labels
on the navigation bar. Note that not some labels (such as
[Parent]) are not displayed on all pages.
Label
Highlighted when...
Links to...
[Parent]
(never highlighted)
the parent of the current package
[Package]
viewing a package
the package containing the current object
[Module]
viewing a module
the module containing the current object
[Class]
viewing a class
the class containing the current object
[Trees]
viewing the trees page
the trees page
[Index]
viewing the index page
the index page
[Help]
viewing the help page
the help page
The "show private" and "hide private" buttons below
the top navigation bar can be used to control whether documentation
for private objects is displayed. Private objects are usually defined
as objects whose (short) names begin with a single underscore, but do
not end with an underscore. For example, "_x",
"__pprint", and "epydoc.epytext._tokenize"
are private objects; but "re.sub",
"__init__", and "type_" are not. However,
if a module defines the "__all__" variable, then its
contents are used to decide which objects are private.
A timestamp below the bottom navigation bar indicates when each
page was last updated.
RDFClosure: This module is brute force implementation of the 'finite' version
of RDFS
semantics and of OWL 2 RL on the top of RDFLib (with some caveats,
see below).
RDFClosure.RDFSClosure: This module is brute force implementation of the RDFS semantics on
the top of RDFLib (with some caveats, see in the introductory
text).
When javascript is enabled, this page will redirect URLs of
the form redirect.html#dotted.name to the
documentation for the object with the given fully-qualified
dotted name.
). The page title may be followed by a link to the
* corresponding source code (using 'span.codelink').
* - The footer consists of a navigation bar, a timestamp, and a
* pointer to epydoc's homepage.
*/
h1.epydoc { margin: 0; font-size: +140%; font-weight: bold; }
h2.epydoc { font-size: +130%; font-weight: bold; }
h3.epydoc { font-size: +115%; font-weight: bold; }
td h3.epydoc { font-size: +115%; font-weight: bold;
margin-bottom: 0; }
table.navbar { background: #cccc99; color: #000000;
border: 2px groove #c0d0d0; }
table.navbar table { color: #000000; }
th.navbar-select { background: #70b0ff;
color: #000000; }
table.navbar a { text-decoration: none; }
table.navbar a:link { color: #0000ff; }
table.navbar a:visited { color: #204080; }
span.breadcrumbs { font-size: 85%; font-weight: bold; }
span.options { font-size: 70%; }
span.codelink { font-size: 85%; }
td.footer { font-size: 85%; }
/* Table Headers
* - Each summary table and details section begins with a 'header'
* row. This row contains a section title (marked by
* 'span.table-header') as well as a show/hide private link
* (marked by 'span.options', defined above).
* - Summary tables that contain user-defined groups mark those
* groups using 'group header' rows.
*/
td.table-header { background: #EFEBCE; color: #000000;
border: 1px solid #608090; }
td.table-header table { color: #000000; }
td.table-header table a:link { color: #0000ff; }
td.table-header table a:visited { color: #204080; }
span.table-header { font-size: 120%; font-weight: bold; }
th.group-header { background: #c0e0f8; color: #000000;
text-align: left; font-style: italic;
font-size: 115%;
border: 1px solid #608090; }
/* Summary Tables (functions, variables, etc)
* - Each object is described by a single row of the table with
* two cells. The left cell gives the object's type, and is
* marked with 'code.summary-type'. The right cell gives the
* object's name and a summary description.
* - CSS styles for the table's header and group headers are
* defined above, under 'Table Headers'
*/
table.summary { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin-bottom: 0.5em; }
td.summary { border: 1px solid #608090; }
code.summary-type { font-size: 85%; }
table.summary a:link { color: #0000ff; }
table.summary a:visited { color: #204080; }
/* Details Tables (functions, variables, etc)
* - Each object is described in its own div.
* - A single-row summary table w/ table-header is used as
* a header for each details section (CSS style for table-header
* is defined above, under 'Table Headers').
*/
table.details { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
table.details table { color: #000000; }
table.details a:link { color: #0000ff; }
table.details a:visited { color: #204080; }
/* Fields */
dl.fields { margin-left: 2em; margin-top: 1em;
margin-bottom: 1em; }
dl.fields dd ul { margin-left: 0em; padding-left: 0em; }
div.fields { margin-left: 2em; }
div.fields p { margin-bottom: 0.5em; }
/* Index tables (identifier index, term index, etc)
* - link-index is used for indices containing lists of links
* (namely, the identifier index & term index).
* - index-where is used in link indices for the text indicating
* the container/source for each link.
* - metadata-index is used for indices containing metadata
* extracted from fields (namely, the bug index & todo index).
*/
table.link-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090; }
td.link-index { border-width: 0px; }
table.link-index a:link { color: #0000ff; }
table.link-index a:visited { color: #204080; }
span.index-where { font-size: 70%; }
table.metadata-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
td.metadata-index { border-width: 1px; border-style: solid; }
table.metadata-index a:link { color: #0000ff; }
table.metadata-index a:visited { color: #204080; }
/* Function signatures
* - sig* is used for the signature in the details section.
* - .summary-sig* is used for the signature in the summary
* table, and when listing property accessor functions.
* */
.sig-name { color: #006080; }
.sig-arg { color: #008060; }
.sig-default { color: #602000; }
.summary-sig { font-family: monospace; }
.summary-sig-name { color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:link
{ color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:visited
{ color: #006080; font-weight: bold; }
.summary-sig-arg { color: #006040; }
.summary-sig-default { color: #501800; }
/* To render variables, classes etc. like functions */
table.summary .summary-name { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:link { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:visited { color: #006080; font-weight: bold;
font-family: monospace; }
/* Variable values
* - In the 'variable details' sections, each varaible's value is
* listed in a 'pre.variable' box. The width of this box is
* restricted to 80 chars; if the value's repr is longer than
* this it will be wrapped, using a backslash marked with
* class 'variable-linewrap'. If the value's repr is longer
* than 3 lines, the rest will be ellided; and an ellipsis
* marker ('...' marked with 'variable-ellipsis') will be used.
* - If the value is a string, its quote marks will be marked
* with 'variable-quote'.
* - If the variable is a regexp, it is syntax-highlighted using
* the re* CSS classes.
*/
pre.variable { padding: .5em; margin: 0;
background: #dce4ec; color: #000000;
border: 1px solid #708890; }
.variable-linewrap { color: #604000; font-weight: bold; }
.variable-ellipsis { color: #604000; font-weight: bold; }
.variable-quote { color: #604000; font-weight: bold; }
.variable-group { color: #008000; font-weight: bold; }
.variable-op { color: #604000; font-weight: bold; }
.variable-string { color: #006030; }
.variable-unknown { color: #a00000; font-weight: bold; }
.re { color: #000000; }
.re-char { color: #006030; }
.re-op { color: #600000; }
.re-group { color: #003060; }
.re-ref { color: #404040; }
/* Base tree
* - Used by class pages to display the base class hierarchy.
*/
pre.base-tree { font-size: 80%; margin: 0; }
/* Frames-based table of contents headers
* - Consists of two frames: one for selecting modules; and
* the other listing the contents of the selected module.
* - h1.toc is used for each frame's heading
* - h2.toc is used for subheadings within each frame.
*/
h1.toc { text-align: center; font-size: 105%;
margin: 0; font-weight: bold;
padding: 0; }
h2.toc { font-size: 100%; font-weight: bold;
margin: 0.5em 0 0 -0.3em; }
/* Syntax Highlighting for Source Code
* - doctest examples are displayed in a 'pre.py-doctest' block.
* If the example is in a details table entry, then it will use
* the colors specified by the 'table pre.py-doctest' line.
* - Source code listings are displayed in a 'pre.py-src' block.
* Each line is marked with 'span.py-line' (used to draw a line
* down the left margin, separating the code from the line
* numbers). Line numbers are displayed with 'span.py-lineno'.
* The expand/collapse block toggle button is displayed with
* 'a.py-toggle' (Note: the CSS style for 'a.py-toggle' should not
* modify the font size of the text.)
* - If a source code page is opened with an anchor, then the
* corresponding code block will be highlighted. The code
* block's header is highlighted with 'py-highlight-hdr'; and
* the code block's body is highlighted with 'py-highlight'.
* - The remaining py-* classes are used to perform syntax
* highlighting (py-string for string literals, py-name for names,
* etc.)
*/
pre.py-doctest { padding: .5em; margin: 1em;
background: #e8f0f8; color: #000000;
border: 1px solid #708890; }
table pre.py-doctest { background: #dce4ec;
color: #000000; }
pre.py-src { border: 2px solid #000000;
background: #f0f0f0; color: #000000; }
.py-line { border-left: 2px solid #000000;
margin-left: .2em; padding-left: .4em; }
.py-lineno { font-style: italic; font-size: 90%;
padding-left: .5em; }
a.py-toggle { text-decoration: none; }
div.py-highlight-hdr { border-top: 2px solid #000000;
border-bottom: 2px solid #000000;
background: #d8e8e8; }
div.py-highlight { border-bottom: 2px solid #000000;
background: #d0e0e0; }
.py-prompt { color: #005050; font-weight: bold;}
.py-more { color: #005050; font-weight: bold;}
.py-string { color: #006030; }
.py-comment { color: #003060; }
.py-keyword { color: #600000; }
.py-output { color: #404040; }
.py-name { color: #000050; }
.py-name:link { color: #000050 !important; }
.py-name:visited { color: #000050 !important; }
.py-number { color: #005000; }
.py-defname { color: #000060; font-weight: bold; }
.py-def-name { color: #000060; font-weight: bold; }
.py-base-class { color: #000060; }
.py-param { color: #000060; }
.py-docstring { color: #006030; }
.py-decorator { color: #804020; }
/* Use this if you don't want links to names underlined: */
/*a.py-name { text-decoration: none; }*/
/* Graphs & Diagrams
* - These CSS styles are used for graphs & diagrams generated using
* Graphviz dot. 'img.graph-without-title' is used for bare
* diagrams (to remove the border created by making the image
* clickable).
*/
img.graph-without-title { border: none; }
img.graph-with-title { border: 1px solid #000000; }
span.graph-title { font-weight: bold; }
span.graph-caption { }
/* General-purpose classes
* - 'p.indent-wrapped-lines' defines a paragraph whose first line
* is not indented, but whose subsequent lines are.
* - The 'nomargin-top' class is used to remove the top margin (e.g.
* from lists). The 'nomargin' class is used to remove both the
* top and bottom margin (but not the left or right margin --
* for lists, that would cause the bullets to disappear.)
*/
p.indent-wrapped-lines { padding: 0 0 0 7em; text-indent: -7em;
margin: 0; }
.nomargin-top { margin-top: 0; }
.nomargin { margin-top: 0; margin-bottom: 0; }
/* HTML Log */
div.log-block { padding: 0; margin: .5em 0 .5em 0;
background: #e8f0f8; color: #000000;
border: 1px solid #000000; }
div.log-error { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffb0b0; color: #000000;
border: 1px solid #000000; }
div.log-warning { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffffb0; color: #000000;
border: 1px solid #000000; }
div.log-info { padding: .1em .3em .1em .3em; margin: 4px;
background: #b0ffb0; color: #000000;
border: 1px solid #000000; }
h2.log-hdr { background: #70b0ff; color: #000000;
margin: 0; padding: 0em 0.5em 0em 0.5em;
border-bottom: 1px solid #000000; font-size: 110%; }
p.log { font-weight: bold; margin: .5em 0 .5em 0; }
tr.opt-changed { color: #000000; font-weight: bold; }
tr.opt-default { color: #606060; }
pre.log { margin: 0; padding: 0; padding-left: 1em; }
OWL-RL-7.1.4/owlrl/ 0000775 0000000 0000000 00000000000 15042011661 0013632 5 ustar 00root root 0000000 0000000 OWL-RL-7.1.4/owlrl/AxiomaticTriples.py 0000775 0000000 0000000 00000064571 15042011661 0017505 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
Axiomatic triples to be (possibly) added to the final graph.
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from rdflib.namespace import OWL, RDF, RDFS, XSD
# Simple RDF axiomatic triples (typing of subject, predicate, first, rest, etc)
_Simple_RDF_axiomatic_triples = [
(RDF.type, RDF.type, RDF.Property),
(RDF.subject, RDF.type, RDF.Property),
(RDF.predicate, RDF.type, RDF.Property),
(RDF.object, RDF.type, RDF.Property),
(RDF.first, RDF.type, RDF.Property),
(RDF.rest, RDF.type, RDF.Property),
(RDF.value, RDF.type, RDF.Property),
(RDF.nil, RDF.type, RDF.List),
]
# RDFS axiomatic triples (domain and range, as well as class setting for a number of RDFS symbols)
_RDFS_axiomatic_triples = [
(RDF.type, RDFS.domain, RDFS.Resource),
(RDFS.domain, RDFS.domain, RDF.Property),
(RDFS.range, RDFS.domain, RDF.Property),
(RDFS.subPropertyOf, RDFS.domain, RDF.Property),
(RDFS.subClassOf, RDFS.domain, RDFS.Class),
(RDF.subject, RDFS.domain, RDF.Statement),
(RDF.predicate, RDFS.domain, RDF.Statement),
(RDF.object, RDFS.domain, RDF.Statement),
(RDFS.member, RDFS.domain, RDFS.Resource),
(RDF.first, RDFS.domain, RDF.List),
(RDF.rest, RDFS.domain, RDF.List),
(RDFS.seeAlso, RDFS.domain, RDFS.Resource),
(RDFS.isDefinedBy, RDFS.domain, RDFS.Resource),
(RDFS.comment, RDFS.domain, RDFS.Resource),
(RDFS.label, RDFS.domain, RDFS.Resource),
(RDF.value, RDFS.domain, RDFS.Resource),
(RDF.Property, RDF.type, RDFS.Class),
(RDF.type, RDFS.range, RDFS.Class),
(RDFS.domain, RDFS.range, RDFS.Class),
(RDFS.range, RDFS.range, RDFS.Class),
(RDFS.subPropertyOf, RDFS.range, RDF.Property),
(RDFS.subClassOf, RDFS.range, RDFS.Class),
(RDF.subject, RDFS.range, RDFS.Resource),
(RDF.predicate, RDFS.range, RDFS.Resource),
(RDF.object, RDFS.range, RDFS.Resource),
(RDFS.member, RDFS.range, RDFS.Resource),
(RDF.first, RDFS.range, RDFS.Resource),
(RDF.rest, RDFS.range, RDF.List),
(RDFS.seeAlso, RDFS.range, RDFS.Resource),
(RDFS.isDefinedBy, RDFS.range, RDFS.Resource),
(RDFS.comment, RDFS.range, RDFS.Literal),
(RDFS.label, RDFS.range, RDFS.Literal),
(RDF.value, RDFS.range, RDFS.Resource),
(RDF.Alt, RDFS.subClassOf, RDFS.Container),
(RDF.Bag, RDFS.subClassOf, RDFS.Container),
(RDF.Seq, RDFS.subClassOf, RDFS.Container),
(RDFS.ContainerMembershipProperty, RDFS.subClassOf, RDF.Property),
(RDFS.isDefinedBy, RDFS.subPropertyOf, RDFS.seeAlso),
(RDF.XMLLiteral, RDF.type, RDFS.Datatype),
(RDF.XMLLiteral, RDFS.subClassOf, RDFS.Literal),
(RDFS.Datatype, RDFS.subClassOf, RDFS.Class),
# rdfs valid triples; these would be inferred by the RDFS expansion, but it may make things
# a bit faster to add these upfront
(RDFS.Resource, RDF.type, RDFS.Class),
(RDFS.Class, RDF.type, RDFS.Class),
(RDFS.Literal, RDF.type, RDFS.Class),
(RDF.XMLLiteral, RDF.type, RDFS.Class),
(RDFS.Datatype, RDF.type, RDFS.Class),
(RDF.Seq, RDF.type, RDFS.Class),
(RDF.Bag, RDF.type, RDFS.Class),
(RDF.Alt, RDF.type, RDFS.Class),
(RDFS.Container, RDF.type, RDFS.Class),
(RDF.List, RDF.type, RDFS.Class),
(RDFS.ContainerMembershipProperty, RDF.type, RDFS.Class),
(RDF.Property, RDF.type, RDFS.Class),
(RDF.Statement, RDF.type, RDFS.Class),
(RDFS.domain, RDF.type, RDF.Property),
(RDFS.range, RDF.type, RDF.Property),
(RDFS.subPropertyOf, RDF.type, RDF.Property),
(RDFS.subClassOf, RDF.type, RDF.Property),
(RDFS.member, RDF.type, RDF.Property),
(RDFS.seeAlso, RDF.type, RDF.Property),
(RDFS.isDefinedBy, RDF.type, RDF.Property),
(RDFS.comment, RDF.type, RDF.Property),
(RDFS.label, RDF.type, RDF.Property),
]
# RDFS Axiomatic Triples all together
RDFS_Axiomatic_Triples = _Simple_RDF_axiomatic_triples + _RDFS_axiomatic_triples
# RDFS D-entailement triples, ie, possible subclassing of various datatypes
RDFS_D_Axiomatic_Triples_subclasses = [
# See http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#built-in-datatypes
(XSD.decimal, RDFS.subClassOf, RDFS.Literal),
(XSD.integer, RDFS.subClassOf, XSD.decimal),
(XSD.long, RDFS.subClassOf, XSD.integer),
(XSD.int, RDFS.subClassOf, XSD.long),
(XSD.short, RDFS.subClassOf, XSD.int),
(XSD.byte, RDFS.subClassOf, XSD.short),
(XSD.nonNegativeInteger, RDFS.subClassOf, XSD.integer),
(XSD.positiveInteger, RDFS.subClassOf, XSD.nonNegativeInteger),
(XSD.unsignedLong, RDFS.subClassOf, XSD.nonNegativeInteger),
(XSD.unsignedInt, RDFS.subClassOf, XSD.unsignedLong),
(XSD.unsignedShort, RDFS.subClassOf, XSD.unsignedInt),
(XSD.unsignedByte, RDFS.subClassOf, XSD.unsignedShort),
(XSD.nonPositiveInteger, RDFS.subClassOf, XSD.integer),
(XSD.negativeInteger, RDFS.subClassOf, XSD.nonPositiveInteger),
(XSD.normalizedString, RDFS.subClassOf, XSD.string),
(XSD.token, RDFS.subClassOf, XSD.normalizedString),
(XSD.language, RDFS.subClassOf, XSD.token),
(XSD.Name, RDFS.subClassOf, XSD.token),
(XSD.NMTOKEN, RDFS.subClassOf, XSD.token),
(XSD.NCName, RDFS.subClassOf, XSD.Name),
(XSD.dateTimeStamp, RDFS.subClassOf, XSD.dateTime),
]
#
RDFS_D_Axiomatic_Triples_types = [
(XSD.integer, RDF.type, RDFS.Datatype),
(XSD.decimal, RDF.type, RDFS.Datatype),
(XSD.nonPositiveInteger, RDF.type, RDFS.Datatype),
(XSD.nonPositiveInteger, RDF.type, RDFS.Datatype),
(XSD.positiveInteger, RDF.type, RDFS.Datatype),
(XSD.positiveInteger, RDF.type, RDFS.Datatype),
(XSD.long, RDF.type, RDFS.Datatype),
(XSD.int, RDF.type, RDFS.Datatype),
(XSD.short, RDF.type, RDFS.Datatype),
(XSD.byte, RDF.type, RDFS.Datatype),
(XSD.unsignedLong, RDF.type, RDFS.Datatype),
(XSD.unsignedInt, RDF.type, RDFS.Datatype),
(XSD.unsignedShort, RDF.type, RDFS.Datatype),
(XSD.unsignedByte, RDF.type, RDFS.Datatype),
(XSD.float, RDF.type, RDFS.Datatype),
(XSD.double, RDF.type, RDFS.Datatype),
(XSD.string, RDF.type, RDFS.Datatype),
(XSD.normalizedString, RDF.type, RDFS.Datatype),
(XSD.token, RDF.type, RDFS.Datatype),
(XSD.language, RDF.type, RDFS.Datatype),
(XSD.Name, RDF.type, RDFS.Datatype),
(XSD.NCName, RDF.type, RDFS.Datatype),
(XSD.NMTOKEN, RDF.type, RDFS.Datatype),
(XSD.boolean, RDF.type, RDFS.Datatype),
(XSD.hexBinary, RDF.type, RDFS.Datatype),
(XSD.base64Binary, RDF.type, RDFS.Datatype),
(XSD.anyURI, RDF.type, RDFS.Datatype),
(XSD.dateTimeStamp, RDF.type, RDFS.Datatype),
(XSD.dateTime, RDF.type, RDFS.Datatype),
(RDFS.Literal, RDF.type, RDFS.Datatype),
(RDF.XMLLiteral, RDF.type, RDFS.Datatype),
]
RDFS_D_Axiomatic_Triples = (
RDFS_D_Axiomatic_Triples_types + RDFS_D_Axiomatic_Triples_subclasses
)
# OWL Class axiomatic triples: definition of special classes
_OWL_axiomatic_triples_Classes = [
(OWL.AllDifferent, RDF.type, RDFS.Class),
(OWL.AllDifferent, RDFS.subClassOf, RDFS.Resource),
(OWL.AllDisjointClasses, RDF.type, RDFS.Class),
(OWL.AllDisjointClasses, RDFS.subClassOf, RDFS.Resource),
(OWL.AllDisjointProperties, RDF.type, RDFS.Class),
(OWL.AllDisjointProperties, RDFS.subClassOf, RDFS.Resource),
(OWL.Annotation, RDF.type, RDFS.Class),
(OWL.Annotation, RDFS.subClassOf, RDFS.Resource),
(OWL.AnnotationProperty, RDF.type, RDFS.Class),
(OWL.AnnotationProperty, RDFS.subClassOf, RDF.Property),
(OWL.AsymmetricProperty, RDF.type, RDFS.Class),
(OWL.AsymmetricProperty, RDFS.subClassOf, RDF.Property),
(OWL.Class, RDF.type, RDFS.Class),
(OWL.Class, OWL.equivalentClass, RDFS.Class),
# (OWL.DataRange, RDF.type, RDFS.Class),
# (OWL.DataRange, OWL.equivalentClass, RDFS.Datatype),
(RDFS.Datatype, RDF.type, RDFS.Class),
(OWL.DatatypeProperty, RDF.type, RDFS.Class),
(OWL.DatatypeProperty, RDFS.subClassOf, RDF.Property),
(OWL.DeprecatedClass, RDF.type, RDFS.Class),
(OWL.DeprecatedClass, RDFS.subClassOf, RDFS.Class),
(OWL.DeprecatedProperty, RDF.type, RDFS.Class),
(OWL.DeprecatedProperty, RDFS.subClassOf, RDF.Property),
(OWL.FunctionalProperty, RDF.type, RDFS.Class),
(OWL.FunctionalProperty, RDFS.subClassOf, RDF.Property),
(OWL.InverseFunctionalProperty, RDF.type, RDFS.Class),
(OWL.InverseFunctionalProperty, RDFS.subClassOf, RDF.Property),
(OWL.IrreflexiveProperty, RDF.type, RDFS.Class),
(OWL.IrreflexiveProperty, RDFS.subClassOf, RDF.Property),
(RDFS.Literal, RDF.type, RDFS.Datatype),
# (OWL.NamedIndividual, RDF.type, RDFS.Class),
# (OWL.NamedIndividual, OWL.equivalentClass, RDFS.Resource),
(OWL.NegativePropertyAssertion, RDF.type, RDFS.Class),
(OWL.NegativePropertyAssertion, RDFS.subClassOf, RDFS.Resource),
(OWL.Nothing, RDF.type, RDFS.Class),
(OWL.Nothing, RDFS.subClassOf, OWL.Thing),
(OWL.ObjectProperty, RDF.type, RDFS.Class),
(OWL.ObjectProperty, OWL.equivalentClass, RDF.Property),
(OWL.Ontology, RDF.type, RDFS.Class),
(OWL.Ontology, RDFS.subClassOf, RDFS.Resource),
(OWL.OntologyProperty, RDF.type, RDFS.Class),
(OWL.OntologyProperty, RDFS.subClassOf, RDF.Property),
(RDF.Property, RDF.type, RDFS.Class),
(OWL.ReflexiveProperty, RDF.type, RDFS.Class),
(OWL.ReflexiveProperty, RDFS.subClassOf, RDF.Property),
(OWL.Restriction, RDF.type, RDFS.Class),
(OWL.Restriction, RDFS.subClassOf, RDFS.Class),
(OWL.SymmetricProperty, RDF.type, RDFS.Class),
(OWL.SymmetricProperty, RDFS.subClassOf, RDF.Property),
(OWL.Thing, RDF.type, RDFS.Class),
(OWL.Thing, RDFS.subClassOf, RDFS.Resource),
(OWL.TransitiveProperty, RDF.type, RDFS.Class),
(OWL.TransitiveProperty, RDFS.subClassOf, RDF.Property),
# OWL valid triples; some of these would be inferred by the OWL RL expansion, but it may make things
# a bit faster to add these upfront
(OWL.AllDisjointProperties, RDF.type, OWL.Class),
(OWL.AllDisjointClasses, RDF.type, OWL.Class),
(OWL.AllDisjointProperties, RDF.type, OWL.Class),
(OWL.Annotation, RDF.type, OWL.Class),
(OWL.AsymmetricProperty, RDF.type, OWL.Class),
(OWL.Axiom, RDF.type, OWL.Class),
(OWL.DataRange, RDF.type, OWL.Class),
(RDFS.Datatype, RDF.type, OWL.Class),
(OWL.DatatypeProperty, RDF.type, OWL.Class),
(OWL.DeprecatedClass, RDF.type, OWL.Class),
(OWL.DeprecatedClass, RDFS.subClassOf, OWL.Class),
(OWL.DeprecatedProperty, RDF.type, OWL.Class),
(OWL.FunctionalProperty, RDF.type, OWL.Class),
(OWL.InverseFunctionalProperty, RDF.type, OWL.Class),
(OWL.IrreflexiveProperty, RDF.type, OWL.Class),
(OWL.NamedIndividual, RDF.type, OWL.Class),
(OWL.NegativePropertyAssertion, RDF.type, OWL.Class),
(OWL.Nothing, RDF.type, OWL.Class),
(OWL.ObjectProperty, RDF.type, OWL.Class),
(OWL.Ontology, RDF.type, OWL.Class),
(OWL.OntologyProperty, RDF.type, OWL.Class),
(RDF.Property, RDF.type, OWL.Class),
(OWL.ReflexiveProperty, RDF.type, OWL.Class),
(OWL.Restriction, RDF.type, OWL.Class),
(OWL.Restriction, RDFS.subClassOf, OWL.Class),
# (OWL.SelfRestriction, RDF.type, OWL.Class),
(OWL.SymmetricProperty, RDF.type, OWL.Class),
(OWL.Thing, RDF.type, OWL.Class),
(OWL.TransitiveProperty, RDF.type, OWL.Class),
]
# OWL Property axiomatic triples: definition of domains and ranges
_OWL_axiomatic_triples_Properties = [
(OWL.allValuesFrom, RDF.type, RDF.Property),
(OWL.allValuesFrom, RDFS.domain, OWL.Restriction),
(OWL.allValuesFrom, RDFS.range, RDFS.Class),
(OWL.assertionProperty, RDF.type, RDF.Property),
(OWL.assertionProperty, RDFS.domain, OWL.NegativePropertyAssertion),
(OWL.assertionProperty, RDFS.range, RDF.Property),
(OWL.backwardCompatibleWith, RDF.type, OWL.OntologyProperty),
(OWL.backwardCompatibleWith, RDF.type, OWL.AnnotationProperty),
(OWL.backwardCompatibleWith, RDFS.domain, OWL.Ontology),
(OWL.backwardCompatibleWith, RDFS.range, OWL.Ontology),
# (OWL.bottomDataProperty, RDF.type, RDFS.DatatypeProperty),
# (OWL.bottomObjectProperty, RDF.type, OWL.ObjectProperty),
# (OWL.cardinality, RDF.type, RDF.Property),
# (OWL.cardinality, RDFS.domain, OWL.Restriction),
# (OWL.cardinality, RDFS.range, XSD.nonNegativeInteger),
(RDFS.comment, RDF.type, OWL.AnnotationProperty),
(RDFS.comment, RDFS.domain, RDFS.Resource),
(RDFS.comment, RDFS.range, RDFS.Literal),
(OWL.complementOf, RDF.type, RDF.Property),
(OWL.complementOf, RDFS.domain, RDFS.Class),
(OWL.complementOf, RDFS.range, RDFS.Class),
# (OWL.datatypeComplementOf, RDF.type, RDF.Property),
# (OWL.datatypeComplementOf, RDFS.domain, RDFS.Datatype),
# (OWL.datatypeComplementOf, RDFS.range, RDFS.Datatype),
(OWL.deprecated, RDF.type, OWL.AnnotationProperty),
(OWL.deprecated, RDFS.domain, RDFS.Resource),
(OWL.deprecated, RDFS.range, RDFS.Resource),
(OWL.differentFrom, RDF.type, RDF.Property),
(OWL.differentFrom, RDFS.domain, RDFS.Resource),
(OWL.differentFrom, RDFS.range, RDFS.Resource),
# (OWL.disjointUnionOf, RDF.type, RDF.Property),
# (OWL.disjointUnionOf, RDFS.domain, RDFS.Class),
# (OWL.disjointUnionOf, RDFS.range, RDF.List),
(OWL.disjointWith, RDF.type, RDF.Property),
(OWL.disjointWith, RDFS.domain, RDFS.Class),
(OWL.disjointWith, RDFS.range, RDFS.Class),
(OWL.distinctMembers, RDF.type, RDF.Property),
(OWL.distinctMembers, RDFS.domain, OWL.AllDifferent),
(OWL.distinctMembers, RDFS.range, RDF.List),
(OWL.equivalentClass, RDF.type, RDF.Property),
(OWL.equivalentClass, RDFS.domain, RDFS.Class),
(OWL.equivalentClass, RDFS.range, RDFS.Class),
(OWL.equivalentProperty, RDF.type, RDF.Property),
(OWL.equivalentProperty, RDFS.domain, RDF.Property),
(OWL.equivalentProperty, RDFS.range, RDF.Property),
(OWL.hasKey, RDF.type, RDF.Property),
(OWL.hasKey, RDFS.domain, RDFS.Class),
(OWL.hasKey, RDFS.range, RDF.List),
(OWL.hasValue, RDF.type, RDF.Property),
(OWL.hasValue, RDFS.domain, OWL.Restriction),
(OWL.hasValue, RDFS.range, RDFS.Resource),
(OWL.imports, RDF.type, OWL.OntologyProperty),
(OWL.imports, RDFS.domain, OWL.Ontology),
(OWL.imports, RDFS.range, OWL.Ontology),
(OWL.incompatibleWith, RDF.type, OWL.OntologyProperty),
(OWL.incompatibleWith, RDF.type, OWL.AnnotationProperty),
(OWL.incompatibleWith, RDFS.domain, OWL.Ontology),
(OWL.incompatibleWith, RDFS.range, OWL.Ontology),
(OWL.intersectionOf, RDF.type, RDF.Property),
(OWL.intersectionOf, RDFS.domain, RDFS.Class),
(OWL.intersectionOf, RDFS.range, RDF.List),
(OWL.inverseOf, RDF.type, RDF.Property),
(OWL.inverseOf, RDFS.domain, RDF.Property),
(OWL.inverseOf, RDFS.range, RDF.Property),
(RDFS.isDefinedBy, RDF.type, OWL.AnnotationProperty),
(RDFS.isDefinedBy, RDFS.domain, RDFS.Resource),
(RDFS.isDefinedBy, RDFS.range, RDFS.Resource),
(RDFS.label, RDF.type, OWL.AnnotationProperty),
(RDFS.label, RDFS.domain, RDFS.Resource),
(RDFS.label, RDFS.range, RDFS.Literal),
(OWL.maxCardinality, RDF.type, RDF.Property),
(OWL.maxCardinality, RDFS.domain, OWL.Restriction),
(OWL.maxCardinality, RDFS.range, XSD.nonNegativeInteger),
(OWL.maxQualifiedCardinality, RDF.type, RDF.Property),
(OWL.maxQualifiedCardinality, RDFS.domain, OWL.Restriction),
(OWL.maxQualifiedCardinality, RDFS.range, XSD.nonNegativeInteger),
(OWL.members, RDF.type, RDF.Property),
(OWL.members, RDFS.domain, RDFS.Resource),
(OWL.members, RDFS.range, RDF.List),
# (OWL.minCardinality, RDF.type, RDF.Property),
# (OWL.minCardinality, RDFS.domain, OWL.Restriction),
# (OWL.minCardinality, RDFS.range, XSD.nonNegativeInteger),
# (OWL.minQualifiedCardinality, RDF.type, RDF.Property),
# (OWL.minQualifiedCardinality, RDFS.domain, OWL.Restriction),
# (OWL.minQualifiedCardinality, RDFS.range, XSD.nonNegativeInteger),
# (OWL.annotatedTarget, RDF.type, RDF.Property),
# (OWL.annotatedTarget, RDFS.domain, RDFS.Resource),
# (OWL.annotatedTarget, RDFS.range, RDFS.Resource),
(OWL.onClass, RDF.type, RDF.Property),
(OWL.onClass, RDFS.domain, OWL.Restriction),
(OWL.onClass, RDFS.range, RDFS.Class),
# (OWL.onDataRange, RDF.type, RDF.Property),
# (OWL.onDataRange, RDFS.domain, OWL.Restriction),
# (OWL.onDataRange, RDFS.range, RDFS.Datatype),
(OWL.onDatatype, RDF.type, RDF.Property),
(OWL.onDatatype, RDFS.domain, RDFS.Datatype),
(OWL.onDatatype, RDFS.range, RDFS.Datatype),
(OWL.oneOf, RDF.type, RDF.Property),
(OWL.oneOf, RDFS.domain, RDFS.Class),
(OWL.oneOf, RDFS.range, RDF.List),
(OWL.onProperty, RDF.type, RDF.Property),
(OWL.onProperty, RDFS.domain, OWL.Restriction),
(OWL.onProperty, RDFS.range, RDF.Property),
# (OWL.onProperties, RDF.type, RDF.Property),
# (OWL.onProperties, RDFS.domain, OWL.Restriction),
# (OWL.onProperties, RDFS.range, RDF.List),
# (OWL.annotatedProperty, RDF.type, RDF.Property),
# (OWL.annotatedProperty, RDFS.domain, RDFS.Resource),
# (OWL.annotatedProperty, RDFS.range, RDF.Property),
(OWL.priorVersion, RDF.type, OWL.OntologyProperty),
(OWL.priorVersion, RDF.type, OWL.AnnotationProperty),
(OWL.priorVersion, RDFS.domain, OWL.Ontology),
(OWL.priorVersion, RDFS.range, OWL.Ontology),
(OWL.propertyChainAxiom, RDF.type, RDF.Property),
(OWL.propertyChainAxiom, RDFS.domain, RDF.Property),
(OWL.propertyChainAxiom, RDFS.range, RDF.List),
# (OWL.propertyDisjointWith, RDF.type, RDF.Property),
# (OWL.propertyDisjointWith, RDFS.domain, RDF.Property),
# (OWL.propertyDisjointWith, RDFS.range, RDF.Property),
#
# (OWL.qualifiedCardinality, RDF.type, RDF.Property),
# (OWL.qualifiedCardinality, RDFS.domain, OWL.Restriction),
# (OWL.qualifiedCardinality, RDFS.range, XSD.nonNegativeInteger),
(OWL.sameAs, RDF.type, RDF.Property),
(OWL.sameAs, RDFS.domain, RDFS.Resource),
(OWL.sameAs, RDFS.range, RDFS.Resource),
(RDFS.seeAlso, RDF.type, OWL.AnnotationProperty),
(RDFS.seeAlso, RDFS.domain, RDFS.Resource),
(RDFS.seeAlso, RDFS.range, RDFS.Resource),
(OWL.someValuesFrom, RDF.type, RDF.Property),
(OWL.someValuesFrom, RDFS.domain, OWL.Restriction),
(OWL.someValuesFrom, RDFS.range, RDFS.Class),
(OWL.sourceIndividual, RDF.type, RDF.Property),
(OWL.sourceIndividual, RDFS.domain, OWL.NegativePropertyAssertion),
(OWL.sourceIndividual, RDFS.range, RDFS.Resource),
#
# (OWL.annotatedSource, RDF.type, RDF.Property),
# (OWL.annotatedSource, RDFS.domain, RDFS.Resource),
# (OWL.annotatedSource, RDFS.range, RDFS.Resource),
#
(OWL.targetIndividual, RDF.type, RDF.Property),
(OWL.targetIndividual, RDFS.domain, OWL.NegativePropertyAssertion),
(OWL.targetIndividual, RDFS.range, RDFS.Resource),
(OWL.targetValue, RDF.type, RDF.Property),
(OWL.targetValue, RDFS.domain, OWL.NegativePropertyAssertion),
(OWL.targetValue, RDFS.range, RDFS.Literal),
# (OWL.topDataProperty, RDF.type, RDFS.DatatypeProperty),
# (OWL.topDataProperty, RDFS.domain, RDFS.Resource),
# (OWL.topDataProperty, RDFS.range, RDFS.Literal),
#
# (OWL.topObjectProperty, RDF.type, OWL.ObjectProperty),
# (OWL.topObjectProperty, RDFS.domain, RDFS.Resource),
# (OWL.topObjectProperty, RDFS.range, RDFS.Resource),
(OWL.unionOf, RDF.type, RDF.Property),
(OWL.unionOf, RDFS.domain, RDFS.Class),
(OWL.unionOf, RDFS.range, RDF.List),
(OWL.versionInfo, RDF.type, OWL.AnnotationProperty),
(OWL.versionInfo, RDFS.domain, RDFS.Resource),
(OWL.versionInfo, RDFS.range, RDFS.Resource),
(OWL.versionIRI, RDF.type, OWL.AnnotationProperty),
(OWL.versionIRI, RDFS.domain, RDFS.Resource),
(OWL.versionIRI, RDFS.range, RDFS.Resource),
(OWL.withRestrictions, RDF.type, RDF.Property),
(OWL.withRestrictions, RDFS.domain, RDFS.Datatype),
(OWL.withRestrictions, RDFS.range, RDF.List),
# some OWL valid triples; these would be inferred by the OWL RL expansion, but it may make things
# a bit faster to add these upfront
(OWL.allValuesFrom, RDFS.range, OWL.Class),
(OWL.complementOf, RDFS.domain, OWL.Class),
(OWL.complementOf, RDFS.range, OWL.Class),
# (OWL.datatypeComplementOf, domain, OWL.DataRange),
# (OWL.datatypeComplementOf, range, OWL.DataRange),
(OWL.disjointUnionOf, RDFS.domain, OWL.Class),
(OWL.disjointWith, RDFS.domain, OWL.Class),
(OWL.disjointWith, RDFS.range, OWL.Class),
(OWL.equivalentClass, RDFS.domain, OWL.Class),
(OWL.equivalentClass, RDFS.range, OWL.Class),
(OWL.hasKey, RDFS.domain, OWL.Class),
(OWL.intersectionOf, RDFS.domain, OWL.Class),
(OWL.onClass, RDFS.range, OWL.Class),
# (OWL.onDataRange, RDFS.range, OWL.DataRange),
(OWL.onDatatype, RDFS.domain, OWL.DataRange),
(OWL.onDatatype, RDFS.range, OWL.DataRange),
(OWL.oneOf, RDFS.domain, OWL.Class),
(OWL.someValuesFrom, RDFS.range, OWL.Class),
(OWL.unionOf, RDFS.range, OWL.Class),
# (OWL.withRestrictions, RDFS.domain, OWL.DataRange)
]
# OWL RL axiomatic triples: combination of the RDFS triples plus the OWL specific ones
OWLRL_Axiomatic_Triples = (
_OWL_axiomatic_triples_Classes + _OWL_axiomatic_triples_Properties
)
# Note that this is not used anywhere. But I encoded it once and I did not want to remove it...:-)
_OWL_axiomatic_triples_Facets = [
# langPattern
(XSD.length, RDF.type, RDF.Property),
(XSD.maxExclusive, RDF.type, RDF.Property),
(XSD.maxInclusive, RDF.type, RDF.Property),
(XSD.maxLength, RDF.type, RDF.Property),
(XSD.minExclusive, RDF.type, RDF.Property),
(XSD.minInclusive, RDF.type, RDF.Property),
(XSD.minLength, RDF.type, RDF.Property),
(XSD.pattern, RDF.type, RDF.Property),
(XSD.length, RDFS.domain, RDFS.Resource),
(XSD.maxExclusive, RDFS.domain, RDFS.Resource),
(XSD.maxInclusive, RDFS.domain, RDFS.Resource),
(XSD.maxLength, RDFS.domain, RDFS.Resource),
(XSD.minExclusive, RDFS.domain, RDFS.Resource),
(XSD.minInclusive, RDFS.domain, RDFS.Resource),
(XSD.minLength, RDFS.domain, RDFS.Resource),
(XSD.pattern, RDFS.domain, RDFS.Resource),
(XSD.length, RDFS.domain, RDFS.Resource),
(XSD.maxExclusive, RDFS.range, RDFS.Literal),
(XSD.maxInclusive, RDFS.range, RDFS.Literal),
(XSD.maxLength, RDFS.range, RDFS.Literal),
(XSD.minExclusive, RDFS.range, RDFS.Literal),
(XSD.minInclusive, RDFS.range, RDFS.Literal),
(XSD.minLength, RDFS.range, RDFS.Literal),
(XSD.pattern, RDFS.range, RDFS.Literal),
]
# OWL D-entailment triples (additionally to the RDFS ones), ie, possible subclassing of various extra datatypes
_OWL_D_Axiomatic_Triples_types = [(RDF.PlainLiteral, RDF.type, RDFS.Datatype)]
#
OWL_D_Axiomatic_Triples_subclasses = [
(XSD.string, RDFS.subClassOf, RDF.PlainLiteral),
(XSD.normalizedString, RDFS.subClassOf, RDF.PlainLiteral),
(XSD.token, RDFS.subClassOf, RDF.PlainLiteral),
(XSD.Name, RDFS.subClassOf, RDF.PlainLiteral),
(XSD.NCName, RDFS.subClassOf, RDF.PlainLiteral),
(XSD.NMTOKEN, RDFS.subClassOf, RDF.PlainLiteral),
]
#
OWLRL_Datatypes_Disjointness = [
(XSD.anyURI, OWL.disjointWith, XSD.base64Binary),
(XSD.anyURI, OWL.disjointWith, XSD.boolean),
(XSD.anyURI, OWL.disjointWith, XSD.dateTime),
(XSD.anyURI, OWL.disjointWith, XSD.decimal),
(XSD.anyURI, OWL.disjointWith, XSD.double),
(XSD.anyURI, OWL.disjointWith, XSD.float),
(XSD.anyURI, OWL.disjointWith, XSD.hexBinary),
(XSD.anyURI, OWL.disjointWith, XSD.string),
(XSD.anyURI, OWL.disjointWith, RDF.PlainLiteral),
(XSD.anyURI, OWL.disjointWith, RDF.XMLLiteral),
(XSD.base64Binary, OWL.disjointWith, XSD.boolean),
(XSD.base64Binary, OWL.disjointWith, XSD.dateTime),
(XSD.base64Binary, OWL.disjointWith, XSD.decimal),
(XSD.base64Binary, OWL.disjointWith, XSD.double),
(XSD.base64Binary, OWL.disjointWith, XSD.float),
(XSD.base64Binary, OWL.disjointWith, XSD.hexBinary),
(XSD.base64Binary, OWL.disjointWith, XSD.string),
(XSD.base64Binary, OWL.disjointWith, RDF.PlainLiteral),
(XSD.base64Binary, OWL.disjointWith, RDF.XMLLiteral),
(XSD.boolean, OWL.disjointWith, XSD.dateTime),
(XSD.boolean, OWL.disjointWith, XSD.decimal),
(XSD.boolean, OWL.disjointWith, XSD.double),
(XSD.boolean, OWL.disjointWith, XSD.float),
(XSD.boolean, OWL.disjointWith, XSD.hexBinary),
(XSD.boolean, OWL.disjointWith, XSD.string),
(XSD.boolean, OWL.disjointWith, RDF.PlainLiteral),
(XSD.boolean, OWL.disjointWith, RDF.XMLLiteral),
(XSD.dateTime, OWL.disjointWith, XSD.decimal),
(XSD.dateTime, OWL.disjointWith, XSD.double),
(XSD.dateTime, OWL.disjointWith, XSD.float),
(XSD.dateTime, OWL.disjointWith, XSD.hexBinary),
(XSD.dateTime, OWL.disjointWith, XSD.string),
(XSD.dateTime, OWL.disjointWith, RDF.PlainLiteral),
(XSD.dateTime, OWL.disjointWith, RDF.XMLLiteral),
(XSD.decimal, OWL.disjointWith, XSD.double),
(XSD.decimal, OWL.disjointWith, XSD.float),
(XSD.decimal, OWL.disjointWith, XSD.hexBinary),
(XSD.decimal, OWL.disjointWith, XSD.string),
(XSD.decimal, OWL.disjointWith, RDF.PlainLiteral),
(XSD.decimal, OWL.disjointWith, RDF.XMLLiteral),
(XSD.double, OWL.disjointWith, XSD.float),
(XSD.double, OWL.disjointWith, XSD.hexBinary),
(XSD.double, OWL.disjointWith, XSD.string),
(XSD.double, OWL.disjointWith, RDF.PlainLiteral),
(XSD.double, OWL.disjointWith, RDF.XMLLiteral),
(XSD.float, OWL.disjointWith, XSD.hexBinary),
(XSD.float, OWL.disjointWith, XSD.string),
(XSD.float, OWL.disjointWith, RDF.PlainLiteral),
(XSD.float, OWL.disjointWith, RDF.XMLLiteral),
(XSD.hexBinary, OWL.disjointWith, XSD.string),
(XSD.hexBinary, OWL.disjointWith, RDF.PlainLiteral),
(XSD.hexBinary, OWL.disjointWith, RDF.XMLLiteral),
(XSD.string, OWL.disjointWith, RDF.XMLLiteral),
]
# OWL RL D Axiomatic triples: combination of the RDFS ones, plus some extra statements on ranges and domains, plus
# some OWL specific datatypes
OWLRL_D_Axiomatic_Triples = (
RDFS_D_Axiomatic_Triples
+ _OWL_D_Axiomatic_Triples_types
+ OWL_D_Axiomatic_Triples_subclasses
+ OWLRL_Datatypes_Disjointness
)
OWL-RL-7.1.4/owlrl/Closure.py 0000775 0000000 0000000 00000030621 15042011661 0015625 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
The generic superclasses for various rule based semantics and the possible extensions.
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from typing import Union
import rdflib
from rdflib.namespace import RDF
from rdflib import BNode, Literal, Graph, Dataset
from .Namespaces import ERRNS
try:
from rdflib.graph import ConjunctiveGraph
except ImportError:
ConjunctiveGraph = Dataset
debugGlobal = False
offlineGeneration = False
######################################################################################################
# noinspection PyMethodMayBeStatic,PyPep8Naming,PyPep8Naming
class Core:
"""
Core of the semantics management, dealing with the RDFS and other Semantic triples. The only
reason to have it in a separate class is for an easier maintainability.
This is a common superclass only. In the present module, it is subclassed by
a :class:`.RDFSClosure.RDFS_Semantics` class and a :class:`.OWLRL.OWLRL_Semantics` classes.
There are some methods that are implemented in the subclasses only, ie, this class cannot be used by itself!
:param graph: The RDF graph to be extended.
:type graph: :class:`rdflib.graph.Graph`
:param axioms: Whether axioms should be added or not.
:type axioms: bool
:param daxioms: Whether datatype axioms should be added or not.
:type daxioms: bool
:param rdfs: Whether RDFS inference is also done (used in subclassed only).
:type rdfs: bool
:param destination: The destination graph to which the results are written. If None, use the source graph.
:type destination: :class:`rdflib.graph.Graph`
:var IMaxNum: Maximal index of :code:`rdf:_i` occurrence in the graph.
:type IMaxNum: int
:var graph: The real graph.
:type graph: :class:`rdflib.graph.Graph`
:var axioms: Whether axioms should be added or not.
:type axioms: bool
:var daxioms: Whether datatype axioms should be added or not.
:type daxioms: bool
:var added_triples: Triples added to the graph, conceptually, during one processing cycle.
:type added_triples: set of triples
:var error_messages: Error messages (typically inconsistency messages in OWL RL) found during processing. These
are added to the final graph at the very end as separate BNodes with error messages.
:type error_messages: list of str
:var rdfs: Whether RDFS inference is also done (used in subclassed only).
:type rdfs: bool
"""
# noinspection PyUnusedLocal
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = False, destination: Union[None, Graph] = None):
"""
The parameter descriptions here are from the old documentation.
@param graph: the RDF graph to be extended
@type graph: Graph
@param axioms: whether axioms should be added or not
@type axioms: boolean
@param daxioms: whether datatype axioms should be added or not
@type daxioms: boolean
@param rdfs: whether RDFS inference is also done (used in subclassed only)
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: Graph
"""
self._debug = debugGlobal
# Calculate the maximum 'n' value for the '_i' type predicates (see Horst's paper)
n = 1
maxnum = 0
cont = True
while cont:
cont = False
predicate = RDF[("_%d" % n)]
for (s, p, o) in graph.triples((None, predicate, None)):
# there is at least one if we got here
maxnum = n
n += 1
cont = True
self.IMaxNum = maxnum
self.graph = graph
if isinstance(self.graph, (Dataset, ConjunctiveGraph)):
self.graph.default_union = True
if destination is None:
if isinstance(graph, (Dataset, ConjunctiveGraph)):
self.destination = graph.default_context
else:
self.destination = graph
else:
if isinstance(destination, (str, rdflib.URIRef)):
if isinstance(graph, (Dataset, ConjunctiveGraph)):
self.destination = graph.get_context(destination)
else:
raise ValueError("URIRef destinations are only supported for Datasets and ConjunctiveGraphs")
else:
source_store = self.graph.store
dest_store = destination.store
if source_store is not dest_store:
raise ValueError("The source and destination graphs share the same backing store")
self.destination = destination
self.axioms = axioms
self.daxioms = daxioms
self.rdfs = rdfs
self.error_messages = []
self.empty_stored_triples()
def add_error(self, message):
"""
Add an error message
:param message: Error message.
:type message: str
"""
if message not in self.error_messages:
self.error_messages.append(message)
def pre_process(self):
"""
Do some pre-processing step. This method before anything else in the closure. By default, this method is empty,
subclasses can add content to it by overriding it.
"""
pass
def post_process(self):
"""
Do some post-processing step. This method when all processing is done, but before handling possible
errors (ie, the method can add its own error messages). By default, this method is empty, subclasses
can add content to it by overriding it.
"""
pass
def rules(self, t, cycle_num):
"""
The core processing cycles through every tuple in the graph and dispatches it to the various methods
implementing a specific group of rules. By default, this method raises an exception; indeed, subclasses
*must* add content to by overriding it.
:param t: One triple on which to apply the rules.
:type t: tuple
:param cycle_num: Which cycle are we in, starting with 1. This value is forwarded to all local rules; it is
also used locally to collect the bnodes in the graph.
:type cycle_num: int
"""
raise Exception(
"This method should not be called directly; subclasses should override it"
)
def add_axioms(self):
"""
Add axioms.
This is only a placeholder and raises an exception by default; subclasses *must* fill this with real content
"""
raise Exception(
"This method should not be called directly; subclasses should override it"
)
def add_d_axioms(self):
"""
Add d axioms.
This is only a placeholder and raises an exception by default; subclasses I{must} fill this with real content
"""
raise Exception(
"This method should not be called directly; subclasses should override it"
)
def one_time_rules(self):
"""
This is only a placeholder; subclasses should fill this with real content. By default, it is just an empty call.
This set of rules is invoked only once and not in a cycle.
"""
pass
# noinspection PyAttributeOutsideInit
def empty_stored_triples(self):
"""
Empty the internal store for triples.
"""
self.added_triples = set()
def flush_stored_triples(self):
"""
Send the stored triples to the graph, and empty the container.
"""
for t in self.added_triples:
self.destination.add(t)
self.empty_stored_triples()
def store_triple(self, t):
"""
In contrast to its name, this does not yet add anything to the graph itself, it just stores the tuple in an
internal set (:code:`Core.added_triples`). (It is important for this to be a set: some of the rules in the
various closures may generate the same tuples several times.) Before adding the tuple to the set, the method
checks whether the tuple is in the final graph already (if yes, it is not added to the set).
The set itself is emptied at the start of every processing cycle; the triples are then effectively added to the
graph at the end of such a cycle. If the set is actually empty at that point, this means that the cycle has not
added any new triple, and the full processing can stop.
:param t: The triple to be added to the graph, unless it is already there
:type t: tuple
"""
(s, p, o) = t
if not isinstance(p, Literal) and not (t in self.destination or t in self.graph):
if self._debug or offlineGeneration:
print(t)
self.added_triples.add(t)
# noinspection PyAttributeOutsideInit
def closure(self):
"""
Generate the closure the graph. This is the real 'core'.
The processing rules store new triples via the separate method :func:`owlrl.Closure.Core.store_triple` which stores
them in the :code:`added_triples` array. If that array is empty at the end of a cycle,
it means that the whole process can be stopped.
If required, the relevant axiomatic triples are added to the graph before processing in cycles. Similarly
the exchange of literals against bnodes is also done in this step (and restored after all cycles are over).
"""
self.pre_process()
# Handling the axiomatic triples. In general, this means adding all tuples in the list that
# forwarded, and those include RDF or RDFS. In both cases the relevant parts of the container axioms should also
# be added.
if self.axioms:
self.add_axioms()
# Add the datatype axioms, if needed (note that this makes use of the literal proxies, the order of the call
# is important!
if self.daxioms:
self.add_d_axioms()
self.flush_stored_triples()
# Get first the 'one-time rules', ie, those that do not need an extra round in cycles down the line
self.one_time_rules()
self.flush_stored_triples()
# Go cyclically through all rules until no change happens
new_cycle = True
cycle_num = 0
while new_cycle:
# yes, there was a change, let us go again
cycle_num += 1
# DEBUG: print the cycle number out
if self._debug:
print("----- Cycle #%d" % cycle_num)
# go through all rules, and collect the replies (to see whether any change has been done)
# the new triples to be added are collected separately not to interfere with
# the current graph yet
self.empty_stored_triples()
# Execute all the rules; these might fill up the added triples array
for t in self.graph.triples((None, None, None)):
self.rules(t, cycle_num)
# Add the tuples to the graph (if necessary, that is). If any new triple has been generated, a new cycle
# will be necessary...
new_cycle = len(self.added_triples) > 0
for t in self.added_triples:
self.destination.add(t)
self.post_process()
self.flush_stored_triples()
# Add possible error messages
if self.error_messages:
# I am not sure this is the right vocabulary to use for this purpose, but I haven't found anything!
# I could, of course, come up with my own, but I am not sure that would be kosher...
self.destination.bind("err", "http://www.daml.org/2002/03/agents/agent-ont#")
for m in self.error_messages:
message = BNode()
self.destination.add((message, RDF.type, ERRNS.ErrorMessage))
self.destination.add((message, ERRNS.error, Literal(m)))
OWL-RL-7.1.4/owlrl/CombinedClosure.py 0000775 0000000 0000000 00000016256 15042011661 0017276 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
The combined closure: performing *both* the OWL 2 RL and RDFS closures.
The two are very close but there are some rules in RDFS that are not in OWL 2 RL (eg, the axiomatic
triples concerning the container membership properties). Using this closure class the
OWL 2 RL implementation becomes a full extension of RDFS.
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from typing import Union
from rdflib import Graph
from rdflib.namespace import OWL, RDF, RDFS
from owlrl.RDFSClosure import RDFS_Semantics
from owlrl.OWLRL import OWLRL_Semantics
######################################################################################################
# noinspection PyPep8Naming
class RDFS_OWLRL_Semantics(RDFS_Semantics, OWLRL_Semantics):
"""
Common subclass of the RDFS and OWL 2 RL semantic classes. All methods simply call back
to the functions in the superclasses. This may lead to some unnecessary duplication of terms
and rules, but it is not so bad. Also, the additional identification defined for OWL Full,
ie, Resource being the same as Thing and OWL and RDFS classes being identical are added to the
triple store.
Note that this class is also a possible user extension point: subclasses can be created that
extend the standard functionality by extending this class. This class *always*} performs RDFS inferences.
Subclasses have to set the :code:`self.rdfs` flag explicitly to the requested value if that is to be controlled.
:param graph: The RDF graph to be extended.
:type graph: :class:`rdflib.Graph`
:param axioms: Whether (non-datatype) axiomatic triples should be added or not.
:type axioms: bool
:param daxioms: Whether datatype axiomatic triples should be added or not.
:type daxioms: bool
:param rdfs: Placeholder flag (used in subclassed only, it is always defaulted to True in this class)
:type rdfs: bool
:var full_binding_triples: Additional axiom type triples that are added to the combined semantics; these 'bind'
the RDFS and the OWL worlds together.
:var rdfs: (bool) Whether RDFS inference is to be performed or not. In this class instance the value is *always*
:code:`True`, subclasses may explicitly change it at initialization time.
:type rdfs: bool
"""
full_binding_triples = [
(OWL.Thing, OWL.equivalentClass, RDFS.Resource),
(RDFS.Class, OWL.equivalentClass, OWL.Class),
(OWL.DataRange, OWL.equivalentClass, RDFS.Datatype),
]
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = True, destination: Union[None, Graph] = None):
"""
@param graph: the RDF graph to be extended
@type graph: rdflib.Graph
@param axioms: whether (non-datatype) axiomatic triples should be added or not
@type axioms: bool
@param daxioms: whether datatype axiomatic triples should be added or not
@type daxioms: bool
@param rdfs: placeholder flag (used in subclassed only, it is always defaulted to True in this class)
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: rdflib.Graph
"""
OWLRL_Semantics.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
RDFS_Semantics.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
self.rdfs = True
# noinspection PyMethodMayBeStatic
@staticmethod
def add_new_datatype(
uri,
conversion_function,
datatype_list,
subsumption_dict=None,
subsumption_key=None,
subsumption_list=None,
):
"""
If an extension wants to add new datatypes, this method should be invoked at initialization time.
:param uri: URI for the new datatypes, like owl_ns["Rational"].
:param conversion_function: A function converting the lexical representation of the datatype to a Python value,
possibly raising an exception in case of unsuitable lexical form.
:param datatype_list: List of datatypes already in use that has to be checked.
:type datatype_list: list
:param subsumption_dict: Dictionary of subsumption hierarchies (indexed by the datatype URI-s).
:type subsumption_dict: dict
:param subsumption_key: Key in the dictionary, if None, the uri parameter is used.
:type subsumption_key: str
:param subsumption_list: List of subsumptions associated to a subsumption key (ie, all datatypes that are
superclasses of the new datatype).
:type subsumption_list: list
"""
from .DatatypeHandling import AltXSDToPYTHON, use_Alt_lexical_conversions
if datatype_list:
datatype_list.append(uri)
if subsumption_dict and subsumption_list:
if subsumption_key:
subsumption_dict[subsumption_key] = subsumption_list
else:
subsumption_dict[uri] = subsumption_list
AltXSDToPYTHON[uri] = conversion_function
use_Alt_lexical_conversions()
def post_process(self):
"""
Do some post-processing step. This method when all processing is done, but before handling possible
errors (I.e., the method can add its own error messages). By default, this method is empty, subclasses
can add content to it by overriding it.
"""
OWLRL_Semantics.post_process(self)
def rules(self, t, cycle_num):
"""
:param t: A triple (in the form of a tuple).
:type t: tuple
:param cycle_num: Which cycle are we in, starting with 1. This value is forwarded to all local rules; it is
also used locally to collect the bnodes in the graph.
:type cycle_num: int
"""
OWLRL_Semantics.rules(self, t, cycle_num)
if self.rdfs:
RDFS_Semantics.rules(self, t, cycle_num)
def add_axioms(self):
if self.rdfs:
RDFS_Semantics.add_axioms(self)
OWLRL_Semantics.add_axioms(self)
def add_d_axioms(self):
if self.rdfs:
RDFS_Semantics.add_d_axioms(self)
OWLRL_Semantics.add_d_axioms(self)
def one_time_rules(self):
"""Adds some extra axioms and calls for the d_axiom part of the OWL Semantics."""
for t in self.full_binding_triples:
self.store_triple(t)
# Note that the RL one time rules include the management of datatype which is a true superset
# of the rules in RDFS. It is therefore unnecessary to add those even self.rdfs is True.
OWLRL_Semantics.one_time_rules(self)
OWL-RL-7.1.4/owlrl/DatatypeHandling.py 0000775 0000000 0000000 00000057033 15042011661 0017437 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
Most of the XSD datatypes are handled directly by RDFLib. However, in some cases, that is not good enough. There are two
major reasons for this:
#. Some datatypes are missing from RDFLib and required by OWL 2 RL and/or RDFS.
#. In other cases, though the datatype is present, RDFLib is fairly lax in checking the lexical value of those datatypes. Typical case is boolean.
Some of these deficiencies are handled by this module. All the functions convert the lexical value into a
python datatype (or return the original string if this is not possible) which will be used, e.g.,
for comparisons (equalities). If the lexical value constraints are not met, exceptions are raised.
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
# noinspection PyPep8Naming
# from owlrl.RDFS import RDFNS as ns_rdf
from rdflib.namespace import RDF, XSD
from rdflib.term import XSDToPython, Literal, _toPythonMapping
import datetime, time, re
from decimal import Decimal
# noinspection PyMissingConstructor,PyPep8Naming
class _namelessTZ(datetime.tzinfo):
"""
(Nameless) timezone object. The python datetime object requires timezones as
a specific object added to the conversion, rather than the explicit hour and minute
difference used by XSD. This class is used to wrap around the hour/minute values.
:param hours: Hour offset.
:param minutes: Minute offset
"""
def __init__(self, hours, minutes):
"""
@param hours: hour offset
@param minutes: minute offset
"""
self.__offset = datetime.timedelta(hours=hours, minutes=minutes)
self.__name = "nameless"
def utcoffset(self, dt):
return self.__offset
def tzname(self, dt):
return self.__name
def dst(self, dt):
return datetime.timedelta(0)
# noinspection PyPep8Naming
def _returnTimeZone(incoming_v):
"""Almost all time/date related methods require the extraction of optional time zone information.
@param incoming_v: the time/date string
@return (v,timezone) tuple; 'v' is the input string with the timezone info cut off, 'timezone' is a L{_namelessTZ}
instance or None
"""
if incoming_v[-1] == "Z":
v = incoming_v[:-1]
tzone = _namelessTZ(0, 0)
else:
pattern = r".*(\+|-)([0-9][0-9]):([0-9][0-9])"
match = re.match(pattern, incoming_v)
if match is None:
v = incoming_v
tzone = None
else:
hours = int(match.groups()[1])
if match.groups()[0] == "-":
hours = -hours - 1
minutes = int(match.groups()[2])
v = incoming_v[:-6]
tzone = _namelessTZ(hours, minutes)
return v, tzone
# Booleans ##################################################
# noinspection PyPep8Naming
def _strToBool(v):
"""The built-in conversion to boolean is way too lax. The xsd specification requires that only true, false, 1 or 0 should be used...
@param v: the literal string defined as boolean
@return corresponding boolean value
@raise ValueError: invalid boolean values
"""
if v.lower() == "true" or v.lower() == "1":
return True
elif v.lower() == "false" or v.lower() == "0":
return False
else:
raise ValueError("Invalid boolean literal value %s" % v)
# Decimals ##################################################
# noinspection PyPep8Naming
def _strToDecimal(v):
"""The built in datatype handling for RDFLib maps a decimal number to float, but the python version 2.4 and upwards
also has a Decimal number. Better make use of that to use very high numbers.
However, there is also a big difference between Python's decimal and XSD's decimal, because the latter does not
allow for an exponential normal form (why???). This must be filtered out.
@param v: the literal string defined as decimal
@return Decimal
@raise ValueError: invalid decimal value
"""
# check whether the lexical form of 'v' is o.k.
if v.find("E") != -1 or v.find("e") != -1:
# this is an invalid lexical form, though would be accepted by Python
raise ValueError("Invalid decimal literal value %s" % v)
else:
return Decimal(v)
# ANY URIS ##################################################
# set of characters allowed in a hexadecimal number
_hexc = ["A", "B", "C", "D", "E", "F", "a", "b", "c", "d", "e", "f"]
# set of numerals
_numb = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
# noinspection PyPep8Naming
def _strToAnyURI(v):
"""Rudimentary test for the AnyURI value. If it is a relative URI, then some tests are done to filter out
mistakes. I am not sure this is the full implementation of the RFC, though, may have to be checked at some point
later.
@param v: the literal string defined as a URI
@return the incoming value
@raise ValueError: invalid URI value
"""
import urllib.parse
if len(v) == 0:
return v
if urllib.parse.urlsplit(v)[0] != "":
# this means that there is a proper scheme, the URI should be kosher
return v
else:
# this is meant to be a relative URI.
# If I am correct, that cannot begin with one or more "?" or ":" characters
# all others are o.k.
# if it begins with a % then it should be followed by two hexa characters,
# otherwise it is also a bug
if v[0] == "%":
if (
len(v) >= 3
and (v[1] in _hexc or v[1] in _numb)
and (v[2] in _hexc or v[2] in _numb)
):
return v
else:
raise ValueError("Invalid IRI %s" % v)
elif v[0] == "?" or v[0] == ":":
raise ValueError("Invalid IRI %s" % v)
else:
return v
# Base64Binary ##################################################
# noinspection PyPep8Naming
def _strToBase64Binary(v):
"""Rudimentary test for the base64Binary value. The problem is that the built-in b64 module functions ignore the
fact that only a certain family of characters are allowed to appear in the lexical value, so this is checked first.
@param v: the literal string defined as a base64encoded string
@return the decoded (binary) content
@raise ValueError: invalid base 64 binary value
"""
import base64
if v.replace("=", "x").replace("+", "y").replace("/", "z").isalnum():
try:
return base64.standard_b64decode(v)
except:
raise ValueError("Invalid Base64Binary %s" % v)
else:
raise ValueError("Invalid Base64Binary %s" % v)
# Numerical types ##################################################
# limits for unsigned bytes
_limits_unsignedByte = [-1, 256]
# limits for bytes
_limits_byte = [-129, 128]
# limits for unsigned int
_limits_unsignedInt = [-1, 4294967296]
# limits for int
_limits_int = [-2147483649, 2147483648]
# limits for unsigned short
_limits_unsignedShort = [-1, 65536]
# limits for short
_limits_short = [-32769, 32768]
# limits for unsigned long
_limits_unsignedLong = [-1, 18446744073709551616]
# limits for long
_limits_long = [-9223372036854775809, 9223372036854775808]
# limits for positive integer
_limits_positiveInteger = [0, None]
# limits for non positive integer
_limits_nonPositiveInteger = [None, 1]
# limits for non negative integer
_limits_nonNegativeInteger = [-1, None]
# limits for negative integer
_limits_negativeInteger = [None, 0]
# noinspection PyPep8Naming,PyBroadException
def _strToBoundNumeral(v, interval, conversion):
"""Test (and convert) a generic numerical type, with a check against a lower and upper limit.
@param v: the literal string to be converted
@param interval: lower and upper bounds (non inclusive). If the value is None, no comparison should be done
@param conversion: conversion function, ie, int, long, etc
@raise ValueError: invalid value
"""
try:
i = conversion(v)
if (interval[0] is None or interval[0] < i) and (
interval[1] is None or i < interval[1]
):
return i
except:
pass
raise ValueError("Invalid numerical value %s" % v)
# Double and float ##################################################
# noinspection PyPep8Naming
def _strToDouble(v):
"""Test and convert a double value into a Decimal or float. Raises an exception if the number is outside the
permitted range, ie, 1.0E+310 and 1.0E-330. To be on the safe side (python does not have double!) Decimals are used
if possible. Upper and lower values, as required by xsd, are checked (and these fixed values are the reasons
why Decimal is used!)
@param v: the literal string defined as a double
@return Decimal
@raise ValueError: invalid value
"""
try:
value = Decimal(v)
upper = Decimal("1.0E+310")
lower = Decimal("1.0E-330")
if lower < abs(value) < upper:
# bingo
return value
else:
raise ValueError("Invalid double %s" % v)
except:
# there was a problem in creating a decimal...
raise ValueError("Invalid double %s" % v)
# noinspection PyPep8Naming
def _strToFloat(v):
"""Test and convert a float value into Decimal or (python) float. Raises an exception if the number is outside the
permitted range, ie, 1.0E+40 and 1.0E-50. (And these fixed values are the reasons why Decimal is used!)
@param v: the literal string defined as a float
@return Decimal if the local python version is >= 2.4, float otherwise
@raise ValueError: invalid value
"""
try:
value = Decimal(v)
upper = Decimal("1.0E+40")
lower = Decimal("1.0E-50")
if lower < abs(value) < upper:
# bingo
return value
else:
raise ValueError("Invalid float %s" % v)
except:
# there was a problem in creating a decimal...
raise ValueError("Invalid float %s" % v)
# hexa ##################################################
# noinspection PyPep8Naming
def _strToHexBinary(v):
"""Test (and convert) hexa integer values. The number of characters should be even.
@param v: the literal string defined as a hexa number
@return long value
@raise ValueError: invalid value
"""
# first of all, the number of characters must be even according to the xsd spec:
length = len(v)
if (length / 2) * 2 != length:
raise ValueError("Invalid hex binary number %s" % v)
return int(v, 16)
# Datetime, date timestamp, etc ################################
# noinspection PyPep8Naming
def _strToDateTimeAndStamp(incoming_v, timezone_required=False):
"""Test (and convert) datetime and date timestamp values.
@param incoming_v: the literal string defined as the date and time
@param timezone_required: whether the timezone is required (ie, for date timestamp) or not
@return datetime
@rtype: datetime.datetime
@raise ValueError: invalid datetime or date timestamp
"""
# First, handle the timezone portion, if there is any
(v, tzone) = _returnTimeZone(incoming_v)
# Check on the timezone. For time date stamp object it is required
if timezone_required and tzone is None:
raise ValueError("Invalid datetime %s" % incoming_v)
# The microseconds should be handled here...
final_v = v
milliseconds = 0
milpattern = r"(.*)(\.)([0-9]*)"
match = re.match(milpattern, v)
if match is not None:
# we have a millisecond portion...
try:
final_v = match.groups()[0]
milliseconds = int(match.groups()[2])
except:
raise ValueError("Invalid datetime %s" % incoming_v)
#
# By now, the pattern should be clear
# This may raise an exception...
try:
tstr = time.strptime(final_v, "%Y-%m-%dT%H:%M:%S")
if tzone is not None:
return datetime.datetime(
tstr.tm_year,
tstr.tm_mon,
tstr.tm_mday,
tstr.tm_hour,
tstr.tm_min,
tstr.tm_sec,
milliseconds,
tzone,
)
else:
return datetime.datetime(
tstr.tm_year,
tstr.tm_mon,
tstr.tm_mday,
tstr.tm_hour,
tstr.tm_min,
tstr.tm_sec,
milliseconds,
)
except:
raise ValueError("Invalid datetime %s" % incoming_v)
# noinspection PyPep8Naming
def _strToTime(incoming_v):
"""Test (and convert) time values.
@param incoming_v: the literal string defined as time value
@return time
@rtype datetime.time
@raise ValueError: invalid datetime or date timestamp
"""
# First, handle the timezone portion, if there is any
(v, tzone) = _returnTimeZone(incoming_v)
# The microseconds should be handled here...
final_v = v
milliseconds = 0
milpattern = r"(.*)(\.)([0-9]*)"
match = re.match(milpattern, v)
if match is not None:
# we have a millisecond portion...
try:
final_v = match.groups()[0]
milliseconds = int(match.groups()[2])
except:
raise ValueError("Invalid datetime %s" % incoming_v)
#
# By now, the pattern should be clear
# This may raise an exception...
try:
tstr = time.strptime(final_v, "%H:%M:%S")
if tzone is not None:
return datetime.time(
tstr.tm_hour, tstr.tm_min, tstr.tm_sec, milliseconds, tzone
)
else:
return datetime.time(tstr.tm_hour, tstr.tm_min, tstr.tm_sec, milliseconds)
except:
raise ValueError("Invalid time %s" % incoming_v)
# noinspection PyPep8Naming
def _strToDate(incoming_v):
"""Test (and convert) date values.
@param incoming_v: the literal string defined as date (in iso format)
@return date
@return datetime.date
@raise ValueError: invalid datetime or date timestamp
"""
# First, handle the timezone portion, if there is any
(final_v, tzone) = _returnTimeZone(incoming_v)
# This may raise an exception...
try:
tstr = time.strptime(final_v, "%Y-%m-%d")
return datetime.date(tstr.tm_year, tstr.tm_mon, tstr.tm_mday)
except:
raise ValueError("Invalid date %s" % incoming_v)
# The 'g' series for dates ############################
# The 'g' datatypes (eg, gYear) cannot be directly represented as a python datatype
# the series of methods below simply check whether the incoming string is o.k., but the
# returned value is the same as the original
# noinspection PyPep8Naming
def _strTogYearMonth(v):
"""Test gYearMonth value
@param v: the literal string
@return v
@raise ValueError: invalid value
"""
try:
time.strptime(v + "-01", "%Y-%m-%d")
return v
except:
raise ValueError("Invalid gYearMonth %s" % v)
# noinspection PyPep8Naming
def _strTogYear(v):
"""Test gYear value
@param v: the literal string
@return v
@raise ValueError: invalid value
"""
try:
time.strptime(v + "-01-01", "%Y-%m-%d")
return v
except:
raise ValueError("Invalid gYear %s" % v)
# noinspection PyPep8Naming
def _strTogMonthDay(v):
"""Test gYearMonth value
@param v: the literal string
@return v
@raise ValueError: invalid value
"""
try:
time.strptime("2008-" + v, "%Y-%m-%d")
return v
except:
raise ValueError("Invalid gMonthDay %s" % v)
# noinspection PyPep8Naming
def _strTogDay(v):
"""Test gYearMonth value
@param v: the literal string
@return v
@raise ValueError: invalid value
"""
try:
time.strptime("2001-01-" + v, "%Y-%m-%d")
return v
except:
raise ValueError("Invalid gDay %s" % v)
# noinspection PyPep8Naming
def _strTogMonth(v):
"""Test gYearMonth value
@param v: the literal string
@return v
@raise ValueError: invalid value
"""
try:
time.strptime("2001-" + v + "-01", "%Y-%m-%d")
return v
except:
raise ValueError("Invalid gMonth %s" % v)
# XML Literal #########################################
# noinspection PyPep8Naming
def _strToXMLLiteral(v):
"""Test (and convert) XML Literal values.
@param v: the literal string defined as an xml literal
@return the canonical version of the same xml text
@raise ValueError: incorrect xml string
"""
import xml.dom.minidom
try:
dom = xml.dom.minidom.parseString(v)
return dom.toxml()
except:
raise ValueError("Invalid XML Literal %s" % v)
# language, NMTOKEN, NAME, etc #########################
# regular expression for a 'language' datatype
_re_language = r"[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*"
# regexp for NMTOKEN. It must be used with a re.U flag (the '(?U' regexp form did not work. It may depend on the
# locale...)
_re_NMTOKEN = r"[\w:_.\-]+"
# characters not permitted at a starting position for Name (otherwise Name is like NMTOKEN
_re_Name_ex = [".", "-"] + _numb
# regexp for NCName. It must be used with a re.U flag (the '(?U' regexp form did not work. It may depend on the
# locale...)
_re_NCName = r"[\w_.\-]+"
# characters not permitted at a starting position for NCName
_re_NCName_ex = [".", "-"] + _numb
# noinspection PyDefaultArgument,PyPep8Naming,PyPep8Naming
def _strToVal_Regexp(v, regexp, flag=0, excludeStart=[]):
"""Test (and convert) a generic string type, with a check against a regular expression.
@param v: the literal string to be converted
@param regexp: the regular expression to check against
@param flag: flags to be used in the regular expression
@param excludeStart: array of characters disallowed in the first position
@return original string
@raise ValueError: invalid value
"""
match = re.match(regexp, v, flag)
if match is None or match.end() != len(v):
raise ValueError("Invalid literal %s" % v)
else:
if len(excludeStart) > 0 and v[0] in excludeStart:
raise ValueError("Invalid literal %s" % v)
return v
# Disallowed characters in a token or a normalized string, as a regexp
_re_token = "[^\n\t\r]+"
# noinspection PyPep8Naming
def _strToToken(v):
"""Test (and convert) a string to a token.
@param v: the literal string to be converted
@return original string
@raise ValueError: invalid value
"""
if len(v) == 0:
return v
# filter out the case when there are new lines and similar (if there is a problem, an exception is raised)
_strToVal_Regexp(v, _re_token)
v1 = " ".join(v.strip().split())
# normalize the string, and see if the result is the same:
if len(v1) == len(v):
# no characters lost, ie, no unnecessary spaces
return v
else:
raise ValueError("Invalid literal %s" % v)
# plain literal ########################################
# noinspection PyPep8Naming
def _strToPlainLiteral(v):
"""Test (and convert) a plain literal
@param v: the literal to be converted
@return a new RDFLib Literal with language tag
@raise ValueError: invalid value
"""
reg = "(.*)@([^@]*)"
# a plain literal must match this regexp!
match = re.match(reg, v)
if match is None:
raise ValueError("Invalid plain literal %s" % v)
else:
lit = match.groups()[0]
if len(match.groups()) == 1 or match.groups()[1] == "":
# no language tag
return Literal(lit)
else:
lang = match.groups()[1]
# check if this is a correct language tag. Note that can raise an exception!
try:
lang = _strToVal_Regexp(lang, _re_language)
return Literal(lit, lang=lang.lower())
except:
raise ValueError("Invalid plain literal %s" % v)
#####################################################################################
# Replacement of RDFLib's conversion function. Each entry assigns a function to an XSD datatype, attempting to convert
# a string to a Python datatype (or raise an exception if some problem is found)
AltXSDToPYTHON = {
XSD.language: lambda v: _strToVal_Regexp(v, _re_language),
XSD.NMTOKEN: lambda v: _strToVal_Regexp(v, _re_NMTOKEN, re.U),
XSD.Name: lambda v: _strToVal_Regexp(v, _re_NMTOKEN, re.U, _re_Name_ex),
XSD.NCName: lambda v: _strToVal_Regexp(v, _re_NCName, re.U, _re_NCName_ex),
XSD.token: _strToToken,
RDF.PlainLiteral: _strToPlainLiteral,
XSD.boolean: _strToBool,
XSD.decimal: _strToDecimal,
XSD.anyURI: _strToAnyURI,
XSD.base64Binary: _strToBase64Binary,
XSD.double: _strToDouble,
XSD.float: _strToFloat,
XSD.byte: lambda v: _strToBoundNumeral(v, _limits_byte, int),
XSD.int: lambda v: _strToBoundNumeral(v, _limits_int, int),
XSD.long: lambda v: _strToBoundNumeral(v, _limits_long, int),
XSD.positiveInteger: lambda v: _strToBoundNumeral(v, _limits_positiveInteger, int),
XSD.nonPositiveInteger: lambda v: _strToBoundNumeral(
v, _limits_nonPositiveInteger, int
),
XSD.negativeInteger: lambda v: _strToBoundNumeral(v, _limits_negativeInteger, int),
XSD.nonNegativeInteger: lambda v: _strToBoundNumeral(
v, _limits_nonNegativeInteger, int
),
XSD.short: lambda v: _strToBoundNumeral(v, _limits_short, int),
XSD.unsignedByte: lambda v: _strToBoundNumeral(v, _limits_unsignedByte, int),
XSD.unsignedShort: lambda v: _strToBoundNumeral(v, _limits_unsignedShort, int),
XSD.unsignedInt: lambda v: _strToBoundNumeral(v, _limits_unsignedInt, int),
XSD.unsignedLong: lambda v: _strToBoundNumeral(v, _limits_unsignedLong, int),
XSD.hexBinary: _strToHexBinary,
XSD.dateTime: lambda v: _strToDateTimeAndStamp(v, False),
XSD.dateTimeStamp: lambda v: _strToDateTimeAndStamp(v, True),
RDF.XMLLiteral: _strToXMLLiteral,
XSD.integer: int,
XSD.string: lambda v: v,
RDF.HTML: lambda v: v,
XSD.normalizedString: lambda v: _strToVal_Regexp(v, _re_token),
# These are RDFS specific...
XSD.time: _strToTime,
XSD.date: _strToDate,
XSD.gYearMonth: _strTogYearMonth,
XSD.gYear: _strTogYear,
XSD.gMonthDay: _strTogMonthDay,
XSD.gDay: _strTogDay,
XSD.gMonth: _strTogMonth,
}
def use_Alt_lexical_conversions():
"""
Registering the datatypes item for RDFLib, ie, bind the dictionary values. The 'bind' method of RDFLib adds
extra datatypes to the registered ones in RDFLib, though the table used here (I.e., :code:`AltXSDToPYTHON`) actually
overrides all of the default conversion routines. The method also add a Decimal entry to the :code:`PythonToXSD` list of
RDFLib.
"""
_toPythonMapping.update(AltXSDToPYTHON)
def use_RDFLib_lexical_conversions():
"""
Restore the original (ie, RDFLib) set of lexical conversion routines.
"""
_toPythonMapping.update(XSDToPython)
#######################################################################################
# This module can pretty much tested individually...
if __name__ == "__main__":
import sys
dtype = sys.argv[1]
string = sys.argv[2]
datatype = XSD[dtype]
result = AltXSDToPYTHON[datatype](string)
print(type(result))
print(result)
OWL-RL-7.1.4/owlrl/Namespaces.py 0000664 0000000 0000000 00000000203 15042011661 0016256 0 ustar 00root root 0000000 0000000 from rdflib import Namespace
ERRNS = Namespace("http://www.daml.org/2002/03/agents/agent-ont#")
T = Namespace("http://test.org/")
OWL-RL-7.1.4/owlrl/OWLRL.py 0000775 0000000 0000000 00000127720 15042011661 0015117 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
This module is a **brute force** implementation of the OWL 2 RL profile.
RDFLib works with 'generalized' RDF, meaning that triples with a BNode predicate are *allowed*. This is good because,
e.g., some of the triples generated for RDF from an OWL 2 functional syntax might look like :code:`[ owl:inverseOf p ]`, and the
RL rules would then operate on such generalized triple. However, as a last, post processing steps, these triples are
removed from the graph before serialization to produce 'standard' RDF (which is o.k. for RL, too, because the
consequent triples are all right, generalized triples might have had a role in the deduction steps only).
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from collections import defaultdict
from typing import Union
import rdflib
from rdflib import BNode, Graph
from rdflib.namespace import OWL, RDF, RDFS
from owlrl.Closure import Core
from owlrl.AxiomaticTriples import OWLRL_Axiomatic_Triples, OWLRL_D_Axiomatic_Triples
from owlrl.AxiomaticTriples import OWLRL_Datatypes_Disjointness
OWLRL_Annotation_properties = [
RDFS.label,
RDFS.comment,
RDFS.seeAlso,
RDFS.isDefinedBy,
OWL.deprecated,
OWL.versionInfo,
OWL.priorVersion,
OWL.backwardCompatibleWith,
OWL.incompatibleWith,
]
from .XsdDatatypes import OWL_RL_Datatypes, OWL_Datatype_Subsumptions
from .DatatypeHandling import AltXSDToPYTHON
identity = lambda v: v
#######################################################################################################################
# OWL-R Semantics class
#
#
# As an editing help: each rule is prefixed by RULE XXXX where XXXX is the acronym given in the profile document.
# This helps in referring back to the spec...
# noinspection PyPep8Naming, PyPep8Naming, PyBroadException
class OWLRL_Semantics(Core):
"""
OWL 2 RL Semantics class, i.e., implementation of the OWL 2 RL closure graph.
.. note:: Note that the module does *not* implement the so called Datatype entailment rules, simply because the underlying
RDFLib does not implement the datatypes (i.e., RDFLib will not make the literal "1.00" and "1.00000" identical,
although even with all the ambiguities on datatypes, this *should* be made equal...).
Also, the so-called extensional entailment rules (Section 7.3.1 in the RDF Semantics document) have not been
implemented either.
The comments and references to the various rule follow the names as used in the `OWL 2 RL
document`_.
.. _OWL 2 RL document: http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules
:param graph: The RDF graph to be extended.
:type graph: :class:`rdflib.Graph`
:param axioms: Whether (non-datatype) axiomatic triples should be added or not.
:type axioms: bool
:param daxioms: Whether datatype axiomatic triples should be added or not.
:type daxioms: bool
:param rdfs: Whether RDFS inference is also done (used in subclassed only).
:type rdfs: bool
"""
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = False, destination: Union[None, Graph] = None):
"""
@param graph: the RDF graph to be extended
@type graph: rdflib.Graph
@param axioms: whether (non-datatype) axiomatic triples should be added or not
@type axioms: bool
@param daxioms: whether datatype axiomatic triples should be added or not
@type daxioms: bool
@param rdfs: whether RDFS inference is also done (used in subclassed only)
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: rdflib.Graph
"""
Core.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
self.bnodes = []
def _list(self, l):
"""
Shorthand to get a list of values (ie, from an rdf:List structure) starting at a head
@param l: RDFLib resource, should be the head of an rdf:List
@return: array of resources
"""
return [ch for ch in self.graph.items(l)]
def post_process(self):
"""
Remove triples with Bnode predicates. The Bnodes in the graph are collected in the first cycle run.
"""
to_be_removed = []
for b in self.bnodes:
for t in self.graph.triples((None, b, None)):
if t not in to_be_removed:
to_be_removed.append(t)
for t in to_be_removed:
self.destination.remove(t)
self.graph.remove(t)
def add_axioms(self):
"""
Add axioms
"""
for t in OWLRL_Axiomatic_Triples:
self.destination.add(t)
def add_d_axioms(self):
"""
Add the datatype axioms
"""
for t in OWLRL_D_Axiomatic_Triples:
self.destination.add(t)
def restriction_typing_check(self, v, t):
"""
Helping method to check whether a type statement is in line with a possible
restriction. This method is invoked by rule "cls-avf" before setting a type
on an allValuesFrom restriction.
The method is a placeholder at this level. It is typically implemented by subclasses for
extra checks, e.g., for datatype facet checks.
:param v: The resource that is to be 'typed'.
:param t: The targeted type (ie, Class).
:return: Boolean.
:rtype: bool
"""
return True
def _one_time_rules_datatypes(self):
"""
Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only
once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once
at the beginning of the process.
These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2, dt-eq, dt-diff.
.. note:: Note, however, that the dt-* are executed only partially, limited by the possibilities offered by RDFLib. These
may not cover all the edge cases of OWL RL. Especially, dt-not-type has not (yet?) been implemented (I wonder
whether RDFLib should not raise exception for those anyway...
"""
# noinspection PyShadowingNames
def _add_to_explicit(s, o):
explicit[s].add(o)
# noinspection PyShadowingNames
def _append_to_explicit(s, o):
explicit[s].add(o)
# noinspection PyShadowingNames
def _handle_subsumptions(r, dt):
if dt in OWL_Datatype_Subsumptions:
for new_dt in OWL_Datatype_Subsumptions[dt]:
self.store_triple((r, RDF.type, new_dt))
self.store_triple((new_dt, RDF.type, RDFS.Datatype))
used_datatypes.add(new_dt)
# explicit object->datatype relationships: those that came from an object being typed as a datatype
# or a sameAs. The values are arrays of datatypes to which the resource belong
explicit = defaultdict(set)
# For processing later:
# implicit object->datatype relationships: these come from real
# literals which are present in the graph
implicit = {
o: o.datatype
for s, p, o in self.graph.triples((None, None, None))
if isinstance(o, rdflib.Literal) and o.datatype in OWL_RL_Datatypes
}
# datatypes in use by the graph (directly or indirectly). This will be used at the end to add the
# necessary disjointness statements (but not more)
used_datatypes = set(implicit.values())
# RULE dt-type2: for all explicit literals the corresponding bnode should get the right type
# definition. The 'implicit' dictionary is also filled on the fly
# RULE dt-not-type: see whether an explicit literal is valid in terms of the defined datatype
for lt in implicit: # note that all non-RL datatypes are ignored
# add the explicit typing triple
self.store_triple((lt, RDF.type, lt.datatype))
# for dt-not-type
# This is a dirty trick: rdflib's Literal includes a method that raises an exception if the
# lexical value cannot be mapped on the value space.
converter = AltXSDToPYTHON.get(lt.datatype, identity)
try:
converter(str(lt))
except ValueError:
self.add_error(
"Lexical value of the literal '%s' does not match"
" its datatype (%s)" % (lt, lt.datatype)
)
# RULE dt-diff
# RULE dt-eq
# Compare literals whether they are different or not. This rules
# are skipped on purpose at the moment.
# Other datatype definitions can come from explicitly defining some nodes as datatypes (though rarely used,
# it is perfectly possible...
# there may be explicit relationships set in the graph, too!
for (s, p, o) in self.graph.triples((None, RDF.type, None)):
if o in OWL_RL_Datatypes:
used_datatypes.add(o)
if s not in implicit:
_add_to_explicit(s, o)
# Finally, there may be sameAs statements that bind nodes to some of the existing ones. This does not introduce
# new datatypes, so the used_datatypes array does not get extended
for (s, p, o) in self.graph.triples((None, OWL.sameAs, None)):
if o in implicit:
_add_to_explicit(s, implicit[o])
# note that s in implicit would mean that the original graph has
# a literal in subject position which is not allowed at the moment, so I do not bother
if o in explicit:
_append_to_explicit(s, o)
if s in explicit:
_append_to_explicit(o, s)
# what we have now:
# explicit+implicit contains all the resources of type datatype;
# implicit contains those that are given by an explicit literal
# explicit contains those that are given by general resources, and there can be a whole array for each entry
# RULE dt-type1: add a Datatype typing for all those
# Note: the strict interpretation of OWL RL is to do that for all allowed datatypes, but this is
# under discussion right now. The optimized version uses only what is really in use
for dt in OWL_RL_Datatypes:
self.store_triple((dt, RDF.type, RDFS.Datatype))
for dts in explicit.values():
for dt in dts:
self.store_triple((dt, RDF.type, RDFS.Datatype))
# Datatype reasoning means that certain datatypes are subtypes of one another.
# I could simply generate the extra subclass relationships into the graph and let the generic
# process work its way, but it seems to be an overkill. Instead, I prefer to add the explicit typing
# into the graph 'manually'
for r in explicit:
# these are the datatypes that this resource has
dtypes = explicit[r]
for dt in dtypes:
_handle_subsumptions(r, dt)
for r, dt in implicit.items():
_handle_subsumptions(r, dt)
# Last step: add the datatype disjointness relationships. This is done only for
# - 'top' level datatypes
# - used in the graph
for t in OWLRL_Datatypes_Disjointness:
(l, pred, r) = t
if l in used_datatypes and r in used_datatypes:
self.store_triple(t)
def _one_time_rules_misc(self):
"""
Rules executed: cls-thing, cls-nothing, prp-ap.
"""
# RULE cls-thing
self.store_triple((OWL.Thing, RDF.type, OWL.Class))
# RULE cls-nothing
self.store_triple((OWL.Nothing, RDF.type, OWL.Class))
# RULE prp-ap
for an in OWLRL_Annotation_properties:
self.store_triple((an, RDF.type, OWL.AnnotationProperty))
def one_time_rules(self):
"""
Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only
once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once
at the beginning of the process.
These are: cls-thing, cls-nothing1, prp-ap, dt-types1, dt-types2, dt-eq, dt-diff.
"""
self._one_time_rules_misc()
self._one_time_rules_datatypes()
def rules(self, t, cycle_num):
"""
Go through the various rule groups, as defined in the OWL-RL profile text and implemented via
local methods. (The calling cycle takes every tuple in the graph.)
:param t: A triple (in the form of a tuple).
:param cycle_num: Which cycle are we in, starting with 1. This value is forwarded to all local rules; it is
also used locally to collect the bnodes in the graph.
"""
if cycle_num == 1:
for r in t:
if isinstance(r, BNode) and r not in self.bnodes:
self.bnodes.append(r)
self._properties(t, cycle_num)
self._equality(t, cycle_num)
self._classes(t, cycle_num)
self._class_axioms(t, cycle_num)
self._schema_vocabulary(t, cycle_num)
def _property_chain(self, p, x):
"""
Implementation of the property chain axiom, invoked from inside the property axiom handler. This is the
implementation of rule prp-spo2, taken aside for an easier readability of the code."""
chain = self._list(x)
# The complication is that, at each step of the chain, there may be spawns, leading to a multitude
# of 'sub' chains:-(
if len(chain) > 0:
for (u1, _y, _z) in self.graph.triples((None, chain[0], None)):
# At least the chain can be started, because the leftmost property has at least
# one element in its extension
finalList = [(u1, _z)]
chainExists = True
for pi in chain[1:]:
newList = []
for (_u, ui) in finalList:
for u in self.graph.objects(ui, pi):
# what is stored is only last entry with u1, the intermediate results
# are not of interest
newList.append((u1, u))
# I have now, in new list, all the intermediate results
# until pi
# if new list is empty, that means that is a blind alley
if len(newList) == 0:
chainExists = False
break
else:
finalList = newList
if chainExists:
for (_u, un) in finalList:
self.store_triple((u1, p, un))
def _equality(self, triple, cycle_num):
"""
Table 4: Semantics of equality. Essentially, the eq-* rules.
@param triple: triple to work on
@param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.
"""
# In many of the 'if' branches, corresponding to rules in the document,
# the branch begins by a renaming of variables (eg, pp, c = s, o).
# There is no programming reasons for doing that, but by renaming the
# variables it becomes easier to compare the declarative rules
# in the document with the implementation
s, p, o = triple
# RULE eq-ref
self.store_triple((s, OWL.sameAs, s))
self.store_triple((o, OWL.sameAs, o))
self.store_triple((p, OWL.sameAs, p))
if p == OWL.sameAs:
x, y = s, o
# RULE eq-sym
self.store_triple((y, OWL.sameAs, x))
# RULE eq-trans
for z in self.graph.objects(y, OWL.sameAs):
self.store_triple((x, OWL.sameAs, z))
# RULE eq-rep-s
for pp, oo in self.graph.predicate_objects(s):
self.store_triple((o, pp, oo))
# RULE eq-rep-p
for ss, oo in self.graph.subject_objects(s):
self.store_triple((ss, o, oo))
# RULE eq-rep-o
for ss, pp in self.graph.subject_predicates(o):
self.store_triple((ss, pp, s))
# RULE eq-diff1
if (s, OWL.differentFrom, o) in self.graph or (
o,
OWL.differentFrom,
s,
) in self.graph:
self.add_error(
"'sameAs' and 'differentFrom' cannot be used on the same subject-object pair: (%s, %s)"
% (s, o)
)
# RULES eq-diff2 and eq-diff3
if p == RDF.type and o == OWL.AllDifferent:
x = s
# the objects method are generators, we cannot simply concatenate them. So we turn the results
# into lists first. (Otherwise the body of the for loops should be repeated verbatim, which
# is silly and error prone...
m1 = [i for i in self.graph.objects(x, OWL.members)]
m2 = [i for i in self.graph.objects(x, OWL.distinctMembers)]
for y in m1 + m2:
zis = self._list(y)
for i in range(0, len(zis) - 1):
zi = zis[i]
for j in range(i + 1, len(zis) - 1):
zj = zis[j]
if (
(zi, OWL.sameAs, zj) in self.graph
or (zj, OWL.sameAs, zi) in self.graph
) and zi != zj:
self.add_error(
"'sameAs' and 'AllDifferent' cannot be used on the same subject-object "
"pair: (%s, %s)" % (zi, zj)
)
def _properties(self, triple, cycle_num):
"""
Table 5: The Semantics of Axioms about Properties. Essentially, the prp-* rules.
@param triple: triple to work on
@param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.
"""
# In many of the 'if' branches, corresponding to rules in the document,
# the branch begins by a renaming of variables (eg, pp, c = s, o).
# There is no programming reasons for doing that, but by renaming the
# variables it becomes easier to compare the declarative rules
# in the document with the implementation
p, t, o = triple
# RULE prp-ap
if cycle_num == 1 and t in OWLRL_Annotation_properties:
self.store_triple((t, RDF.type, OWL.AnnotationProperty))
# RULE prp-dom
if t == RDFS.domain:
for x, y in self.graph.subject_objects(p):
self.store_triple((x, RDF.type, o))
# RULE prp-rng
elif t == RDFS.range:
for x, y in self.graph.subject_objects(p):
self.store_triple((y, RDF.type, o))
elif t == RDF.type:
# RULE prp-fp
if o == OWL.FunctionalProperty:
# Property axiom #3
for x, y1 in self.graph.subject_objects(p):
for y2 in self.graph.objects(x, p):
# Optimization: if the two resources are identical, the samAs is already
# taken place somewhere else, unnecessary to add it here
if y1 != y2:
self.store_triple((y1, OWL.sameAs, y2))
# RULE prp-ifp
elif o == OWL.InverseFunctionalProperty:
for x1, y in self.graph.subject_objects(p):
for x2 in self.graph.subjects(p, y):
# Optimization: if the two resources are identical, the samAs is already
# taken place somewhere else, unnecessary to add it here
if x1 != x2:
self.store_triple((x1, OWL.sameAs, x2))
# RULE prp-irp
elif o == OWL.IrreflexiveProperty:
for x, y in self.graph.subject_objects(p):
if x == y:
self.add_error(
"Irreflexive property used on %s with %s" % (x, p)
)
# RULE prp-symp
elif o == OWL.SymmetricProperty:
for x, y in self.graph.subject_objects(p):
self.store_triple((y, p, x))
# RULE prp-asyp
elif o == OWL.AsymmetricProperty:
for x, y in self.graph.subject_objects(p):
if (y, p, x) in self.graph:
self.add_error(
"Erroneous usage of asymmetric property %s on %s and %s"
% (p, x, y)
)
# RULE prp-trp
elif o == OWL.TransitiveProperty:
for x, y in self.graph.subject_objects(p):
for z in self.graph.objects(y, p):
self.store_triple((x, p, z))
#
# Breaking the order here, I take some additional rules here to the branch checking the type...
#
# RULE prp-adp
elif o == OWL.AllDisjointProperties:
x = p
for y in self.graph.objects(x, OWL.members):
pis = self._list(y)
for i in range(0, len(pis) - 1):
pi = pis[i]
for j in range(i + 1, len(pis) - 1):
pj = pis[j]
for x, y in self.graph.subject_objects(pi):
if (x, pj, y) in self.graph:
self.add_error(
"Disjoint properties in an 'AllDisjointProperties' are not really "
"disjoint: (%s, %s,%s) and (%s,%s,%s)"
% (x, pi, y, x, pj, y)
)
# RULE prp-spo1
elif t == RDFS.subPropertyOf:
p1, p2 = p, o
for x, y in self.graph.subject_objects(p1):
self.store_triple((x, p2, y))
# RULE prp-spo2
elif t == OWL.propertyChainAxiom:
self._property_chain(p, o)
# RULES prp-eqp1 and prp-eqp2
elif t == OWL.equivalentProperty:
p1, p2 = p, o
# Optimization: it clearly does not make sense to run these
# if the two properties are identical (a separate axiom
# does create an equivalent property relations among identical
# properties, too...)
if p1 != p2:
# RULE prp-eqp1
for x, y in self.graph.subject_objects(p1):
self.store_triple((x, p2, y))
# RULE prp-eqp2
for x, y in self.graph.subject_objects(p2):
self.store_triple((x, p1, y))
# RULE prp-pdw
elif t == OWL.propertyDisjointWith:
p1, p2 = p, o
for x, y in self.graph.subject_objects(p1):
if (x, p2, y) in self.graph:
self.add_error(
"Erroneous usage of disjoint properties %s and %s on %s and %s"
% (p1, p2, x, y)
)
# RULES prp-inv1 and prp-inv2
elif t == OWL.inverseOf:
p1, p2 = p, o
# RULE prp-inv1
for x, y in self.graph.subject_objects(p1):
self.store_triple((y, p2, x))
# RULE prp-inv2
for x, y in self.graph.subject_objects(p2):
self.store_triple((y, p1, x))
# RULE prp-key
elif t == OWL.hasKey:
c, u = p, o
pis = self._list(u)
if len(pis) > 0:
for x in self.graph.subjects(RDF.type, c):
# "Calculate" the keys for 'x'. The complication is that there can be various combinations
# of the keys, and that is the structure one has to build up here...
#
# The final list will be a list of lists, with each constituents being the possible combinations
# of the key values.
# startup the list
finalList = [[zi] for zi in self.graph.objects(x, pis[0])]
for pi in pis[1:]:
newList = []
for zi in self.graph.objects(x, pi):
newList = newList + [l + [zi] for l in finalList]
finalList = newList
# I am not sure this can happen, but better safe then sorry... ruling out
# the value lists whose length are not kosher
# (To be checked whether this is necessary in the first place)
valueList = [l for l in finalList if len(l) == len(pis)]
# Now we can look for the y-s, to see if they have the same key values
for y in self.graph.subjects(RDF.type, c):
# rule out the existing equivalences
if not (
y == x
or (y, OWL.sameAs, x) in self.graph
or (x, OWL.sameAs, y) in self.graph
):
# 'calculate' the keys for the y values and see if there is a match
for vals in valueList:
same = True
for i in range(0, len(pis) - 1):
if (y, pis[i], vals[i]) not in self.graph:
same = False
# No use going with this property line
break
if same:
self.store_triple((x, OWL.sameAs, y))
# Look for the next 'y', this branch is finished, no reason to continue
break
# RULES prp-npa1 and prp-npa2
elif t == OWL.sourceIndividual:
x, i1 = p, o
for p1 in self.graph.objects(x, OWL.assertionProperty):
for i2 in self.graph.objects(x, OWL.targetIndividual):
if (i1, p1, i2) in self.graph:
self.add_error(
"Negative (object) property assertion violated for: (%s, %s, %s)"
% (i1, p1, i2)
)
for i2 in self.graph.objects(x, OWL.targetValue):
if (i1, p1, i2) in self.graph:
self.add_error(
"Negative (datatype) property assertion violated for: (%s, %s, %s)"
% (i1, p1, i2)
)
def _classes(self, triple, cycle_num):
"""
Table 6: The Semantics of Classes. Essentially, the cls-* rules
@param triple: triple to work on
@param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.
"""
# In many of the 'if' branches, corresponding to rules in the document,
# the branch begins by a renaming of variables (eg, pp, c = s, o).
# There is no programming reasons for doing that, but by renaming the
# variables it becomes easier to compare the declarative rules
# in the document with the implementation
c, p, x = triple
# RULE cls-nothing2
if p == RDF.type and x == OWL.Nothing:
self.add_error("%s is defined of type 'Nothing'" % c)
# RULES cls-int1 and cls-int2
if p == OWL.intersectionOf:
classes = self._list(x)
# RULE cls-int1
# Optimization: by looking at the members of class[0] right away one
# reduces the search spaces a bit. Individuals not in that class
# are without interest anyway
# I am not sure how empty lists are sanctioned, so having an extra check
# on that does not hurt..
if len(classes) > 0:
for y in self.graph.subjects(RDF.type, classes[0]):
if False not in [
(y, RDF.type, cl) in self.graph for cl in classes[1:]
]:
self.store_triple((y, RDF.type, c))
# RULE cls-int2
for y in self.graph.subjects(RDF.type, c):
for cl in classes:
self.store_triple((y, RDF.type, cl))
# RULE cls-uni
elif p == OWL.unionOf:
for cl in self._list(x):
for y in self.graph.subjects(RDF.type, cl):
self.store_triple((y, RDF.type, c))
# RULE cls-comm
elif p == OWL.complementOf:
c1, c2 = c, x
for x1 in self.graph.subjects(RDF.type, c1):
if (x1, RDF.type, c2) in self.graph:
self.add_error(
"Violation of complementarity for classes %s and %s on element %s"
% (c1, c2, x)
)
# RULES cls-svf1 and cls=svf2
elif p == OWL.someValuesFrom:
xx, y = c, x
# RULE cls-svf1
# RULE cls-svf2
for pp in self.graph.objects(xx, OWL.onProperty):
for u, v in self.graph.subject_objects(pp):
if y == OWL.Thing or (v, RDF.type, y) in self.graph:
self.store_triple((u, RDF.type, xx))
# RULE cls-avf
elif p == OWL.allValuesFrom:
xx, y = c, x
for pp in self.graph.objects(xx, OWL.onProperty):
for u in self.graph.subjects(RDF.type, xx):
for v in self.graph.objects(u, pp):
if self.restriction_typing_check(v, y):
self.store_triple((v, RDF.type, y))
else:
self.add_error(
"Violation of type restriction for allValuesFrom in %s for datatype %s on "
"value %s" % (pp, y, v)
)
# RULES cls-hv1 and cls-hv2
elif p == OWL.hasValue:
xx, y = c, x
for pp in self.graph.objects(xx, OWL.onProperty):
# RULE cls-hv1
for u in self.graph.subjects(RDF.type, xx):
self.store_triple((u, pp, y))
# RULE cls-hv2
for u in self.graph.subjects(pp, y):
self.store_triple((u, RDF.type, xx))
# RULES cls-maxc1 and cls-maxc1
elif p == OWL.maxCardinality:
# This one is a bit complicated, because the literals have been
# exchanged against bnodes...
#
# The construct should lead to an integer. Something may go wrong along the line
# leading to an exception...
xx = c
if x.value == 0:
# RULE cls-maxc1
for pp in self.graph.objects(xx, OWL.onProperty):
for u, y in self.graph.subject_objects(pp):
# This should not occur:
if (u, RDF.type, xx) in self.graph:
self.add_error(
"Erroneous usage of maximum cardinality with %s and %s"
% (xx, y)
)
elif x.value == 1:
# RULE cls-maxc2
for pp in self.graph.objects(xx, OWL.onProperty):
for u, y1 in self.graph.subject_objects(pp):
if (u, RDF.type, xx) in self.graph:
for y2 in self.graph.objects(u, pp):
if y1 != y2:
self.store_triple((y1, OWL.sameAs, y2))
# RULES cls-maxqc1, cls-maxqc2, cls-maxqc3, cls-maxqc4
elif p == OWL.maxQualifiedCardinality:
# This one is a bit complicated, because the literals have been
# exchanged against bnodes...
#
# The construct should lead to an integer. Something may go wrong along the line
# leading to an exception...
xx = c
if x.value == 0:
# RULES cls-maxqc1 and cls-maxqc2 folded in one
for pp in self.graph.objects(xx, OWL.onProperty):
for cc in self.graph.objects(xx, OWL.onClass):
for u, y in self.graph.subject_objects(pp):
# This should not occur:
if (
(y, RDF.type, cc) in self.graph or cc == OWL.Thing
) and (u, RDF.type, xx) in self.graph:
self.add_error(
"Erroneous usage of maximum qualified cardinality with %s, %s and %s"
% (xx, cc, y)
)
elif x.value == 1:
# RULE cls-maxqc3 and cls-maxqc4 folded in one
for pp in self.graph.objects(xx, OWL.onProperty):
for cc in self.graph.objects(xx, OWL.onClass):
for u, y1 in self.graph.subject_objects(pp):
if (u, RDF.type, xx) in self.graph:
if cc == OWL.Thing:
for y2 in self.graph.objects(u, pp):
if y1 != y2:
self.store_triple((y1, OWL.sameAs, y2))
else:
if (y1, RDF.type, cc) in self.graph:
for y2 in self.graph.objects(u, pp):
if (
y1 != y2
and (y2, RDF.type, cc) in self.graph
):
self.store_triple((y1, OWL.sameAs, y2))
# TODO: what if x.value not in (0, 1)? according to the spec
# the cardinality shall be no more than 1, so add an # error?
# RULE cls-oo
elif p == OWL.oneOf:
for y in self._list(x):
self.store_triple((y, RDF.type, c))
def _class_axioms(self, triple, cycle_num):
"""
Table 7: Class Axioms. Essentially, the cax-* rules.
@param triple: triple to work on
@param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.
"""
# In many of the 'if' branches, corresponding to rules in the document,
# the branch begins by a renaming of variables (eg, pp, c = s, o).
# There is no programming reasons for doing that, but by renaming the
# variables it becomes easier to compare the declarative rules
# in the document with the implementation
c1, p, c2 = triple
# RULE cax-sco
if p == RDFS.subClassOf:
# Other axioms sets classes to be subclasses of themselves, to one can optimize the trivial case
if c1 != c2:
for x in self.graph.subjects(RDF.type, c1):
self.store_triple((x, RDF.type, c2))
# RULES cax-eqc1 and cax-eqc1
# Other axioms set classes to be equivalent to themselves, one can optimize the trivial case
elif p == OWL.equivalentClass and c1 != c2:
# RULE cax-eqc1
for x in self.graph.subjects(RDF.type, c1):
self.store_triple((x, RDF.type, c2))
# RULE cax-eqc1
for x in self.graph.subjects(RDF.type, c2):
self.store_triple((x, RDF.type, c1))
# RULE cax-dw
elif p == OWL.disjointWith:
for x in self.graph.subjects(RDF.type, c1):
if (x, RDF.type, c2) in self.graph:
self.add_error(
"Disjoint classes %s and %s have a common individual %s"
% (c1, c2, x)
)
# RULE cax-adc
elif p == RDF.type and c2 == OWL.AllDisjointClasses:
x = c1
for y in self.graph.objects(x, OWL.members):
classes = self._list(y)
if len(classes) > 0:
for i in range(0, len(classes) - 1):
cl1 = classes[i]
for z in self.graph.subjects(RDF.type, cl1):
for cl2 in classes[(i + 1) :]:
if (z, RDF.type, cl2) in self.graph:
self.add_error(
"Disjoint classes %s and %s have a common individual %s"
% (cl1, cl2, z)
)
def _schema_vocabulary(self, triple, cycle_num):
"""
Table 9: The Semantics of Schema Vocabulary. Essentially, the scm-* rules
@param triple: triple to work on
@param cycle_num: which cycle are we in, starting with 1. Can be used for some optimization.
"""
# In many of the 'if' branches, corresponding to rules in the document,
# the branch begins by a renaming of variables (eg, pp, c = s, o).
# There is no programming reasons for doing that, but by renaming the
# variables it becomes easier to compare the declarative rules
# in the document with the implementation
s, p, o = triple
# RULE scm-cls
if p == RDF.type and o == OWL.Class:
c = s
self.store_triple((c, RDFS.subClassOf, c))
self.store_triple((c, OWL.equivalentClass, c))
self.store_triple((c, RDFS.subClassOf, OWL.Thing))
self.store_triple((OWL.Nothing, RDFS.subClassOf, c))
# RULE scm-sco
# Rule scm-eqc2
elif p == RDFS.subClassOf:
c1, c2 = s, o
# RULE scm-sco
# Optimize out the trivial identity case (set elsewhere already)
if c1 != c2:
for c3 in self.graph.objects(c2, RDFS.subClassOf):
# Another axiom already sets that...
if c1 != c3:
self.store_triple((c1, RDFS.subClassOf, c3))
# RULE scm-eqc2
if (c2, RDFS.subClassOf, c1) in self.graph:
self.store_triple((c1, OWL.equivalentClass, c2))
# RULE scm-eqc
elif p == OWL.equivalentClass and s != o:
c1, c2 = s, o
self.store_triple((c1, RDFS.subClassOf, c2))
self.store_triple((c2, RDFS.subClassOf, c1))
# RULE scm-op and RULE scm-dp folded together
# There is a bit of a cheating here: 'Property' is not, strictly speaking, in the rule set!
elif p == RDF.type and (
o == OWL.ObjectProperty or o == OWL.DatatypeProperty or o == RDF.Property
):
pp = s
self.store_triple((pp, RDFS.subPropertyOf, pp))
self.store_triple((pp, OWL.equivalentProperty, pp))
# RULE scm-spo
# RULE scm-eqp2
elif p == RDFS.subPropertyOf and s != o:
p1, p2 = s, o
# Optimize out the trivial identity case (set elsewhere already)
# RULE scm-spo
if p1 != p2:
for p3 in self.graph.objects(p2, RDFS.subPropertyOf):
if p1 != p3:
self.store_triple((p1, RDFS.subPropertyOf, p3))
# RULE scm-eqp2
if (p2, RDFS.subPropertyOf, p1) in self.graph:
self.store_triple((p1, OWL.equivalentProperty, p2))
# RULE scm-eqp
# Optimize out the trivial identity case (set elsewhere already)
elif p == OWL.equivalentProperty and s != o:
p1, p2 = s, o
self.store_triple((p1, RDFS.subPropertyOf, p2))
self.store_triple((p2, RDFS.subPropertyOf, p1))
# RULES scm-dom1 and scm-dom2
elif p == RDFS.domain:
# RULE scm-dom1
pp, c1 = s, o
for (_x, _y, c2) in self.graph.triples((c1, RDFS.subClassOf, None)):
if c1 != c2:
self.store_triple((pp, RDFS.domain, c2))
# RULE scm-dom1
p2, c = s, o
for (p1, _x, _y) in self.graph.triples((None, RDFS.subPropertyOf, p2)):
if p1 != p2:
self.store_triple((p1, RDFS.domain, c))
# RULES scm-rng1 and scm-rng2
elif p == RDFS.range:
# RULE scm-rng1
pp, c1 = s, o
for (_x, _y, c2) in self.graph.triples((c1, RDFS.subClassOf, None)):
if c1 != c2:
self.store_triple((pp, RDFS.range, c2))
# RULE scm-rng1
p2, c = s, o
for (p1, _x, _y) in self.graph.triples((None, RDFS.subPropertyOf, p2)):
if p1 != p2:
self.store_triple((p1, RDFS.range, c))
# RULE scm-hv
elif p == OWL.hasValue:
c1, i = s, o
for p1 in self.graph.objects(c1, OWL.onProperty):
for c2 in self.graph.subjects(OWL.hasValue, i):
for p2 in self.graph.objects(c2, OWL.onProperty):
if (p1, RDFS.subPropertyOf, p2) in self.graph:
self.store_triple((c1, RDFS.subClassOf, c2))
# RULES scm-svf1 and scm-svf2
elif p == OWL.someValuesFrom:
# RULE scm-svf1
c1, y1 = s, o
for pp in self.graph.objects(c1, OWL.onProperty):
for c2 in self.graph.subjects(OWL.onProperty, pp):
for y2 in self.graph.objects(c2, OWL.someValuesFrom):
if (y1, RDFS.subClassOf, y2) in self.graph:
self.store_triple((c1, RDFS.subClassOf, c2))
# RULE scm-svf2
c1, y = s, o
for p1 in self.graph.objects(c1, OWL.onProperty):
for c2 in self.graph.subjects(OWL.someValuesFrom, y):
for p2 in self.graph.objects(c2, OWL.onProperty):
if (p1, RDFS.subPropertyOf, p2) in self.graph:
self.store_triple((c1, RDFS.subClassOf, c2))
# RULES scm-avf1 and scm-avf2
elif p == OWL.allValuesFrom:
# RULE scm-avf1
c1, y1 = s, o
for pp in self.graph.objects(c1, OWL.onProperty):
for c2 in self.graph.subjects(OWL.onProperty, pp):
for y2 in self.graph.objects(c2, OWL.allValuesFrom):
if (y1, RDFS.subClassOf, y2) in self.graph:
self.store_triple((c1, RDFS.subClassOf, c2))
# RULE scm-avf2
c1, y = s, o
for p1 in self.graph.objects(c1, OWL.onProperty):
for c2 in self.graph.subjects(OWL.allValuesFrom, y):
for p2 in self.graph.objects(c2, OWL.onProperty):
if (p1, RDFS.subPropertyOf, p2) in self.graph:
self.store_triple((c2, RDFS.subClassOf, c1))
# RULE scm-int
elif p == OWL.intersectionOf:
c, x = s, o
for ci in self._list(x):
self.store_triple((c, RDFS.subClassOf, ci))
# RULE scm-uni
elif p == OWL.unionOf:
c, x = s, o
for ci in self._list(x):
self.store_triple((ci, RDFS.subClassOf, c))
OWL-RL-7.1.4/owlrl/OWLRLExtras.py 0000775 0000000 0000000 00000037246 15042011661 0016311 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
Extension to OWL 2 RL, ie, some additional rules added to the system from OWL 2 Full. It is implemented through
the :class:`.OWLRL_Extension` class, whose reference has to be passed to the relevant semantic class (i.e., either the OWL 2 RL
or the combined closure class) as an 'extension'.
The added rules and features are:
- self restriction
- owl:rational datatype
- datatype restrictions via facets
In more details, the rules that are added:
1. self restriction 1: :code:`?z owl:hasSelf ?x. ?x owl:onProperty ?p. ?y rdf:type ?z. => ?y ?p ?y.`
2. self restriction 2: :code:`?z owl:hasSelf ?x. ?x owl:onProperty ?p. ?y ?p ?y. => ?y rdf:type ?z.`
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from typing import Union
import rdflib
from rdflib import Graph
from rdflib.namespace import RDF, RDFS, OWL, XSD
from fractions import Fraction as Rational
from .DatatypeHandling import AltXSDToPYTHON
# noinspection PyPep8Naming
from .CombinedClosure import RDFS_OWLRL_Semantics
from .OWLRL import OWLRL_Annotation_properties
from .XsdDatatypes import OWL_RL_Datatypes, OWL_Datatype_Subsumptions
from .RestrictedDatatype import extract_faceted_datatypes
#######################################################################################################################
# Rational datatype
# noinspection PyPep8Naming
def _strToRational(v):
"""Converting a string to a rational.
According to the OWL spec: numerator must be an integer, denominator a positive integer (ie, xsd['integer'] type),
and the denominator should not have a '+' sign.
@param v: the literal string defined as boolean
@return corresponding Rational value
@rtype: Rational
@raise ValueError: invalid rational string literal
"""
try:
r = v.split("/")
if len(r) == 2:
n_str = r[0]
d_str = r[1]
else:
n_str = r[0]
d_str = "1"
if d_str.strip()[0] == "+":
raise ValueError("Invalid Rational literal value %s" % v)
else:
return Rational(
AltXSDToPYTHON[XSD.integer](n_str),
AltXSDToPYTHON[XSD.positiveInteger](d_str),
)
except:
raise ValueError("Invalid Rational literal value %s" % v)
#######################################################################################################################
# noinspection PyPep8Naming,PyBroadException
class OWLRL_Extension(RDFS_OWLRL_Semantics):
"""
Additional rules to OWL 2 RL. The initialization method also adds the :code:`owl:rational` datatype to the set of
allowed datatypes with the :func:`owlrl.OWLRLExtras._strToRational` function as a conversion between the literal form and a Rational. The
:code:`xsd:decimal` datatype is also set to be a subclass of :code:`owl:rational`. Furthermore, the restricted datatypes are
extracted from the graph using a separate method in a different module
(:py:func:`.RestrictedDatatype.extract_faceted_datatypes`), and all those datatypes are also added to the set of allowed
datatypes. In the case of the restricted datatypes and extra subsumption relationship is set up between the
restricted and the base datatypes.
:cvar extra_axioms: Additional axioms that have to be added to the deductive closure (in case the axiomatic triples
are required).
:var restricted_datatypes: list of the datatype restriction from :class:`.RestrictedDatatype`.
:type restricted_datatypes: list of L{restricted datatype} instances
"""
extra_axioms = [
(OWL.hasSelf, RDF.type, RDF.Property),
(OWL.hasSelf, RDFS.domain, RDF.Property),
]
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = False, destination: Union[None, Graph] = None):
"""
@param graph: the RDF graph to be extended
@type graph: rdflib.Graph
@param axioms: whether (non-datatype) axiomatic triples should be added or not
@type axioms: Boolean
@param daxioms: whether datatype axiomatic triples should be added or not
@type daxioms: Boolean
@param rdfs: whether RDFS extension is done
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: rdflib.Graph
"""
RDFS_OWLRL_Semantics.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
self.rdfs = rdfs
self.add_new_datatype(
OWL.rational,
_strToRational,
OWL_RL_Datatypes,
subsumption_dict=OWL_Datatype_Subsumptions,
subsumption_key=XSD.decimal,
subsumption_list=[OWL.rational],
)
self.restricted_datatypes = extract_faceted_datatypes(self, graph)
for dt in self.restricted_datatypes:
self.add_new_datatype(
dt.datatype,
dt.toPython,
OWL_RL_Datatypes,
subsumption_dict=OWL_Datatype_Subsumptions,
subsumption_key=dt.datatype,
subsumption_list=[dt.base_type],
)
# noinspection PyShadowingNames
def _subsume_restricted_datatypes(self):
"""
A one-time-rule: all the literals are checked whether they are (a) of type restricted by a
faceted (restricted) datatype and (b) whether
the corresponding value abides to the restrictions. If true, then the literal gets an extra
tag as being of type of the restricted datatype, too.
"""
literals = self._literals()
for rt in self.restricted_datatypes:
# This is a recorded restriction. The base type is:
base_type = rt.base_type
# Look through all the literals
for lt in literals:
# check if the type of that literal matches. Note that this also takes
# into account the subsumption datatypes, that have been taken
# care of by the 'regular' OWL RL process
if (lt, RDF.type, base_type) in self.graph:
try:
# the conversion or the check may go wrong and raise an exception; then simply move on
if rt.checkValue(lt.toPython()):
# yep, this is also of type 'rt'
self.store_triple((lt, RDF.type, rt.datatype))
except:
continue
def restriction_typing_check(self, v, t):
"""
Helping method to check whether a type statement is in line with a possible
restriction. This method is invoked by rule "cls-avf" before setting a type
on an allValuesFrom restriction.
The method is a placeholder at this level. It is typically implemented by subclasses for
extra checks, e.g., for datatype facet checks.
:param v: the resource that is to be 'typed'.
:param t: the targeted type (i.e., Class).
:return: Boolean.
:rtype: bool
"""
# Look through the restricted datatypes to see if 't' corresponds to one of those...
# There are a bunch of possible exceptions here with datatypes, but they can all
# be ignored...
try:
for rt in self.restricted_datatypes:
if rt.datatype == t:
# bingo
if v in self.literal_proxies.bnode_to_lit:
return rt.checkValue(
self.literal_proxies.bnode_to_lit[v].lit.toPython()
)
else:
return True
# if we got here, no restriction applies
return True
except:
return True
def one_time_rules(self):
"""
This method is invoked only once at the beginning, and prior of, the forward chaining process.
At present, only the L{subsumption} of restricted datatypes<_subsume_restricted_datatypes>} is performed.
"""
RDFS_OWLRL_Semantics.one_time_rules(self)
# it is important to flush the triples at this point, because
# the handling of the restriction datatypes rely on the datatype
# subsumption triples added by the superclass
self.flush_stored_triples()
self._subsume_restricted_datatypes()
def add_axioms(self):
"""
Add the :class:`owlrl.OWLRLExtras.OWLRL_Extension.extra_axioms`, related to the self restrictions. This method is invoked only once at the beginning, and prior of, the forward chaining process.
"""
RDFS_OWLRL_Semantics.add_axioms(self)
for t in self.extra_axioms:
self.destination.add(t)
def rules(self, t, cycle_num):
"""
Go through the additional rules implemented by this module.
:param t: A triple (in the form of a tuple).
:type t: tuple
:param cycle_num: Which cycle are we in, starting with 1. This value is forwarded to all local rules; it is
also used locally to collect the bnodes in the graph.
:type cycle_num: int
"""
RDFS_OWLRL_Semantics.rules(self, t, cycle_num)
z, q, x = t
if q == OWL.hasSelf:
for p in self.graph.objects(z, OWL.onProperty):
for y in self.graph.subjects(RDF.type, z):
self.store_triple((y, p, y))
for y1, y2 in self.graph.subject_objects(p):
if y1 == y2:
self.store_triple((y1, RDF.type, z))
# noinspection PyPep8Naming
class OWLRL_Extension_Trimming(OWLRL_Extension):
"""
This Class adds only one feature to :class:`.OWLRL_Extension`: to initialize with a trimming flag set to :code:`True` by
default.
This is pretty experimental and probably contentious: this class *removes* a number of triples from the Graph at
the very end of the processing steps. These triples are either the by-products of the deductive closure calculation
or are axiom like triples that are added following the rules of OWL 2 RL. While these triples *are necessary* for
the correct inference of really 'useful' triples, they may not be of interest for the application for the end
result. The triples that are removed are of the form (following a SPARQL-like notation):
- :code:`?x owl:sameAs ?x`, :code:`?x rdfs:subClassOf ?x`, :code:`?x rdfs:subPropertyOf ?x`, :code:`?x owl:equivalentClass ?x` type triples.
- :code:`?x rdfs:subClassOf rdf:Resource`, :code:`?x rdfs:subClassOf owl:Thing`, :code:`?x rdf:type rdf:Resource`, :code:`owl:Nothing rdfs:subClassOf ?x` type triples.
- For a datatype that does *not* appear explicitly in a type assignments (ie, in a :code:`?x rdf:type dt`) the corresponding :code:`dt rdf:type owl:Datatype` and :code:`dt rdf:type owl:DataRange` triples, as well as the disjointness statements with other datatypes.
- annotation property axioms.
- a number of axiomatic triples on :code:`owl:Thing`, :code:`owl:Nothing` and :code:`rdf:Resource` (eg, :code:`owl:Nothing rdf:type owl:Class`, :code:`owl:Thing owl:equivalentClass rdf:Resource`, etc).
Trimming is the only feature of this class, done in the :py:meth:`.post_process` step. If users extend :class:`OWLRL_Extension`,
this class can be safely mixed in via multiple inheritance.
:param graph: The RDF graph to be extended.
:type graph: :class:`rdflib.Graph`
:param axioms: Whether (non-datatype) axiomatic triples should be added or not.
:type axioms: bool
:param daxioms: Whether datatype axiomatic triples should be added or not.
:type daxioms: bool
:param rdfs: Whether RDFS extension is done.
:type rdfs: bool
"""
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = False, destination: Union[None, Graph] = None):
"""
@param graph: the RDF graph to be extended
@type graph: rdflib.Graph
@param axioms: whether (non-datatype) axiomatic triples should be added or not
@type axioms: Boolean
@param daxioms: whether datatype axiomatic triples should be added or not
@type daxioms: Boolean
@param rdfs: whether RDFS extension is done
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: rdflib.Graph
"""
OWLRL_Extension.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
def post_process(self):
"""
Do some post-processing step performing the trimming of the graph. See the :class:`.OWLRL_Extension_Trimming`
class for further details.
"""
OWLRL_Extension.post_process(self)
self.flush_stored_triples()
to_be_removed = set()
for t in self.graph.triples((None, None, None)):
s, p, o = t
if s == o:
if (
p == OWL.sameAs
or p == OWL.equivalentClass
or p == RDFS.subClassOf
or p == RDFS.subPropertyOf
):
to_be_removed.add(t)
if (
(p == RDFS.subClassOf and (o == OWL.Thing or o == RDFS.Resource))
or (p == RDF.type and o == RDFS.Resource)
or (s == OWL.Nothing and p == RDFS.subClassOf)
):
to_be_removed.add(t)
for dt in OWL_RL_Datatypes:
# see if this datatype appears explicitly in the graph as the type of a symbol
if len([s for s in self.graph.subjects(RDF.type, dt)]) == 0:
to_be_removed.add((dt, RDF.type, RDFS.Datatype))
to_be_removed.add((dt, RDF.type, OWL.DataRange))
for t in self.graph.triples((dt, OWL.disjointWith, None)):
to_be_removed.add(t)
for t in self.graph.triples((None, OWL.disjointWith, dt)):
to_be_removed.add(t)
for an in OWLRL_Annotation_properties:
self.destination.remove((an, RDF.type, OWL.AnnotationProperty))
to_be_removed.add((OWL.Nothing, RDF.type, OWL.Class))
to_be_removed.add((OWL.Nothing, RDF.type, RDFS.Class))
to_be_removed.add((OWL.Thing, RDF.type, OWL.Class))
to_be_removed.add((OWL.Thing, RDF.type, RDFS.Class))
to_be_removed.add((OWL.Thing, OWL.equivalentClass, RDFS.Resource))
to_be_removed.add((RDFS.Resource, OWL.equivalentClass, OWL.Thing))
to_be_removed.add((OWL.Class, OWL.equivalentClass, RDFS.Class))
to_be_removed.add((OWL.Class, RDFS.subClassOf, RDFS.Class))
to_be_removed.add((RDFS.Class, OWL.equivalentClass, OWL.Class))
to_be_removed.add((RDFS.Class, RDFS.subClassOf, OWL.Class))
to_be_removed.add((RDFS.Datatype, RDFS.subClassOf, OWL.DataRange))
to_be_removed.add((RDFS.Datatype, OWL.equivalentClass, OWL.DataRange))
to_be_removed.add((OWL.DataRange, RDFS.subClassOf, OWL.DatatypeProperty))
to_be_removed.add((OWL.DataRange, OWL.equivalentClass, OWL.DatatypeProperty))
for t in to_be_removed:
self.destination.remove(t)
OWL-RL-7.1.4/owlrl/RDFSClosure.py 0000775 0000000 0000000 00000020100 15042011661 0016273 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
This module is brute force implementation of the RDFS semantics on the top of RDFLib (with some caveats, see in the
introductory text).
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from typing import Union
import rdflib
from rdflib import Literal, Graph
from rdflib.namespace import RDF, RDFS
from itertools import product
from owlrl.Closure import Core
from owlrl.AxiomaticTriples import RDFS_Axiomatic_Triples, RDFS_D_Axiomatic_Triples
######################################################################################################
# RDFS Semantics class
# noinspection PyPep8Naming
class RDFS_Semantics(Core):
"""
RDFS Semantics class, ie, implementation of the RDFS closure graph.
.. note:: Note that the module does *not* implement the so called Datatype entailment rules, simply because the
underlying RDFLib does not implement the datatypes (ie, RDFLib will not make the literal "1.00" and "1.00000"
identical, although even with all the ambiguities on datatypes, this I{should} be made equal...).
Also, the so-called extensional entailment rules (Section 7.3.1 in the RDF Semantics document) have not been
implemented either.
The comments and references to the various rule follow the names as used in the `RDF Semantics document`_.
.. _RDF Semantics document: http://www.w3.org/TR/rdf-mt/
:param graph: The RDF graph to be extended.
:type graph: :class:`rdflib.Graph`
:param axioms: Whether (non-datatype) axiomatic triples should be added or not.
:type axioms: bool
:param daxioms: Whether datatype axiomatic triples should be added or not.
:type daxioms: bool
:param rdfs: Whether RDFS inference is also done (used in subclassed only).
:type rdfs: bool
"""
def __init__(self, graph: Graph, axioms, daxioms, rdfs: bool = False, destination: Union[None, Graph] = None):
"""
@param graph: the RDF graph to be extended
@type graph: rdflib.Graph
@param axioms: whether (non-datatype) axiomatic triples should be added or not
@type axioms: bool
@param daxioms: whether datatype axiomatic triples should be added or not
@type daxioms: bool
@param rdfs: whether RDFS inference is also done (used in subclassed only)
@type rdfs: boolean
@param destination: the destination graph to which the results are written. If None, use the source graph.
@type destination: rdflib.Graph
"""
Core.__init__(self, graph, axioms, daxioms, rdfs=rdfs, destination=destination)
def add_axioms(self):
"""
Add axioms
"""
for t in RDFS_Axiomatic_Triples:
self.destination.add(t)
for i in range(1, self.IMaxNum + 1):
ci = RDF[("_%d" % i)]
self.destination.add((ci, RDF.type, RDF.Property))
self.destination.add((ci, RDFS.domain, RDFS.Resource))
self.destination.add((ci, RDFS.range, RDFS.Resource))
self.destination.add((ci, RDF.type, RDFS.ContainerMembershipProperty))
def add_d_axioms(self):
"""
This is not really complete, because it just uses the comparison possibilities that RDFLib provides.
"""
# #1
literals = (lt for lt in self._literals() if lt.datatype is not None)
for lt in literals:
self.destination.add((lt, RDF.type, lt.datatype))
for t in RDFS_D_Axiomatic_Triples:
self.destination.add(t)
@staticmethod
def _literals_same_as(lt1, lt2):
if lt1.value is not None and lt2.value is not None:
return lt1.value == lt2.value
elif lt1.datatype is not None and lt2.datatype is not None:
return lt1.__eq__(lt2)
return False
# noinspection PyBroadException
def one_time_rules(self):
"""
Some of the rules in the rule set are axiomatic in nature, meaning that they really have to be added only
once, there is no reason to add these in a cycle. These are performed by this method that is invoked only once
at the beginning of the process.
In this case this is related to a 'hidden' same as rules on literals with identical values (though different
lexical values).
"""
# There is also a hidden sameAs rule in RDF Semantics: if a literal appears in a triple, and another one has
# the same value, then the triple should be duplicated with the other value.
literals = self._literals()
items = (
(lt1, lt2)
for lt1, lt2 in product(literals, literals)
if (lt1 is lt2) or self._literals_same_as(lt1, lt2)
)
for lt1, lt2 in items:
# In OWL, this line is simply stating a sameAs for the
# corresponding literals, and then let the usual rules take
# effect. In RDFS this is not possible, so the sameAs rule is,
# essentially replicated...
for (s, p, o) in self.graph.triples((None, None, lt1)):
self.destination.add((s, p, lt2))
def rules(self, t, cycle_num):
"""
Go through the RDFS entailment rules rdf1, rdfs4-rdfs12, by extending the graph.
:param t: A triple (in the form of a tuple).
:type t: tuple
:param cycle_num: Which cycle are we in, starting with 1. Can be used for some (though minor) optimization.
:type cycle_num: int
"""
s, p, o = t
# rdf1
self.store_triple((p, RDF.type, RDF.Property))
# rdfs4a
if cycle_num == 1:
self.store_triple((s, RDF.type, RDFS.Resource))
# rdfs4b
if cycle_num == 1:
self.store_triple((o, RDF.type, RDFS.Resource))
if p == RDFS.domain:
# rdfs2
for uuu, Y, yyy in self.graph.triples((None, s, None)):
self.store_triple((uuu, RDF.type, o))
if p == RDFS.range:
# rdfs3
for uuu, Y, vvv in self.graph.triples((None, s, None)):
self.store_triple((vvv, RDF.type, o))
if p == RDFS.subPropertyOf:
# rdfs5
for Z, Y, xxx in self.graph.triples((o, RDFS.subPropertyOf, None)):
self.store_triple((s, RDFS.subPropertyOf, xxx))
# rdfs7
for zzz, Z, www in self.graph.triples((None, s, None)):
self.store_triple((zzz, o, www))
if p == RDF.type and o == RDF.Property:
# rdfs6
self.store_triple((s, RDFS.subPropertyOf, s))
if p == RDF.type and o == RDFS.Class:
# rdfs8
self.store_triple((s, RDFS.subClassOf, RDFS.Resource))
# rdfs10
self.store_triple((s, RDFS.subClassOf, s))
if p == RDFS.subClassOf:
# rdfs9
for vvv, Y, Z in self.graph.triples((None, RDF.type, s)):
self.store_triple((vvv, RDF.type, o))
# rdfs11
for Z, Y, xxx in self.graph.triples((o, RDFS.subClassOf, None)):
self.store_triple((s, RDFS.subClassOf, xxx))
if p == RDF.type and o == RDFS.ContainerMembershipProperty:
# rdfs12
self.store_triple((s, RDFS.subPropertyOf, RDFS.member))
if p == RDF.type and o == RDFS.Datatype:
self.store_triple((s, RDFS.subClassOf, RDFS.Literal))
def _literals(self):
"""
Get all literals defined in the graph.
"""
return set(
o for s, p, o in self.graph.triples((None, None, None))
if isinstance(o, Literal)
)
OWL-RL-7.1.4/owlrl/RestrictedDatatype.py 0000664 0000000 0000000 00000050661 15042011661 0020020 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
Module to datatype restrictions, i.e., data ranges.
The module implements the following aspects of datatype restrictions:
- a new datatype is created run-time and added to the allowed and accepted datatypes; literals are checked whether they abide to the restrictions
- the new datatype is defined to be a 'subClass' of the restricted datatype
- literals of the restricted datatype and that abide to the restrictions defined by the facets are also assigned to be of the new type
The last item is important to handle the following structures::
ex:RE a owl:Restriction ;
owl:onProperty ex:p ;
owl:someValuesFrom [
a rdfs:Datatype ;
owl:onDatatype xsd:string ;
owl:withRestrictions (
[ xsd:minLength "3"^^xsd:integer ]
[ xsd:maxLength "6"^^xsd:integer ]
)
]
.
ex:q ex:p "abcd"^^xsd:string.
In the case above the system can then infer that :code:`ex:q` is also of type :code:`ex:RE`.
Datatype restrictions are used by the :class:`.OWLRLExtras.OWLRL_Extension` extension class.
The implementation is **not** 100% complete. Some things that an ideal implementation should do are not done yet like:
- checking whether a facet is of a datatype that is allowed for that facet
- handling of non-literals in the facets (ie, if the resource is defined to be of type literal, but whose value is defined via a separate :code:`owl:sameAs` somewhere else)
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
import re
from rdflib.namespace import OWL, RDF, RDFS, XSD
from rdflib import Literal as rdflibLiteral, Graph
from .DatatypeHandling import AltXSDToPYTHON
from functools import reduce
# Constant for datatypes using min, max (inclusive and exclusive):
MIN_MAX = 0
# Constant for datatypes using length, minLength, and maxLength (and nothing else)
LENGTH = 1
# Constant for datatypes using length, minLength, maxLength, and pattern
LENGTH_AND_PATTERN = 2
# Constant for datatypes using length, minLength, maxLength, pattern, and lang range
LENGTH_PATTERN_LRANGE = 3
# Dictionary of all the datatypes, keyed by category
Datatypes_per_facets = {
MIN_MAX: [
# OWL.rational,
# OWL.real,
XSD.decimal,
XSD.integer,
XSD.nonNegativeInteger,
XSD.nonPositiveInteger,
XSD.positiveInteger,
XSD.negativeInteger,
XSD.long,
XSD.short,
XSD.byte,
XSD.unsignedLong,
XSD.unsignedInt,
XSD.unsignedShort,
XSD.unsignedByte,
XSD.double,
XSD.float,
XSD.dateTime,
XSD.dateTimeStamp,
XSD.time,
XSD.date,
],
LENGTH: [XSD.hexBinary, XSD.base64Binary],
LENGTH_AND_PATTERN: [
XSD.anyURI,
XSD.string,
XSD.NMTOKEN,
XSD.Name,
XSD.NCName,
XSD.language,
XSD.normalizedString,
],
LENGTH_PATTERN_LRANGE: [RDF.PlainLiteral],
}
# a simple list containing C{all} datatypes that may have a facet
facetable_datatypes = reduce(lambda x, y: x + y, list(Datatypes_per_facets.values()))
#######################################################################################################
def _lit_to_value(dt, v):
"""
This method is used to convert a string to a value with facet checking. RDF Literals are converted to
Python values using this method; if there is a problem, an exception is raised (and caught higher
up to generate an error message).
The method is the equivalent of all the methods in the :mod:`.DatatypeHandling` module, and is registered
to the system run time, as new restricted datatypes are discovered.
(Technically, the registration is done via a :code:`lambda v: _lit_to_value(self,v)` setting from within a
:class:`.RestrictedDatatype` instance).
:param dt: Faceted datatype.
:type dt: :class:`RestrictedDatatype`
:param v: Literal to be converted and checked.
:raise ValueError: Invalid literal value.
"""
# This may raise an exception...
value = dt.converter(v)
# look at the different facet categories and try to find which is
# is, if any, the one that is of relevant for this literal
for cat in Datatypes_per_facets:
if dt.base_type in Datatypes_per_facets[cat]:
# yep, this is to be checked.
if not dt.checkValue(value):
raise ValueError(
"Literal value %s does not fit the faceted datatype %s" % (v, dt)
)
# got here, everything should be fine
return value
# noinspection PyPep8Naming,PyShadowingBuiltins
def _lang_range_check(range, lang):
"""
Implementation of the extended filtering algorithm, as defined in point 3.3.2,
of U{RFC 4647}, on matching language ranges and language tags.
Needed to handle the C{rdf:PlainLiteral} datatype.
@param range: language range
@param lang: language tag
@rtype: boolean
"""
def _match(r, l):
"""Matching of a range and language item: either range is a wildcard or the two are equal
@param r: language range item
@param l: language tag item
@rtype: boolean
"""
return r == "*" or r == l
rangeList = range.strip().lower().split("-")
langList = lang.strip().lower().split("-")
if not _match(rangeList[0], langList[0]):
return False
rI = 1
rL = 1
while rI < len(rangeList):
if rangeList[rI] == "*":
rI += 1
continue
if rL >= len(langList):
return False
if _match(rangeList[rI], langList[rL]):
rI += 1
rL += 1
continue
if len(langList[rL]) == 1:
return False
else:
rL += 1
continue
return True
#######################################################################################################
def extract_faceted_datatypes(core, graph: Graph):
"""
Extractions of restricted (i.e., faceted) datatypes from the graph.
:param core: The core closure instance that is being handled.
:type core: :class:`.Closure.Core`
:param graph: RDFLib graph.
:type graph: :class:`rdflib.graph.Graph`
:return: List of :class:`.RestrictedDatatype` instances.
:rtype: list
"""
retval = []
for dtype in graph.subjects(RDF.type, RDFS.Datatype):
base_type = None
facets = []
try:
base_types = [x for x in graph.objects(dtype, OWL.onDatatype)]
if len(base_types) > 0:
if len(base_types) > 1:
raise Exception(
"Several base datatype for the same restriction %s" % dtype
)
else:
base_type = base_types[0]
if base_type in facetable_datatypes:
rlists = [x for x in graph.objects(dtype, OWL.withRestrictions)]
if len(rlists) > 1:
raise Exception(
"More than one facet lists for the same restriction %s"
% dtype
)
elif len(rlists) > 0:
final_facets = []
for r in graph.items(rlists[0]):
for (facet, lit) in graph.predicate_objects(r):
if isinstance(lit, rdflibLiteral):
# the python value of the literal should be extracted
# note that this call may lead to an exception, but that is fine,
# it is caught some lines below anyway...
try:
if (
lit.datatype is None
or lit.datatype == XSD.string
):
final_facets.append((facet, str(lit)))
else:
final_facets.append(
(
facet,
AltXSDToPYTHON[lit.datatype](
str(lit)
),
)
)
except Exception as msg:
core.add_error(msg)
continue
# We do have everything we need:
new_datatype = RestrictedDatatype(
dtype, base_type, final_facets
)
retval.append(new_datatype)
except Exception as msg:
# import sys
# print sys.exc_info()
# print sys.exc_type
# print sys.exc_value
# print sys.exc_traceback
core.add_error(msg)
continue
return retval
# noinspection PyPep8Naming
class RestrictedDatatypeCore:
"""
An 'abstract' superclass for datatype restrictions. The instance variables listed here are
used in general, without the specificities of the concrete restricted datatype.
This module defines the :class:`.RestrictedDatatype` class that corresponds to the datatypes and their restrictions
defined in the OWL 2 standard. Other modules may subclass this class to define new datatypes with restrictions.
:ivar type_uri: The URI for this datatype.
:ivar base_type: URI of the datatype that is restricted.
:ivar toPython: Function to convert a Literal of the specified type to a Python value.
"""
def __init__(self, type_uri, base_type):
self.datatype = type_uri
self.base_type = base_type
self.toPython = None
def checkValue(self, value):
"""
Check whether the (Python) value abides to the constraints defined by the current facets.
:param value: The value to be checked.
:rtype: bool
"""
raise Exception(
"This class should not be used by itself, only via its subclasses!"
)
# noinspection PyPep8Naming
class RestrictedDatatype(RestrictedDatatypeCore):
"""
Implementation of a datatype with facets, ie, datatype with restrictions.
:param type_uri: URI of the datatype being defined.
:param base_type: URI of the base datatype, ie, the one being restricted.
:param facets: List of :code:`(facetURI, value)` pairs.
:ivar datatype : The URI for this datatype.
:ivar base_type: URI of the datatype that is restricted.
:ivar converter: Method to convert a literal of the base type to a Python value (:code:`DatatypeHandling.AltXSDToPYTHON`).
:ivar minExclusive: Value for the :code`xsd:minExclusive` facet, initialized to :code:`None` and set to the right value if
a facet is around.
:ivar minInclusive: Value for the :code:`xsd:minInclusive` facet, initialized to :code:`None` and set to the right value if
a facet is around.
:ivar maxExclusive: Value for the :code:`xsd:maxExclusive` facet, initialized to :code:`None` and set to the right value if
a facet is around.
:ivar maxInclusive: Value for the :code:`xsd:maxInclusive` facet, initialized to :code:`None` and set to the right value if
a facet is around.
:ivar minLength: Value for the :code:`xsd:minLength` facet, initialized to :code:`None` and set to the right value if a facet
is around.
:ivar maxLength: Value for the :code:`xsd:maxLength` facet, initialized to :code:`None` and set to the right value if a facet
is around.
:ivar length: Value for the :code:`xsd:length` facet, initialized to :code:`None` and set to the right value if a facet is
around.
:ivar pattern: Array of patterns for the :code:`xsd:pattern` facet, initialized to :code:`[]` and set to the right value if a
facet is around.
:ivar langRange: Array of language ranges for the :code:`rdf:langRange` facet, initialized to :code:`[]` and set to the right
value if a facet is around.
:ivar check_methods: List of class methods that are relevant for the given :code:`base_type`.
:ivar toPython: Function to convert a Literal of the specified type to a Python value. Is defined by :code:`lambda v:
_lit_to_value(self, v)`, see :py:func:`._lit_to_value`.
"""
def __init__(self, type_uri, base_type, facets):
"""
@param type_uri: URI of the datatype being defined
@param base_type: URI of the base datatype, ie, the one being restricted
@param facets: array of C{(facetURI, value)} pairs
"""
RestrictedDatatypeCore.__init__(self, type_uri, base_type)
if self.base_type not in AltXSDToPYTHON:
raise Exception("No facet is implemented for datatype %s" % self.base_type)
self.converter = AltXSDToPYTHON[self.base_type]
self.minExclusive = None
self.maxExclusive = None
self.minInclusive = None
self.maxInclusive = None
self.length = None
self.maxLength = None
self.minLength = None
self.pattern = []
self.langRange = []
for (facet, value) in facets:
if facet == XSD.minInclusive and (
self.minInclusive is None or self.minInclusive < value
):
self.minInclusive = value
elif facet == XSD.minExclusive and (
self.minExclusive is None or self.minExclusive < value
):
self.minExclusive = value
elif facet == XSD.maxInclusive and (
self.maxInclusive is None or value < self.maxInclusive
):
self.maxInclusive = value
elif facet == XSD.maxExclusive and (
self.maxExclusive is None or value < self.maxExclusive
):
self.maxExclusive = value
elif facet == RDF.langRange:
self.langRange.append(value)
elif facet == XSD.length:
self.length = value
elif facet == XSD.maxLength and (
self.maxLength is None or value < self.maxLength
):
self.maxLength = value
elif facet == XSD.minLength and (
self.minLength is None or value > self.minLength
):
self.minLength = value
elif facet == XSD.pattern:
self.pattern.append(re.compile(value))
# Choose the methods that are relevant for this datatype, based on the base type
facet_to_method = {
MIN_MAX: [
RestrictedDatatype._check_max_exclusive,
RestrictedDatatype._check_min_exclusive,
RestrictedDatatype._check_max_inclusive,
RestrictedDatatype._check_min_inclusive,
],
LENGTH: [
RestrictedDatatype._check_min_length,
RestrictedDatatype._check_max_length,
RestrictedDatatype._check_length,
],
LENGTH_AND_PATTERN: [
RestrictedDatatype._check_min_length,
RestrictedDatatype._check_max_length,
RestrictedDatatype._check_length,
RestrictedDatatype._check_pattern,
],
LENGTH_PATTERN_LRANGE: [
RestrictedDatatype._check_min_length,
RestrictedDatatype._check_max_length,
RestrictedDatatype._check_length,
RestrictedDatatype._check_lang_range,
],
}
self.check_methods = []
for cat in Datatypes_per_facets:
if self.base_type in Datatypes_per_facets[cat]:
self.check_methods = facet_to_method[cat]
break
self.toPython = lambda v: _lit_to_value(self, v)
def checkValue(self, value):
"""
Check whether the (Python) value abides to the constraints defined by the current facets.
:param value: The value to be checked.
:rtype: bool
"""
for method in self.check_methods:
if not method(self, value):
return False
return True
def _check_min_exclusive(self, value):
"""
Check the (python) value against min exclusive facet.
@param value: the value to be checked
@rtype: boolean
"""
if self.minExclusive is not None:
return self.minExclusive < value
else:
return True
def _check_min_inclusive(self, value):
"""
Check the (python) value against min inclusive facet.
@param value: the value to be checked
@rtype: boolean
"""
if self.minInclusive is not None:
return self.minInclusive <= value
else:
return True
def _check_max_exclusive(self, value):
"""
Check the (python) value against max exclusive facet.
@param value: the value to be checked
@rtype: boolean
"""
if self.maxExclusive is not None:
return value < self.maxExclusive
else:
return True
def _check_max_inclusive(self, value):
"""
Check the (python) value against max inclusive facet.
@param value: the value to be checked
@rtype: boolean
"""
if self.maxInclusive is not None:
return value <= self.maxInclusive
else:
return True
def _check_min_length(self, value):
"""
Check the (python) value against minimum length facet.
@param value: the value to be checked
@rtype: boolean
"""
if isinstance(value, rdflibLiteral):
val = str(value)
else:
val = value
if self.minLength is not None:
return self.minLength <= len(val)
else:
return True
def _check_max_length(self, value):
"""
Check the (python) value against maximum length facet.
@param value: the value to be checked
@rtype: boolean
"""
if isinstance(value, rdflibLiteral):
val = str(value)
else:
val = value
if self.maxLength is not None:
return self.maxLength >= len(val)
else:
return True
def _check_length(self, value):
"""
Check the (python) value against exact length facet.
@param value: the value to be checked
@rtype: boolean
"""
if isinstance(value, rdflibLiteral):
val = str(value)
else:
val = value
if self.length is not None:
return self.length == len(val)
else:
return True
def _check_pattern(self, value):
"""
Check the (python) value against array of regular expressions.
@param value: the value to be checked
@rtype: boolean
"""
if isinstance(value, rdflibLiteral):
val = str(value)
else:
val = value
for p in self.pattern:
if p.match(val) is None:
return False
return True
def _check_lang_range(self, value):
"""
Check the (python) value against array of language ranges.
@param value: the value to be checked
@rtype: boolean
"""
if isinstance(value, rdflibLiteral):
lang = value.language
else:
return False
for r in self.langRange:
if not _lang_range_check(r, lang):
return False
return True
OWL-RL-7.1.4/owlrl/XsdDatatypes.py 0000775 0000000 0000000 00000007504 15042011661 0016632 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
Lists of XSD datatypes and their mutual relationships
**Requires**: `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
**License**: This software is available for use under the `W3C Software License`_.
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from rdflib.namespace import RDF, RDFS, XSD
# The basic XSD types used everywhere; this means not the complete set of day/month types
_Common_XSD_Datatypes = [
XSD.integer,
XSD.decimal,
XSD.nonNegativeInteger,
XSD.nonPositiveInteger,
XSD.negativeInteger,
XSD.positiveInteger,
XSD.long,
XSD.int,
XSD.short,
XSD.byte,
XSD.unsignedLong,
XSD.unsignedInt,
XSD.unsignedShort,
XSD.unsignedByte,
XSD.float,
XSD.double,
XSD.string,
XSD.normalizedString,
XSD.token,
XSD.language,
XSD.Name,
XSD.NCName,
XSD.NMTOKEN,
XSD.boolean,
XSD.hexBinary,
XSD.base64Binary,
XSD.anyURI,
XSD.dateTimeStamp,
XSD.dateTime,
XSD.time,
XSD.date,
RDFS.Literal,
RDF.XMLLiteral,
RDF.HTML,
RDF.langString,
]
# RDFS Datatypes: the basic ones plus the complete set of day/month ones
RDFS_Datatypes = _Common_XSD_Datatypes + [
XSD.gYearMonth,
XSD.gMonthDay,
XSD.gYear,
XSD.gDay,
XSD.gMonth,
]
# OWL RL Datatypes: the basic ones plus plain literal
OWL_RL_Datatypes = _Common_XSD_Datatypes + [RDF.PlainLiteral]
# XSD Datatype subsumptions
_Common_Datatype_Subsumptions = {
XSD.dateTimeStamp: [XSD.dateTime],
XSD.integer: [XSD.decimal],
XSD.long: [XSD.integer, XSD.decimal],
XSD.int: [XSD.long, XSD.integer, XSD.decimal],
XSD.short: [
XSD.int,
XSD.long,
XSD.integer,
XSD.decimal,
],
XSD.byte: [
XSD.short,
XSD.int,
XSD.long,
XSD.integer,
XSD.decimal,
],
XSD.nonNegativeInteger: [XSD.integer, XSD.decimal],
XSD.positiveInteger: [
XSD.nonNegativeInteger,
XSD.integer,
XSD.decimal,
],
XSD.unsignedLong: [
XSD.nonNegativeInteger,
XSD.integer,
XSD.decimal,
],
XSD.unsignedInt: [
XSD.unsignedLong,
XSD.nonNegativeInteger,
XSD.integer,
XSD.decimal,
],
XSD.unsignedShort: [
XSD.unsignedInt,
XSD.unsignedLong,
XSD.nonNegativeInteger,
XSD.integer,
XSD.decimal,
],
XSD.unsignedByte: [
XSD.unsignedShort,
XSD.unsignedInt,
XSD.unsignedLong,
XSD.nonNegativeInteger,
XSD.integer,
XSD.decimal,
],
XSD.nonPositiveInteger: [XSD.integer, XSD.decimal],
XSD.negativeInteger: [
XSD.nonPositiveInteger,
XSD.integer,
XSD.decimal,
],
XSD.normalizedString: [XSD.string],
XSD.token: [XSD.normalizedString, XSD.string],
XSD.language: [XSD.token, XSD.normalizedString, XSD.string],
XSD.Name: [XSD.token, XSD.normalizedString, XSD.string],
XSD.NCName: [
XSD.Name,
XSD.token,
XSD.normalizedString,
XSD.string,
],
XSD.NMTOKEN: [
XSD.Name,
XSD.token,
XSD.normalizedString,
XSD.string,
],
}
# RDFS Datatype subsumptions: at the moment, there is no extra to XSD
RDFS_Datatype_Subsumptions = _Common_Datatype_Subsumptions
# OWL Datatype subsumptions: at the moment, there is no extra to XSD
OWL_Datatype_Subsumptions = _Common_Datatype_Subsumptions
OWL-RL-7.1.4/owlrl/__init__.py 0000775 0000000 0000000 00000064125 15042011661 0015756 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
#
"""
This module is a brute force implementation of the 'finite' version of `RDFS semantics`_ and of `OWL 2 RL`_ on the top
of RDFLib (with some caveats, see below). Some extensions to these are also implemented.
.. _RDFS semantics: http://www.w3.org/TR/rdf-mt/
.. _OWL 2 RL: http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules
Brute force means that, in all cases, simple forward chaining rules are used to extend (recursively) the incoming graph
with all triples that the rule sets permit (ie, the "deductive closure" of the graph is computed).
There is an extra options whether the axiomatic triples are added to the graph (prior to the forward chaining step).
These, typically set the domain and range for properties or define some core classes.
In the case of RDFS, the implementation uses a 'finite' version of the axiomatic triples only (as proposed, for example,
by Herman ter Horst). This means that it adds only those :code:`rdf:_i` type predicates that do appear in the original graph,
thereby keeping this step finite. For OWL 2 RL, OWL 2 does not define axiomatic triples formally; but they can be
deduced from the `OWL 2 RDF Based Semantics`_ document and are listed in Appendix 6 (though informally).
.. _OWL 2 RDF Based Semantics: http://www.w3.org/TR/owl2-rdf-based-semantics/
.. note:: This implementation adds only those triples that refer to OWL terms that are meaningful for the OWL 2 RL case.
Package Entry Points
====================
The main entry point to the package is via the :class:`.DeductiveClosure` class. This class should be
initialized to control the parameters of the deductive closure; the forward chaining is done via the
L{expand} method.
The simplest way to use the package from an RDFLib application is as follows::
graph = Graph() # creation of an RDFLib graph
...
... # normal RDFLib application, eg, parsing RDF data
...
DeductiveClosure(OWLRL_Semantics).expand(graph) # calculate an OWL 2 RL deductive closure of graph
# without axiomatic triples
The first argument of the :class:`.DeductiveClosure` initialization can be replaced by other classes, providing different
types of deductive closure; other arguments are also possible. For example::
DeductiveClosure(OWLRL_Extension, rdfs_closure = True, axiomatic_triples = True, datatype_axioms = True).expand(graph)
This will calculate the deductive closure including RDFS and some extensions to OWL 2 RL, and with all possible axiomatic
triples added to the graph (this is about the maximum the package can do…)
The same instance of :class:`.DeductiveClosure` can be used for several graph expansions. In other words, the
expand function does not change any state.
For convenience, a second entry point to the package is provided in the form of a function called
:func:`owlrl.convert_graph`, that expects a directory with various options, including a file name. The function
parses the file, creates the expanded graph, and serializes the result into RDF/XML or Turtle. This function is
particularly useful as an entry point for a CGI call (where the HTML form parameters are in a directory) and is easy to
use with a command line interface. The package distribution contains an example for both.
There are major closure type (ie, semantic closure possibilities); these can be controlled through the appropriate
parameters of the :class:`.DeductiveClosure` class:
* using the :class:`.RDFS_Semantics` class, implementing the `RDFS semantics`_.
.. _RDFS semantics: http://www.w3.org/TR/rdf-mt/
* using the :class:`.OWLRL.OWLRL_Semantics` class, implementing the `OWL 2 RL`_.
.. _OWL 2 RL: http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules
* using :class:`.CombinedClosure.RDFS_OWLRL_Semantics` class, implementing a combined semantics of `RDFS semantics`_ and `OWL 2 RL`_.
.. _RDFS semantics: http://www.w3.org/TR/rdf-mt/
.. _OWL 2 RL: http://www.w3.org/TR/owl2-profiles/#Reasoning_in_OWL_2_RL_and_RDF_Graphs_using_Rules
In all three cases there are other dimensions that can control the exact closure being generated:
* for convenience, the so called axiomatic triples (see, eg, the `axiomatic triples in RDFS`_ are, by default, I{not} added to the graph closure to reduce the number of generated triples. These can be controlled through a separate initialization argument.
.. _axiomatic triples in RDFS: http://www.w3.org/TR/rdf-mt/#rdfs_interp
* similarly, the axiomatic triples for D-entailment are separated.
Some Technical/implementation aspects
=====================================
The core processing is done in the in the :class:`.Closure.Core` class, which is subclassed by the
:class:`.RDFSClosure.RDFS_Semantics` and the :class:`.OWLRL.OWLRL_Semantics` classes (these two are then, on their turn,
subclassed by the :class:`.CombinedClosure.RDFS_OWLRL_Semantics` class). The core implements the core functionality of
cycling through the rules, whereas the rules themselves are defined and implemented in the subclasses. There are also
methods that are executed only once either at the beginning or at the end of the full processing cycle. Adding axiomatic
triples is handled separately, which allows a finer user control over these features.
The OWL specification includes references to datatypes that are not in the core RDFS specification, consequently not
directly implemented by RDFLib. These are added in a separate module of the package.
Problems with Literals with datatypes
-------------------------------------
The current distribution of RDFLib is fairly poor in handling datatypes, particularly in checking whether a lexical form
of a literal is "proper" as for its declared datatype. A typical example is ::
"-1234"^^xsd:nonNegativeInteger
which should not be accepted as valid literal. Because the requirements of OWL 2 RL are much stricter in this respect,
an alternative set of datatype handling (essentially, conversions) had to be implemented (see the :py:mod:`.XsdDatatypes`
module).
The :class:`.DeductiveClosure` class has an additional instance variable whether
the default RDFLib conversion routines should be exchanged against the new ones. If this flag is set to True and
instance creation (this is the default), then the conversion routines are set back to the originals once the expansion
is complete, thereby avoiding to influence older application that may not work properly with the new set of conversion
routines.
If the user wants to use these alternative lexical conversions everywhere in the application, then
the :py:meth:`.DeductiveClosure.use_improved_datatypes_conversions` method can be invoked.
That method changes the conversion routines and, from that point on, all usage of :class:`.DeductiveClosure` instances
will use the improved conversion methods without resetting them. Ie, the code structure can be something like::
DeductiveClosure().use_improved_datatypes_conversions()
... RDFLib application
DeductiveClosure().expand(graph)
...
The default situation can be set back using the
:py:meth:`.DeductiveClosure.use_rdflib_datatypes_conversions` call.
It is, however, not *required* to use these methods at all. I.e., the user can use::
DeductiveClosure(improved_datatypes=False).expand(graph)
which will result in a proper graph expansion except for the datatype specific comparisons which will be incomplete.
**Requires**:
* `RDFLib`_, 4.0.0 and higher.
.. _RDFLib: https://github.com/RDFLib/rdflib
* `rdflib_jsonld`_
.. _rdflib_jsonld: https://github.com/RDFLib/rdflib-jsonld
**License**: This software is available for use under the `W3C Software License`_
.. _W3C Software License: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
**Organization**: `World Wide Web Consortium`_
.. _World Wide Web Consortium: http://www.w3.org
**Author**: `Ivan Herman`_
.. _Ivan Herman: http://www.w3.org/People/Ivan/
"""
# Examples: LangString is disjoint from String
__version__ = "7.1.4"
__author__ = "Ivan Herman"
__contact__ = "Ivan Herman, ivan@w3.org"
__license__ = "W3C® SOFTWARE NOTICE AND LICENSE, http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231"
from typing import Union
# noinspection PyPackageRequirements,PyPackageRequirements,PyPackageRequirements
import rdflib
from rdflib import Graph, Literal
from . import DatatypeHandling, Closure
from .OWLRLExtras import OWLRL_Extension, OWLRL_Extension_Trimming
from .OWLRL import OWLRL_Semantics
from .RDFSClosure import RDFS_Semantics
from .CombinedClosure import RDFS_OWLRL_Semantics
from rdflib.namespace import OWL
RDFXML = "xml"
TURTLE = "turtle"
JSON = "json"
AUTO = "auto"
RDFA = "rdfa"
# noinspection PyShadowingBuiltins
def __parse_input(iformat, inp, graph):
"""Parse the input into the graph, possibly checking the suffix for the format.
@param iformat: input format; can be one of L{AUTO}, L{TURTLE}, or L{RDFXML}. L{AUTO} means that the suffix of the
file name or URI will decide: '.ttl' means Turtle, RDF/XML otherwise.
@param inp: input file; anything that RDFLib accepts in that position (URI, file name, file object). If '-',
standard input is used.
@param graph: the RDFLib Graph instance to parse into.
"""
if iformat == AUTO:
if inp == "-":
format = "turtle"
else:
if inp.endswith(".ttl") or inp.endswith(".n3"):
format = "turtle"
elif inp.endswith(".json") or inp.endswith(".jsonld"):
format = "json-ld"
elif inp.endswith(".html"):
format = "rdfa1.1"
else:
format = "xml"
elif iformat == TURTLE:
format = "turtle"
elif iformat == RDFA:
format = "rdfa1.1"
elif iformat == RDFXML:
format = "xml"
elif iformat == JSON:
format = "json-ld"
else:
raise Exception("Unknown input syntax")
if inp == "-":
# standard input is used
import sys
source = sys.stdin
else:
source = inp
graph.parse(source, format=format)
def interpret_owl_imports(iformat, graph):
"""
Interpret the owl import statements. Essentially, recursively merge with all the objects in the owl import
statement, and remove the corresponding triples from the graph.
This method can be used by an application prior to expansion. It is *not* done by the :class:`.DeductiveClosure`
class.
:param iformat: Input format; can be one of :code:`AUTO`, :code:`TURTLE`, or :code:`RDFXML`. :code:`AUTO` means that the suffix of the file name or URI will decide: '.ttl' means Turtle, RDF/XML otherwise.
:type iformat: str
:param graph: The RDFLib Graph instance to parse into.
:type graph: :class:`rdflib.graph.Graph`
"""
while True:
# 1. collect the import statements:
all_imports = [t for t in graph.triples((None, OWL.imports, None))]
if len(all_imports) == 0:
# no import statement whatsoever, we can go on...
return
# 2. remove all the import statements from the graph
for t in all_imports:
graph.remove(t)
# 3. get all the imported vocabularies and import them
for (s, p, uri) in all_imports:
# this is not 100% kosher. The expected object for an import statement is a URI. However,
# on local usage, a string would also make sense, so I do that one, too
if isinstance(uri, Literal):
__parse_input(iformat, str(uri), graph)
else:
__parse_input(iformat, uri, graph)
# 4. start all over again to see if import statements have been imported
def return_closure_class(owl_closure, rdfs_closure, owl_extras, trimming=False):
"""
Return the right semantic extension class based on three possible choices (this method is here to help potential
users, the result can be fed into a :class:`DeductiveClosure` instance at initialization).
:param owl_closure: Whether OWL 2 RL deductive closure should be calculated.
:type owl_closure: bool
:param rdfs_closure: Whether RDFS deductive closure should be calculated. In case :code:`owl_closure==True`, this
parameter should also be used in the initialization of :class:`DeductiveClosure`.
:type rdfs_closure: bool
:param owl_extras: Whether the extra possibilities (rational datatype, etc) should be added to an OWL 2 RL
deductive closure. This parameter has no effect in case :code:`owl_closure==False`.
:type owl_extras: bool
:param trimming: Whether extra trimming is done on the OWL RL + Extension output.
:type trimming: bool
:return: Deductive class reference or None.
:rtype: :class:`.DeductiveClosure` or None
"""
if owl_closure:
if owl_extras:
if trimming:
return OWLRL_Extension_Trimming
else:
return OWLRL_Extension
else:
if rdfs_closure:
return RDFS_OWLRL_Semantics
else:
return OWLRL_Semantics
elif rdfs_closure:
return RDFS_Semantics
else:
return None
# noinspection PyCallingNonCallable
class DeductiveClosure:
"""
Entry point to generate the deductive closure of a graph. The exact choice deductive
closure is controlled by a class reference. The important initialization parameter is the :code:`closure_class`, a Class
object referring to a subclass of :class:`.Closure.Core`. Although this package includes a number of such subclasses
:class:`.OWLRL_Semantics`, :class:`.RDFS_Semantics`, :class:`.RDFS_OWLRL_Semantics`, and :class:`.OWLRL_Extension`, the user can use his/her
own if additional rules are implemented.
Note that :code:`owl:imports` statements are *not* interpreted in this class, that has to be done beforehand on the graph
that is to be expanded.
:param closure_class: A closure class reference.
:type closure_class: subclass of :class:`.Closure.Core`
:param improved_datatypes: Whether the improved set of lexical-to-Python conversions should be used for datatype handling. See the introduction for more details. Default: True.
:type improved_datatypes: bool
:param rdfs_closure: Whether the RDFS closure should also be executed. Default: False.
:type rdfs_closure: bool
:param axiomatic_triples: Whether relevant axiomatic triples are added before chaining, except for datatype axiomatic triples. Default: False.
:type axiomatic_triples: bool
:param datatype_axioms: Whether further datatype axiomatic triples are added to the output. Default: false.
:type datatype_axioms: bool
:var improved_datatype_generic: Whether the improved set of lexical-to-Python conversions should be used for datatype handling *in general*, I.e., not only for a particular instance and not only for inference purposes. Default: False.
:type improved_datatype_generic: bool
"""
# This is the original set of param definitions in the class definition
#
# @ivar rdfs_closure: Whether the RDFS closure should also be executed. Default: False.
# @type rdfs_closure: boolean
# @ivar axiomatic_triples: Whether relevant axiomatic triples are added before chaining, except for datatype axiomatic
# triples. Default: False.
# @type axiomatic_triples: boolean
# @ivar datatype_axioms: Whether further datatype axiomatic triples are added to the output. Default: false.
# @type datatype_axioms: boolean
# @ivar closure_class: the class instance used to expand the graph
# @type closure_class: L{Closure.Core}
# @cvar improved_datatype_generic: Whether the improved set of lexical-to-Python conversions should be used for
# datatype handling I{in general}, ie, not only for a particular instance and not only for inference purposes.
# Default: False.
# @type improved_datatype_generic: boolean
improved_datatype_generic = False
def __init__(
self,
closure_class,
improved_datatypes=True,
rdfs_closure=False,
axiomatic_triples=False,
datatype_axioms=False,
):
# This is the original set of param definitions in the __init__
#
# @param closure_class: a closure class reference.
# @type closure_class: subclass of L{Closure.Core}
# @param rdfs_closure: whether RDFS rules are executed or not
# @type rdfs_closure: boolean
# @param axiomatic_triples: Whether relevant axiomatic triples are added before chaining, except for datatype
# axiomatic triples. Default: False.
# @type axiomatic_triples: boolean
# @param datatype_axioms: Whether further datatype axiomatic triples are added to the output. Default: false.
# @type datatype_axioms: boolean
# @param improved_datatypes: Whether the improved set of lexical-to-Python conversions should be used for
# datatype handling. See the introduction for more details. Default: True.
# @type improved_datatypes: boolean
if closure_class is None:
self.closure_class = None
else:
if not isinstance(closure_class, type):
raise ValueError("The closure type argument must be a class reference")
else:
self.closure_class = closure_class
self.axiomatic_triples = axiomatic_triples
self.datatype_axioms = datatype_axioms
self.rdfs_closure = rdfs_closure
self.improved_datatypes = improved_datatypes
def expand(self, graph: Graph, destination: Union[None, Graph] = None):
"""
Expand the graph using forward chaining, and with the relevant closure type.
:param graph: The RDF graph.
:type graph: :class:`rdflib.Graph`
:param destination: The RDF graph to which the results are written. If not specified, the graph is modified in-place.
:type destination: :class:`rdflib.Graph`
"""
if (not DeductiveClosure.improved_datatype_generic) and self.improved_datatypes:
DatatypeHandling.use_Alt_lexical_conversions()
if self.closure_class is not None:
self.closure_class(
graph,
self.axiomatic_triples,
self.datatype_axioms,
rdfs=self.rdfs_closure,
destination=destination
).closure()
if (not DeductiveClosure.improved_datatype_generic) and self.improved_datatypes:
DatatypeHandling.use_RDFLib_lexical_conversions()
@staticmethod
def use_improved_datatypes_conversions():
"""
Switch the system to use the improved datatype conversion routines.
"""
DeductiveClosure.improved_datatype_generic = True
DatatypeHandling.use_Alt_lexical_conversions()
@staticmethod
def use_rdflib_datatypes_conversions():
"""
Switch the system to use the generic (RDFLib) datatype conversion routines
"""
DeductiveClosure.improved_datatype_generic = False
DatatypeHandling.use_RDFLib_lexical_conversions()
###############################################################################################################
# noinspection PyPep8Naming,PyBroadException,PyBroadException,PyBroadException
def convert_graph(options, closureClass=None):
"""
Entry point for external scripts (CGI or command line) to parse an RDF file(s), possibly execute OWL and/or RDFS
closures, and serialize back the result in some format.
Note that this entry point can be used requiring no entailment at all;
because both the input and the output format for the package can be RDF/XML or Turtle, such usage would
simply mean a format conversion.
If OWL 2 RL processing is required, that also means that the :code:`owl:imports` statements are interpreted. I.e.,
ontologies can be spread over several files. Note, however, that the output of the process would then include all
imported ontologies, too.
:param options: Object with specific attributes.
:type options: object
:param options.sources: List of uris or file names for the source data; for each one if the name ends with 'ttl', it
is considered to be turtle, RDF/XML otherwise (this can be overwritten by the options.iformat, though)
:type options.sources: list
:param options.text: Direct Turtle encoding of a graph as a text string (useful, eg, for a CGI call using a text
field).
:type options.text: str
:param options.owlClosure: Can be yes or no.
:type options.owlClosure: bool
:param options.rdfsClosure: Can be yes or no.
:type options.rdfsClosure: bool
:param options.owlExtras: Can be yes or no; whether the extra rules beyond OWL 2 RL are used or not.
:type options.owlExtras: bool
:param options.axioms: Whether relevant axiomatic triples are added before chaining (can be a boolean, or the
strings "yes" or "no").
:type options.axioms: bool
:param options.daxioms: Further datatype axiomatic triples are added to the output (can be a boolean, or the strings
"yes" or "no").
:type options.daxioms: bool
:param options.format: Output format, can be "turtle" or "rdfxml".
:type options.format: str
:param options.iformat: Input format, can be "turtle", "rdfa", "json", "rdfxml", or "auto". "auto" means that the
suffix of the file is considered: '.ttl'. '.html', 'json' or '.jsonld' respectively with 'xml' as a fallback.
:type options.iformat: str
:param options.trimming: Whether the extension to OWLRL should also include trimming.
:type options.trimming: bool
:param closureClass: Explicit class reference. If set, this overrides the various different other options to be
used as an extension.
:type closureClass: TODO(edmond.chuc@csiro.au): What class is this supposed to be?
"""
# Original parameter definitions from old documentation.
#
# @param options: object with specific attributes, namely:
# - options.sources: list of uris or file names for the source data; for each one if the name ends with 'ttl', it is
# considered to be turtle, RDF/XML otherwise (this can be overwritten by the options.iformat, though)
# - options.text: direct Turtle encoding of a graph as a text string (useful, eg, for a CGI call using a text field)
# - options.owlClosure: can be yes or no
# - options.rdfsClosure: can be yes or no
# - options.owlExtras: can be yes or no; whether the extra rules beyond OWL 2 RL are used or not.
# - options.axioms: whether relevant axiomatic triples are added before chaining (can be a boolean, or the strings
# "yes" or "no")
# - options.daxioms: further datatype axiomatic triples are added to the output (can be a boolean, or the strings
# "yes" or "no")
# - options.format: output format, can be "turtle" or "rdfxml"
# - options.iformat: input format, can be "turtle", "rdfa", "json", "rdfxml", or "auto". "auto" means that the
# suffix of the file is considered: '.ttl'. '.html', 'json' or '.jsonld' respectively with 'xml' as a fallback
# - options.trimming: whether the extension to OWLRL should also include trimming
# @param closureClass: explicit class reference. If set, this overrides the various different other options to be
# used as an extension.
def __check_yes_or_true(opt):
return (
opt is True
or opt == "yes"
or opt == "Yes"
or opt == "True"
or opt == "true"
)
import warnings
warnings.filterwarnings("ignore")
if len(options.sources) == 0 and (
options.text is None or len(options.text.strip()) == 0
):
raise Exception("No graph specified either via a URI or text")
graph = Graph()
# Just to be sure that this attribute does not create issues with older versions of the service...
# the try statement should be removed, eventually...
iformat = "auto"
try:
iformat = options.iformat
except:
# exception can be raised if that attribute is not used at all, true for older versions
pass
# similar measure with the possible usage of the 'source' options
try:
if options.source is not None:
options.sources.append(options.source)
except:
# exception can be raised if that attribute is not used at all, true for newer versions
pass
# Get the sources first. Note that a possible error is filtered out, namely to process the same file twice. This is
# done by turning the input arguments into a set...
for inp in set(options.sources):
__parse_input(iformat, inp, graph)
# add the possible extra text (ie, the text input on the HTML page)
if options.text is not None:
graph.parse(data=options.text, format="n3")
# Get all the options right
# noinspection PyPep8Naming
owlClosure = __check_yes_or_true(options.owlClosure)
# noinspection PyPep8Naming
rdfsClosure = __check_yes_or_true(options.rdfsClosure)
# noinspection PyPep8Naming
owlExtras = __check_yes_or_true(options.owlExtras)
try:
trimming = __check_yes_or_true(options.trimming)
except:
trimming = False
axioms = __check_yes_or_true(options.axioms)
daxioms = __check_yes_or_true(options.daxioms)
if owlClosure:
interpret_owl_imports(iformat, graph)
# @@@@ some smarter choice should be used later to decide what the closure class is!!! That should
# also control the import management. Eg, if the superclass includes OWL...
if closureClass is not None:
closure_class = closureClass
else:
closure_class = return_closure_class(
owlClosure, rdfsClosure, owlExtras, trimming
)
DeductiveClosure(
closure_class,
improved_datatypes=True,
rdfs_closure=rdfsClosure,
axiomatic_triples=axioms,
datatype_axioms=daxioms,
).expand(graph)
if options.format == "rdfxml":
return graph.serialize(format="pretty-xml")
elif options.format == "json":
return graph.serialize(format="json-ld")
else:
return graph.serialize(format="turtle")
OWL-RL-7.1.4/poetry.lock 0000664 0000000 0000000 00000153056 15042011661 0014701 0 ustar 00root root 0000000 0000000 # This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
[[package]]
name = "alabaster"
version = "0.7.13"
description = "A configurable sidebar-enabled Sphinx theme"
optional = false
python-versions = ">=3.6"
groups = ["dev"]
files = [
{file = "alabaster-0.7.13-py3-none-any.whl", hash = "sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3"},
{file = "alabaster-0.7.13.tar.gz", hash = "sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2"},
]
[[package]]
name = "babel"
version = "2.17.0"
description = "Internationalization utilities"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2"},
{file = "babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d"},
]
[package.extras]
dev = ["backports.zoneinfo", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata"]
[[package]]
name = "black"
version = "24.4.2"
description = "The uncompromising code formatter."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "black-24.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dd1b5a14e417189db4c7b64a6540f31730713d173f0b63e55fabd52d61d8fdce"},
{file = "black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e537d281831ad0e71007dcdcbe50a71470b978c453fa41ce77186bbe0ed6021"},
{file = "black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaea3008c281f1038edb473c1aa8ed8143a5535ff18f978a318f10302b254063"},
{file = "black-24.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:7768a0dbf16a39aa5e9a3ded568bb545c8c2727396d063bbaf847df05b08cd96"},
{file = "black-24.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:257d724c2c9b1660f353b36c802ccece186a30accc7742c176d29c146df6e474"},
{file = "black-24.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bdde6f877a18f24844e381d45e9947a49e97933573ac9d4345399be37621e26c"},
{file = "black-24.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e151054aa00bad1f4e1f04919542885f89f5f7d086b8a59e5000e6c616896ffb"},
{file = "black-24.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:7e122b1c4fb252fd85df3ca93578732b4749d9be076593076ef4d07a0233c3e1"},
{file = "black-24.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:accf49e151c8ed2c0cdc528691838afd217c50412534e876a19270fea1e28e2d"},
{file = "black-24.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:88c57dc656038f1ab9f92b3eb5335ee9b021412feaa46330d5eba4e51fe49b04"},
{file = "black-24.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be8bef99eb46d5021bf053114442914baeb3649a89dc5f3a555c88737e5e98fc"},
{file = "black-24.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:415e686e87dbbe6f4cd5ef0fbf764af7b89f9057b97c908742b6008cc554b9c0"},
{file = "black-24.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bf10f7310db693bb62692609b397e8d67257c55f949abde4c67f9cc574492cc7"},
{file = "black-24.4.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:98e123f1d5cfd42f886624d84464f7756f60ff6eab89ae845210631714f6db94"},
{file = "black-24.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48a85f2cb5e6799a9ef05347b476cce6c182d6c71ee36925a6c194d074336ef8"},
{file = "black-24.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:b1530ae42e9d6d5b670a34db49a94115a64596bc77710b1d05e9801e62ca0a7c"},
{file = "black-24.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:37aae07b029fa0174d39daf02748b379399b909652a806e5708199bd93899da1"},
{file = "black-24.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da33a1a5e49c4122ccdfd56cd021ff1ebc4a1ec4e2d01594fef9b6f267a9e741"},
{file = "black-24.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef703f83fc32e131e9bcc0a5094cfe85599e7109f896fe8bc96cc402f3eb4b6e"},
{file = "black-24.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:b9176b9832e84308818a99a561e90aa479e73c523b3f77afd07913380ae2eab7"},
{file = "black-24.4.2-py3-none-any.whl", hash = "sha256:d36ed1124bb81b32f8614555b34cc4259c3fbc7eec17870e8ff8ded335b58d8c"},
{file = "black-24.4.2.tar.gz", hash = "sha256:c872b53057f000085da66a19c55d68f6f8ddcac2642392ad3a355878406fbd4d"},
]
[package.dependencies]
click = ">=8.0.0"
mypy-extensions = ">=0.4.3"
packaging = ">=22.0"
pathspec = ">=0.9.0"
platformdirs = ">=2"
tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""}
[package.extras]
colorama = ["colorama (>=0.4.3)"]
d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"]
jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
uvloop = ["uvloop (>=0.15.2)"]
[[package]]
name = "certifi"
version = "2025.7.14"
description = "Python package for providing Mozilla's CA Bundle."
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2"},
{file = "certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995"},
]
[[package]]
name = "charset-normalizer"
version = "3.4.2"
description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941"},
{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd"},
{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6"},
{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d"},
{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86"},
{file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c"},
{file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0"},
{file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef"},
{file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6"},
{file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366"},
{file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db"},
{file = "charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a"},
{file = "charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509"},
{file = "charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2"},
{file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645"},
{file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd"},
{file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8"},
{file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f"},
{file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7"},
{file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9"},
{file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544"},
{file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82"},
{file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0"},
{file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5"},
{file = "charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a"},
{file = "charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28"},
{file = "charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7"},
{file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3"},
{file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a"},
{file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214"},
{file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a"},
{file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd"},
{file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981"},
{file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c"},
{file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b"},
{file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d"},
{file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f"},
{file = "charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c"},
{file = "charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e"},
{file = "charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0"},
{file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf"},
{file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e"},
{file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1"},
{file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c"},
{file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691"},
{file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0"},
{file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b"},
{file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff"},
{file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b"},
{file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148"},
{file = "charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7"},
{file = "charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-win32.whl", hash = "sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58"},
{file = "charset_normalizer-3.4.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2"},
{file = "charset_normalizer-3.4.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb"},
{file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a"},
{file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45"},
{file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5"},
{file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1"},
{file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027"},
{file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b"},
{file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455"},
{file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01"},
{file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58"},
{file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681"},
{file = "charset_normalizer-3.4.2-cp38-cp38-win32.whl", hash = "sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7"},
{file = "charset_normalizer-3.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a"},
{file = "charset_normalizer-3.4.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4"},
{file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7"},
{file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836"},
{file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597"},
{file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7"},
{file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f"},
{file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba"},
{file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12"},
{file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518"},
{file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5"},
{file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3"},
{file = "charset_normalizer-3.4.2-cp39-cp39-win32.whl", hash = "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471"},
{file = "charset_normalizer-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e"},
{file = "charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0"},
{file = "charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63"},
]
[[package]]
name = "click"
version = "8.1.8"
description = "Composable command line interface toolkit"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2"},
{file = "click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a"},
]
[package.dependencies]
colorama = {version = "*", markers = "platform_system == \"Windows\""}
[[package]]
name = "colorama"
version = "0.4.6"
description = "Cross-platform colored terminal text."
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
groups = ["dev"]
markers = "platform_system == \"Windows\" or sys_platform == \"win32\""
files = [
{file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
{file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
]
[[package]]
name = "docutils"
version = "0.20.1"
description = "Docutils -- Python Documentation Utilities"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"},
{file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"},
]
[[package]]
name = "exceptiongroup"
version = "1.3.0"
description = "Backport of PEP 654 (exception groups)"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
markers = "python_version < \"3.11\""
files = [
{file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"},
{file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"},
]
[package.dependencies]
typing-extensions = {version = ">=4.6.0", markers = "python_version < \"3.13\""}
[package.extras]
test = ["pytest (>=6)"]
[[package]]
name = "idna"
version = "3.10"
description = "Internationalized Domain Names in Applications (IDNA)"
optional = false
python-versions = ">=3.6"
groups = ["dev"]
files = [
{file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},
{file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},
]
[package.extras]
all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"]
[[package]]
name = "imagesize"
version = "1.4.1"
description = "Getting image size from png/jpeg/jpeg2000/gif file"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
groups = ["dev"]
files = [
{file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"},
{file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"},
]
[[package]]
name = "importlib-metadata"
version = "8.5.0"
description = "Read metadata from Python packages"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
markers = "python_version < \"3.10\""
files = [
{file = "importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b"},
{file = "importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7"},
]
[package.dependencies]
zipp = ">=3.20"
[package.extras]
check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
cover = ["pytest-cov"]
doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
enabler = ["pytest-enabler (>=2.2)"]
perf = ["ipython"]
test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"]
type = ["pytest-mypy"]
[[package]]
name = "iniconfig"
version = "2.1.0"
description = "brain-dead simple config-ini parsing"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760"},
{file = "iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7"},
]
[[package]]
name = "isodate"
version = "0.7.2"
description = "An ISO 8601 date/time/duration parser and formatter"
optional = false
python-versions = ">=3.7"
groups = ["main"]
markers = "python_version < \"3.11\""
files = [
{file = "isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15"},
{file = "isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6"},
]
[[package]]
name = "jinja2"
version = "3.1.6"
description = "A very fast and expressive template engine."
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67"},
{file = "jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d"},
]
[package.dependencies]
MarkupSafe = ">=2.0"
[package.extras]
i18n = ["Babel (>=2.7)"]
[[package]]
name = "markupsafe"
version = "2.1.5"
description = "Safely add untrusted strings to HTML/XML markup."
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"},
{file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"},
{file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"},
{file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"},
{file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"},
{file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"},
{file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"},
{file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"},
{file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"},
{file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"},
{file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"},
{file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"},
{file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"},
{file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"},
{file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"},
{file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"},
{file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"},
{file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"},
{file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
]
[[package]]
name = "mypy-extensions"
version = "1.1.0"
description = "Type system extensions for programs checked with the mypy type checker."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505"},
{file = "mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558"},
]
[[package]]
name = "packaging"
version = "25.0"
description = "Core utilities for Python packages"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"},
{file = "packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f"},
]
[[package]]
name = "pathspec"
version = "0.12.1"
description = "Utility library for gitignore style pattern matching of file paths."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"},
{file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"},
]
[[package]]
name = "platformdirs"
version = "4.3.6"
description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
{file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
]
[package.extras]
docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"]
test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"]
type = ["mypy (>=1.11.2)"]
[[package]]
name = "pluggy"
version = "1.5.0"
description = "plugin and hook calling mechanisms for python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
{file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
]
[package.extras]
dev = ["pre-commit", "tox"]
testing = ["pytest", "pytest-benchmark"]
[[package]]
name = "pygments"
version = "2.19.2"
description = "Pygments is a syntax highlighting package written in Python."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b"},
{file = "pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887"},
]
[package.extras]
windows-terminal = ["colorama (>=0.4.6)"]
[[package]]
name = "pyparsing"
version = "3.1.4"
description = "pyparsing module - Classes and methods to define and execute parsing grammars"
optional = false
python-versions = ">=3.6.8"
groups = ["main"]
files = [
{file = "pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c"},
{file = "pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032"},
]
[package.extras]
diagrams = ["jinja2", "railroad-diagrams"]
[[package]]
name = "pytest"
version = "8.3.5"
description = "pytest: simple powerful testing with Python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820"},
{file = "pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845"},
]
[package.dependencies]
colorama = {version = "*", markers = "sys_platform == \"win32\""}
exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
iniconfig = "*"
packaging = "*"
pluggy = ">=1.5,<2"
tomli = {version = ">=1", markers = "python_version < \"3.11\""}
[package.extras]
dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
[[package]]
name = "rdflib"
version = "7.1.4"
description = "RDFLib is a Python library for working with RDF, a simple yet powerful language for representing information."
optional = false
python-versions = "<4.0.0,>=3.8.1"
groups = ["main"]
files = [
{file = "rdflib-7.1.4-py3-none-any.whl", hash = "sha256:72f4adb1990fa5241abd22ddaf36d7cafa5d91d9ff2ba13f3086d339b213d997"},
{file = "rdflib-7.1.4.tar.gz", hash = "sha256:fed46e24f26a788e2ab8e445f7077f00edcf95abb73bcef4b86cefa8b62dd174"},
]
[package.dependencies]
isodate = {version = ">=0.7.2,<1.0.0", markers = "python_version < \"3.11\""}
pyparsing = ">=2.1.0,<4"
[package.extras]
berkeleydb = ["berkeleydb (>=18.1.0,<19.0.0)"]
html = ["html5rdf (>=1.2,<2)"]
lxml = ["lxml (>=4.3,<6.0)"]
networkx = ["networkx (>=2,<4)"]
orjson = ["orjson (>=3.9.14,<4)"]
[[package]]
name = "requests"
version = "2.32.4"
description = "Python HTTP for Humans."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"},
{file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"},
]
[package.dependencies]
certifi = ">=2017.4.17"
charset_normalizer = ">=2,<4"
idna = ">=2.5,<4"
urllib3 = ">=1.21.1,<3"
[package.extras]
socks = ["PySocks (>=1.5.6,!=1.5.7)"]
use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
[[package]]
name = "snowballstemmer"
version = "3.0.1"
description = "This package provides 32 stemmers for 30 languages generated from Snowball algorithms."
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*"
groups = ["dev"]
files = [
{file = "snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064"},
{file = "snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895"},
]
[[package]]
name = "sphinx"
version = "7.1.2"
description = "Python documentation generator"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "sphinx-7.1.2-py3-none-any.whl", hash = "sha256:d170a81825b2fcacb6dfd5a0d7f578a053e45d3f2b153fecc948c37344eb4cbe"},
{file = "sphinx-7.1.2.tar.gz", hash = "sha256:780f4d32f1d7d1126576e0e5ecc19dc32ab76cd24e950228dcf7b1f6d3d9e22f"},
]
[package.dependencies]
alabaster = ">=0.7,<0.8"
babel = ">=2.9"
colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""}
docutils = ">=0.18.1,<0.21"
imagesize = ">=1.3"
importlib-metadata = {version = ">=4.8", markers = "python_version < \"3.10\""}
Jinja2 = ">=3.0"
packaging = ">=21.0"
Pygments = ">=2.13"
requests = ">=2.25.0"
snowballstemmer = ">=2.0"
sphinxcontrib-applehelp = "*"
sphinxcontrib-devhelp = "*"
sphinxcontrib-htmlhelp = ">=2.0.0"
sphinxcontrib-jsmath = "*"
sphinxcontrib-qthelp = "*"
sphinxcontrib-serializinghtml = ">=1.1.5"
[package.extras]
docs = ["sphinxcontrib-websupport"]
lint = ["docutils-stubs", "flake8 (>=3.5.0)", "flake8-simplify", "isort", "mypy (>=0.990)", "ruff", "sphinx-lint", "types-requests"]
test = ["cython", "filelock", "html5lib", "pytest (>=4.6)"]
[[package]]
name = "sphinxcontrib-applehelp"
version = "1.0.4"
description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "sphinxcontrib-applehelp-1.0.4.tar.gz", hash = "sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e"},
{file = "sphinxcontrib_applehelp-1.0.4-py3-none-any.whl", hash = "sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228"},
]
[package.extras]
lint = ["docutils-stubs", "flake8", "mypy"]
test = ["pytest"]
[[package]]
name = "sphinxcontrib-devhelp"
version = "1.0.2"
description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp document."
optional = false
python-versions = ">=3.5"
groups = ["dev"]
files = [
{file = "sphinxcontrib-devhelp-1.0.2.tar.gz", hash = "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"},
{file = "sphinxcontrib_devhelp-1.0.2-py2.py3-none-any.whl", hash = "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e"},
]
[package.extras]
lint = ["docutils-stubs", "flake8", "mypy"]
test = ["pytest"]
[[package]]
name = "sphinxcontrib-htmlhelp"
version = "2.0.1"
description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "sphinxcontrib-htmlhelp-2.0.1.tar.gz", hash = "sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff"},
{file = "sphinxcontrib_htmlhelp-2.0.1-py3-none-any.whl", hash = "sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903"},
]
[package.extras]
lint = ["docutils-stubs", "flake8", "mypy"]
test = ["html5lib", "pytest"]
[[package]]
name = "sphinxcontrib-jsmath"
version = "1.0.1"
description = "A sphinx extension which renders display math in HTML via JavaScript"
optional = false
python-versions = ">=3.5"
groups = ["dev"]
files = [
{file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"},
{file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"},
]
[package.extras]
test = ["flake8", "mypy", "pytest"]
[[package]]
name = "sphinxcontrib-qthelp"
version = "1.0.3"
description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp document."
optional = false
python-versions = ">=3.5"
groups = ["dev"]
files = [
{file = "sphinxcontrib-qthelp-1.0.3.tar.gz", hash = "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72"},
{file = "sphinxcontrib_qthelp-1.0.3-py2.py3-none-any.whl", hash = "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6"},
]
[package.extras]
lint = ["docutils-stubs", "flake8", "mypy"]
test = ["pytest"]
[[package]]
name = "sphinxcontrib-serializinghtml"
version = "1.1.5"
description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)."
optional = false
python-versions = ">=3.5"
groups = ["dev"]
files = [
{file = "sphinxcontrib-serializinghtml-1.1.5.tar.gz", hash = "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"},
{file = "sphinxcontrib_serializinghtml-1.1.5-py2.py3-none-any.whl", hash = "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd"},
]
[package.extras]
lint = ["docutils-stubs", "flake8", "mypy"]
test = ["pytest"]
[[package]]
name = "tomli"
version = "2.2.1"
description = "A lil' TOML parser"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
markers = "python_version < \"3.11\""
files = [
{file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
{file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
{file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"},
{file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"},
{file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"},
{file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"},
{file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"},
{file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"},
{file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"},
{file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"},
{file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"},
{file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"},
{file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"},
{file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"},
{file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"},
{file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"},
{file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"},
{file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"},
{file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"},
{file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"},
{file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"},
{file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"},
{file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"},
{file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"},
{file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"},
{file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"},
{file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"},
{file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"},
{file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"},
{file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"},
{file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},
{file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},
]
[[package]]
name = "typing-extensions"
version = "4.13.2"
description = "Backported and Experimental Type Hints for Python 3.8+"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
markers = "python_version < \"3.11\""
files = [
{file = "typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c"},
{file = "typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef"},
]
[[package]]
name = "urllib3"
version = "2.2.3"
description = "HTTP library with thread-safe connection pooling, file post, and more."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"},
{file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"},
]
[package.extras]
brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
h2 = ["h2 (>=4,<5)"]
socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
zstd = ["zstandard (>=0.18.0)"]
[[package]]
name = "zipp"
version = "3.20.2"
description = "Backport of pathlib-compatible object wrapper for zip files"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
markers = "python_version < \"3.10\""
files = [
{file = "zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350"},
{file = "zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29"},
]
[package.extras]
check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]
cover = ["pytest-cov"]
doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
enabler = ["pytest-enabler (>=2.2)"]
test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"]
type = ["pytest-mypy"]
[metadata]
lock-version = "2.1"
python-versions = ">=3.9,<4.0"
content-hash = "21295d04cc780525e82f6de98a984a56dd82468e1754440dca99c058ce44bbdc"
OWL-RL-7.1.4/pypi.txt 0000664 0000000 0000000 00000000443 15042011661 0014216 0 ustar 00root root 0000000 0000000 rm -r .pytest_cache build dist owlrl.egg-info
git commit -am "..."
git tag "v5.2.3"
git push
git push --tags
# markup release on GitHub - https://github.com/RDFLib/OWL-RL/releases
python setup.py bdist_wheel sdist
twine upload ./dist/*
build docco
`python setup.py build_sphinx`
OWL-RL-7.1.4/pyproject.toml 0000664 0000000 0000000 00000001143 15042011661 0015406 0 ustar 00root root 0000000 0000000 [tool.poetry]
name = "owlrl"
version = "7.1.4"
description = "A simple implementation of the OWL2 RL Profile, as well as a basic RDFS inference, on top of RDFLib. Based mechanical forward chaining."
authors = ["Nicholas Car "]
license = "W3C software and Document Notice License"
readme = "README.rst"
packages = [{include = "owlrl"}]
[tool.poetry.dependencies]
python = ">=3.9,<4.0"
rdflib = ">=7.1.4"
[tool.poetry.group.dev.dependencies]
black = "24.4.2"
sphinx = ">=7.1.2,<8"
pytest = ">=7.1.3,<9.0.0"
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"
OWL-RL-7.1.4/scripts/ 0000775 0000000 0000000 00000000000 15042011661 0014162 5 ustar 00root root 0000000 0000000 OWL-RL-7.1.4/scripts/RDFConvertService 0000775 0000000 0000000 00000012034 15042011661 0017405 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Possible CGI entry point for the owl package.
@author: U{Ivan Herman}
@license: This software is available for use under the
U{W3C® SOFTWARE NOTICE AND LICENSE}
@contact: Ivan Herman, ivan@w3.org
"""
"""
$Id: RDFConvertService.py,v 1.3 2009/07/10 08:45:14 ivan Exp $
"""
import os
import sys
import cgi
import cgitb
# prevent accidentally importing `scripts/owlrl` file when calling
# `from owlrl import ...` below.
HERE_DIR = os.path.abspath(os.path.dirname(__file__))
if HERE_DIR in sys.path:
sys.path.remove(HERE_DIR)
# Add 'owlrl' module from the parent directory into the path if it exists.
PARENT_DIR = os.path.dirname(HERE_DIR)
parent_dir_list = os.listdir(PARENT_DIR)
if 'owlrl' in parent_dir_list:
possible_owlrl = os.path.join(PARENT_DIR, 'owlrl')
if os.path.isdir(possible_owlrl):
sys.path.append(possible_owlrl)
__version__ = "4.0"
cgitb.enable()
form = cgi.FieldStorage()
from owlrl import convert_graph, RDFXML, TURTLE, AUTO
# ---------------------------------------------------------------------------------------------------------------------
class Options:
def __init__(self, frm):
self.iformat = AUTO
self.owlClosure = "no"
self.rdfsClosure = "no"
self.owlExtras = "no"
self.axioms = "no"
self.daxioms = "no"
self.sources = []
self.text = None
self.format = TURTLE
if "source_1" in list(frm.keys()):
self.sources.append(frm["source_1"].value)
if "source_2" in list(frm.keys()):
self.sources.append(frm["source_2"].value)
if "text" in list(frm.keys()):
self.text = frm["text"].value
if "format" in list(frm.keys()):
self.format = frm["format"].value
if "iformat" in list(frm.keys()):
v = frm["iformat"].value
if v == "xml" or v == "turtle":
self.iformat = v
if "fullClosure" in list(frm.keys()) and frm["fullClosure"].value == "yes":
self.owlClosure = "yes"
self.rdfsClosure = "yes"
self.axioms = "no"
self.daxioms = "no"
self.owlExtras = "no"
else:
if "owlClosure" in list(frm.keys()):
self.owlClosure = frm["owlClosure"].value
if "rdfsClosure" in list(frm.keys()):
self.rdfsClosure = frm["rdfsClosure"].value
if "owlExtras" in list(frm.keys()):
self.owlExtras = frm["owlExtras"].value
if "axioms" in list(frm.keys()):
self.axioms = frm["axioms"].value
if "daxioms" in list(frm.keys()):
self.daxioms = frm["daxioms"].value
# this one is for backward compatibility...
if "uri" in list(frm.keys()):
self.sources.append(frm["uri"].value)
if "source" in list(frm.keys()):
self.sources.append(frm["source"].value)
def to_html(self):
print('
