Man Linux: Main Page and Category List

NAME  -  Closed  World  Machine,  an  RDF/N3  semantic  web  data


       Command line RDF/N3 tool

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


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

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

              Input & Output in N3 and set N3 flags

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

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

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

       --ugly Store input and regurgitate, data only, fastest *

              Store input and regurgitate in subject order *

       --no   No output *
              (default is to store and pretty print with anonymous nodes) *

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

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

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

                     Read patches from foo, applying insertions and  deletions
                     to store

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

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

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

                     Apply rules in store  to  store,  adding  conclusions  to

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

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

              --why  Replace the store with an explanation of its contents

                     proof tries to be shorter

                     Set modus operandi for inference (see below)

                     Replace  the  statements  in  the  store  with statements
                     describing them.

                     Undo the effects of --reify

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

                     Undo the effects of --flatten

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

                     Remove from store any triple involving anything in  class

              --data Remove  all  except  plain RDF triples (formulae, forAll,

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

                     Enable  processing  of crypto builtin functions. Requires
                     python crypto.

              --help print this message

                     print CVS revision numbers of major modules

                     Verbose debugging output of questionable use, range 0-99

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

                     After sparql query, print in sparqlResults format instead
                     of rdf


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

                     *  mutually  exclusive  ** doesn’t work for complex cases


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

       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

       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

       import md5, binascii
              # for building md5 URIs

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