owl-db-tools.core — com.github.pdenno/owl-db-tools 1.0.42

Load the datahike (DH) database from Jena content; define pathom resolvers.

*conn* clj

A dynamic var that is bound to a DB connection on db-create

app-schema clj

arg-prefix-maps clj

(arg-prefix-maps ontos)

Define a map relating prefixes to URIs for the create-db ontos argument.

box-value clj

(box-value v triple)

Boxing is the process of converting a value type to the type object. Return the value boxed as a map where the key identifies the type. This is necessary where an owl property can have multiple types (like :owl/oneOf).

boxed-property? clj

These can take multiple values of various types, some need to be boxed.

create-db! clj

(create-db! db-cfg
            ontos
            &
            {:keys [check-sites check-sites-timeout rebuild? user-attrs]
             :or {check-sites-timeout 15000}})

If rebuild? is true, read OWL with Jena and write it into a Datahike DB. Otherwise, just set the connection atom, conn. BTW, if this doesn't get a response within 15 secs from slurping odp.org, it doesn't rebuild the DB.

debugging? clj

distinct-temps clj

(distinct-temps mm temps)

The maps from resolve-temps :perm-data can contain field values that contain temps. The values the temps refer to ought to be unique. If they aren't this function returns the map with such vectors dropping the duplicates.

full-schema clj

The currently schema, consisting of static-schema plus what is learned while loading.

keywordize-triple clj

(keywordize-triple {:?/syms [x y z]})

From Jena, all the resources come back as symbols in either namespace '_' or 'http:'. These are to be rendered as keywords in the namespace 'temp' for _, and the short prefix for the full URL otherwise. The function returns a vector of the converted [x y z] triple.

learn-cardinality clj

(learn-cardinality prop examples)

Return either :db.cardinality/many or :db.cardinality/one based on evidence.

learn-schema! clj

(learn-schema! dvecs conn)

Create a schema from what we know about the owl, rdfs, and rdf parts plus any additional triples created by ontologies.

learn-type clj

(learn-type prop examples)

Return the :db/valueType for the data.

list-starters clj

(list-starters dvecs)

Return a list of triples that start lists. They have a :rdf/first, but they aren't used as the :rdf/rest of anything.

load-inline clj

(load-inline src)

When (:access src) is the keyword :inline, then src will also include :inline-data

load-jena clj

(load-jena {:keys [uri access format] :as src})

Using Jena, return an rdf/KB object with the argument ontologies loaded.

load-local clj

(load-local src)

Load an ontology stored in a file in resources.

load-remote clj

(load-remote src & {:keys [timeout] :or {timeout 10000}})

Experience suggests some sites (e.g. ontologydesignpatterns.org) cannot be relied upon. Return nil if you can't load from the :access URL, otherwise return the stream.

loaded-ok? clj

When false it is usually because of a timeout slurping a URL.

long2short clj

a map from URI strings to prefix strings

lookup-resource clj

(lookup-resource id conn)

Return the :db/id of the resource given the its ns-qualified keyword identifier.

mark-as-stored clj

(mark-as-stored onto-spec conn)

Add :source/loaded? true to the onto spec

multi-valued-property? clj

Properties where the object can have many values Many-valued properties aren't the same as things bearing temp values. For example, :owl/complement of can have a temp.

not-stored-property? clj

These aren't stored; they are used to create vectors.

onto-keyword clj

(onto-keyword sym)

Return the keyword representing an ontology or schema (e.g. RDF).

owl-schema clj

partition-temp-perm clj

(partition-temp-perm dmapv)

Create a map with two keys: :temp-data - a map of temp resources indexed by their :resource/iri. :perm-data - a subset of the argument vector with temp maps removed.

prefix-maps clj

(prefix-maps jkb conn)

Define a map relating prefixes to URIs found by means of the Jena. Check whether the DB already has a short-name for that resource (user might have specified it). If a short-name already exists, keep it. (Both long and short are db.unique db.identity, intentionally, so you really can't change it anyway.

rdf-schema clj

rdfs-schema clj

real-keyword? clj

Other keywords are assumed to be resources

reset-for-new-db! clj

(reset-for-new-db!)

resolve-rdf-lists clj

(resolve-rdf-lists dvecs)

Return a map of toplevel rdf/Lists.

resolve-temp-internal clj

(resolve-temp-internal temp-maps)

Temp resources can reference other temp resources. This resolves everything.

resolve-temp-refs clj

(resolve-temp-refs dmapv conn)

resolve-temps created references to resources, :resource/temp-ref. Stubs for all :resource/iris were transacted to the DB. This recursively replaces :resource/temp-ref with their DH entity ID. Argument is a vector of maps, one for each resource.

resolve-temps clj

(resolve-temps dmapv)

Replace every temp reference with its value. Argument is a vector of maps.

resource-ids clj

(resource-ids conn)

Return a vector of resource keywords

schema-attributes clj

(schema-attributes conn & {:keys [origin] :or {origin #{:learned :user}}})

Return a vector of maps of learned or user schema elements. Arguments: conn - a database connection. :origin - an optional keyword argument consisting of a set containing any of #{:all, :learned :user}. The default value for this argument is #{:learned :user}.

single-valued-property? clj

The following are properties that can only take one value.

site-online? clj

(site-online? url timeout)

Return true if the site reacts within timeout

sources clj

(sources conn & {:keys [l2s]})

Return maps describing what was loaded

static-schema clj

The subset of schema define above.

store-onto! clj

(store-onto! conn jena-maps)

Transform RDF triples in argument jena-maps, resolve rdf/List, create maps of resources. Then store it.

temp-id? clj

(temp-id? k)

transact? clj

(transact? conn data & {:keys [check-data?] :or {check-data? debugging?}})

Optionally check that the data is valid before sending it. Does not compare against the schema. Currenlty only checks for nils.

triples2maps clj

(triples2maps dvecs rdf-lists)

Iterate through the triples returning a map keyed by the RDF resource (keyword) represented.

update-long2short! clj

(update-long2short! conn)

Return a map from uri strings to prefix strings

valid-for-transact? clj

(valid-for-transact? data)