Linux Certif

Toute la documentation sur la certification Linux LPI

cwm

NAME

why.py:30: - Closed World Machine, an RDF/N3 semantic web data processor

DESCRIPTION

Command line RDF/N3 tool

<command> <options> <steps> [--with <more args> ]

OPTIONS

--pipe

Don't store, just pipe out *

steps, in order left to right:

--rdf

Input & Output ** in RDF/XML instead of n3 from now on

--n3

Input & Output in N3 from now on. (Default)

--rdf=flags

Input & Output ** in RDF and set given RDF flags

--n3=flags

Input & Output in N3 and set N3 flags

--ntriples

Input & Output in NTriples (equiv --n3=usbpartane -bySubject -quiet)

--language=x

Input & Output in "x" (rdf, n3, etc) --rdf same as: --language=rdf

--languageOptions=y

--n3=sp same as: --language=n3 --languageOptions=sp

--ugly

Store input and regurgitate, data only, fastest *

--bySubject

Store input and regurgitate in subject order *

--no

No output *

(default is to store and pretty print with anonymous nodes) *

--base=<uri>

Set the base URI. Input or output is done as though this were the document URI.

--closure=flags

Control automatic lookup of identifiers (see below) <uri> Load document. URI may be relative to current directory.

--apply=foo

Read rules from foo, apply to store, adding conclusions to store

--patch=foo

Read patches from foo, applying insertions and deletions to store

--filter=foo

Read rules from foo, apply to store, REPLACING store with conclusions

--query=foo

Read a N3QL query from foo, apply it to the store, and replace the store with its conclusions

--sparql=foo

Read a SPARQL query from foo, apply it to the store, and replace the store with its conclusions

--rules

Apply rules in store to store, adding conclusions to store

--think

as -rules but continue until no more rule matches (or forever!)

--engine=otter

use otter (in your $PATH) instead of llyn for linking, etc

--why

Replace the store with an explanation of its contents

--why=u

proof tries to be shorter

--mode=flags

Set modus operandi for inference (see below)

--reify

Replace the statements in the store with statements describing them.

--dereify

Undo the effects of --reify

--flatten

Reify only nested subexpressions (not top level) so that no {} remain.

--unflatten

Undo the effects of --flatten

--think=foo

as -apply=foo but continue until no more rule matches (or forever!)

--purge

Remove from store any triple involving anything in class log:Chaff

--data

Remove all except plain RDF triples (formulae, forAll, etc)

--strings

Dump :s to stdout ordered by :k whereever { :k log:outputString :s }

--crypto

Enable processing of crypto builtin functions. Requires python crypto.

--help

print this message

--revision

print CVS revision numbers of major modules

--chatty=50

Verbose debugging output of questionable use, range 0-99

--sparqlServer

instead of outputting, start a SPARQL server on port 8000 of the store

--sparqlResults

After sparql query, print in sparqlResults format instead of rdf

finally:

--with

Pass any further arguments to the N3 store as os:argv values

* mutually exclusive ** doesn't work for complex cases :-/

EXAMPLES

cwm --rdf foo.rdf --n3 --pipe

Convert from rdf/xml to rdf/n3

cwm foo.n3 bar.n3 --think

Combine data and find all deductions

cwm foo.n3 --flat --n3=spart

Mode flags affect inference extending to the web:

r

Needed to enable any remote stuff.

a

When reading schema, also load rules pointed to by schema (requires r, s)

E

Errors loading schemas of definitive documents are ignored

m

Schemas and definitive documents loaded are merged into the meta knowledge (otherwise they are consulted independently)

s

Read the schema for any predicate in a query.

u

Generate unique ids using a run-specific

Closure flags are set to cause the working formula to be automatically expanded to the closure under the operation of looking up:

s

the subject of a statement added

p

the predicate of a statement added

o

the object of a statement added

t

the object of an rdf:type statement added

i

any owl:imports documents

r

any doc:rules documents

E

errors are ignored --- This is independant of --mode=E

n

Normalize IRIs to URIs

e

Smush together any nodes which are = (owl:sameAs)

See http://www.w3.org/2000/10/swap/doc/cwm for more documentation.

Setting the environment variable CWM_RDFLIB to 1 makes Cwm use rdflib to parse rdf/xml files. Note that this requires rdflib.

Flags for N3 output are as follows:-

a Anonymous nodes should be output using the _: convention (p flag or not). d Don't use default namespace (empty prefix) e escape literals --- use \u notation i Use identifiers from store - don't regen on output l List syntax suppression. Don't use (..) n No numeric syntax - use strings typed with ^^ syntax p Prefix suppression - don't use them, always URIs in <> instead of qnames. q Quiet - don't output comments about version and base URI used. r Relative URI suppression. Always use absolute URIs. s Subject must be explicit for every statement. Don't use ";" shorthand. t "this" and "()" special syntax should be suppressed. u Use \u for unicode escaping in URIs instead of utf-8 %XX v Use "this log:forAll" for @forAll, and "this log:forAll" for "@forSome". / If namespace has no # in it, assume it ends at the last slash if outputting.

Flags for N3 input:

B Turn any blank node into an existentially qualified explicitly named node.

Flags to control RDF/XML output (after --rdf=) areas follows:

b - Don't use nodeIDs for Bnodes c - Don't use elements as class names d - Default namespace supressed. l - Don't use RDF collection syntax for lists r - Relative URI suppression. Always use absolute URIs. z - Allow relative URIs for namespaces

Flags to control RDF/XML INPUT (after --rdf=) follow:

S

- Strict spec. Unknown parse type treated as Literal instead of error.

T

- take foreign XML as transparent and parse any RDF in it

(default is to ignore unless rdf:RDF at top level)

L

- If non-rdf attributes have no namespace prefix, assume in local <#> namespace

D

- Assume default namespace declared as local document is assume xmlns=""

R

- Do not require an outer <rdf:RDF>, treating the file as RDF content (opposite of T)

Note: The parser (sax2rdf) does not support reification, bagIds, or parseType=Literal.

It does support the rest of RDF incl. datatypes, xml:lang, and nodeIds.

import md5, binascii

# for building md5 URIs

1.197