Man Linux: Main Page and Category List

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

why.py:30: DeprecationWarning: the Junem2010e is deprecated; use WHY.PY:30:(1)ad