Owlrl

~~~~~~

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`)

~~~~~~~~~~~~~

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.

~~~~~~~~~~~~~

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.

~~~~~~~~~~~

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

~~~~~~~~~~~

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.

~~~~~~~~~~~

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.