kathaireo

Kathaireo is intended to become an interactive shell for operating on RDF and stuff. Its makes use of rdflib and rdflib-sqlalchemy.

Main goal is to provide a fast and slim tool for easier work on RDF, OWL, etc. ontologies, including imports local and remote sources, persistent storage with Sqlite etc., namespace support and convenience features like context-aware autocompletion and reference resolution.

command declaration

Custom commands can easily be added to extend the list of predefined ones. This might make it easier to hack specialized plugins at some point.

Registration of a new command works like this:

from kathaireo import commands
from kathaireo import rdf

def triples_with_object(*args, **kwargs):
	name = kwargs.get("graphname") # access argument values as defined
	objid = kwargs.get("ontoclass") # in command syntax
	o = rdf.rdflib.URIRef(objid)
	g = rdf.get_graph(name)
	for s,p in g.subject_predicates(o):
		print s,p
	g.subject_predicates(rdf.rdflib.URIRef()):

commands.register("triples <graphname> object <ontoclass>", triples_with_object)
commands.parse("create g") # create a new RDF graph with identifier 'g'
commands.parse("load file.rdf g") # import contents of local RDF file
commands.parse("triples g object http://www.w3.org/2000/01/rdf-schema#Class")

Thanks to the decorator @cmd_handler, handler functions can be implemented wherever convenient, without worrying about additionally binding commands syntaxes. Binding and registration can be let done automatically by having said decorator take care of introducing the handler to the commands.handlers module's namespace, and fixing its invocation for user input satisfying command syntax specifications simply placed anywhere the docstring:

from kathaireo import cmd_handler

@cmd_handler
def triples_with_object(*args, **kwargs):
	"""Returns list of triples with a specified identifier as object.
	handles:
	`triples <graphname> object <ontoclass>`"""
	[...]

That's it.

parameter configuration

Whenever a new command argument type is introduced by submitting an <argument> placeholder, it may also be desirable to configure its possible values, rather than having those determined by default value constraints. This is what the kathaireo.commands.arguments module is for. Its function register(name, proposer=function, format=list) adds an argument's name to a registry and assigns to it a handler function for user input autocompletion proposals and a list of regular expressions for value validation.

A function to be registered as an argument's autocompletion provider must accept two parameters: the argument's name and the prefix to be completed. It is expected to return a list of autocompletion candidates, i.e. of legal values fitting the currently prepared user input.

When calling commands.register(arg) whithout passing any values for proposer or format, the default behaviour in autocompletion of <arg> values will be that of looking up previously entered values for <arg>, and validation will merely check if input qualifies as a legal variable name, i.e. consists only of alphanumeric characters and underscores. To complete the above example code, we subscribe to those default features for the argument introduced by command triples as <ontoclass>:

	commands.arguments.register('ontoclass')

Of course, other commands can make use of the same argument placeholder, if the assigned configurations fit their purpose as well.

The following code is an example of overwriting the default handling. It implements and specifies autocompletion and validation for input submitted as a value of filename arguments:

import os
import re
from glob import glob

def list_files(arg, prefix):
	path = prefix.split(os.sep)[:-1]
	files = glob(os.path.join(os.sep.join(path), '*'))
	compl = [[fn for fn in files if fn.startswith(prefix)]
	arghist = commands.arguments.propose_default(arg, prefix)
	compl.extend(arghist) # suggest previous values
	return compl

commands.arguments.register('filename', proposer=list_files, 
	format=[re.compile(''(/?[^/\s]+/)*\w*\.\w+')])