# rdflib.namespace package

## Module contents

### Namespace Utilities

RDFLib provides mechanisms for managing Namespaces.

In particular, there is a `Namespace` class that takes as its argument the base URI of the namespace.

    >>> from rdflib.namespace import Namespace
    >>> RDFS = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")

Fully qualified URIs in the namespace can be constructed either by attribute or by dictionary access on Namespace instances:

    >>> RDFS.seeAlso
    rdflib.term.URIRef('http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso')
    >>> RDFS['seeAlso']
    rdflib.term.URIRef('http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso')

#### Automatic handling of unknown predicates

As a programming convenience, a namespace binding is automatically created when `rdflib.term.URIRef` predicates are added to the graph.

#### Importable namespaces

The following namespaces are available by directly importing from rdflib:

- BRICK

- CSVW

- DC

- DCAT

- DCMITYPE

- DCTERMS

- DCAM

- DOAP

- FOAF

- ODRL2

- ORG

- OWL

- PROF

- PROV

- QB

- RDF

- RDFS

- SDO

- SH

- SKOS

- SOSA

- SSN

- TIME

- VANN

- VOID

- XSD

class rdflib.namespace.ClosedNamespace(uri, terms)

  Bases: `rdflib.namespace.Namespace`

  A namespace with a closed list of members

  Trying to create terms not listed is an error

  __annotations__ = {}
  __contains__(ref)

    Allows to check if a URI is within (starts with) this Namespace.

        >>> from rdflib import URIRef
        >>> namespace = Namespace('http://example.org/')
        >>> uri = URIRef('http://example.org/foo')
        >>> uri in namespace
        True
        >>> person_class = namespace['Person']
        >>> person_class in namespace
        True
        >>> obj = URIRef('http://not.example.org/bar')
        >>> obj in namespace
        False

  __dir__()

    Default dir() implementation.

  __getattr__(name)
  __getitem__(key)

    Return self[key].

  __module__ = 'rdflib.namespace'
  static __new__(cls, uri, terms)
  __repr__()

    Return repr(self).

  term(name)
  property uri

class rdflib.namespace.Namespace(value)

  Bases: `str`

  Utility class for quickly generating URIRefs with a common prefix

      >>> from rdflib.namespace import Namespace
      >>> n = Namespace("http://example.org/")
      >>> n.Person # as attribute
      rdflib.term.URIRef('http://example.org/Person')
      >>> n['first-name'] # as item - for things that are not valid python identifiers
      rdflib.term.URIRef('http://example.org/first-name')
      >>> n.Person in n
      True
      >>> n2 = Namespace("http://example2.org/")
      >>> n.Person in n2
      False

  __annotations__ = {}
  __contains__(ref)

    Allows to check if a URI is within (starts with) this Namespace.

        >>> from rdflib import URIRef
        >>> namespace = Namespace('http://example.org/')
        >>> uri = URIRef('http://example.org/foo')
        >>> uri in namespace
        True
        >>> person_class = namespace['Person']
        >>> person_class in namespace
        True
        >>> obj = URIRef('http://not.example.org/bar')
        >>> obj in namespace
        False

  __dict__ = mappingproxy({'__module__': 'rdflib.namespace', '__doc__': '\n Utility class for quickly generating URIRefs with a common prefix\n\n >>> from rdflib.namespace import Namespace\n >>> n = Namespace("http://example.org/")\n >>> n.Person # as attribute\n rdflib.term.URIRef(\'http://example.org/Person\')\n >>> n[\'first-name\'] # as item - for things that are not valid python identifiers\n rdflib.term.URIRef(\'http://example.org/first-name\')\n >>> n.Person in n\n True\n >>> n2 = Namespace("http://example2.org/")\n >>> n.Person in n2\n False\n ', '__new__': <staticmethod(<function Namespace.__new__>)>, 'title': <property object>, 'term': <function Namespace.term>, '__getitem__': <function Namespace.__getitem__>, '__getattr__': <function Namespace.__getattr__>, '__repr__': <function Namespace.__repr__>, '__contains__': <function Namespace.__contains__>, '__dict__': <attribute '__dict__' of 'Namespace' objects>, '__weakref__': <attribute '__weakref__' of 'Namespace' objects>, '__annotations__': {}})
  __getattr__(name)
  __getitem__(key)

    Return self[key].

  __module__ = 'rdflib.namespace'
  static __new__(cls, value)
  __repr__()

    Return repr(self).

  __weakref__

    list of weak references to the object (if defined)

  term(name)
  property title

    Return a version of the string where each word is titlecased.

    More specifically, words start with uppercased characters and all remaining cased characters have lower case.

class rdflib.namespace.NamespaceManager(graph)

  Bases: `object`

  Class for managing prefix => namespace mappings

  Sample usage from FuXi …

      ruleStore = N3RuleStore(additionalBuiltins=additionalBuiltins)
      nsMgr = NamespaceManager(Graph(ruleStore))
      ruleGraph = Graph(ruleStore,namespace_manager=nsMgr)

  and …

      >>> import rdflib
      >>> from rdflib import Graph
      >>> from rdflib.namespace import Namespace, NamespaceManager
      >>> exNs = Namespace('http://example.com/')
      >>> namespace_manager = NamespaceManager(Graph())
      >>> namespace_manager.bind('ex', exNs, override=False)
      >>> g = Graph()
      >>> g.namespace_manager = namespace_manager
      >>> all_ns = [n for n in g.namespace_manager.namespaces()]
      >>> assert ('ex', rdflib.term.URIRef('http://example.com/')) in all_ns
      >>>

  __contains__(ref)
  __dict__ = mappingproxy({'__module__': 'rdflib.namespace', '__doc__': "\n\n Class for managing prefix => namespace mappings\n\n Sample usage from FuXi ...\n\n .. code-block:: python\n\n ruleStore = N3RuleStore(additionalBuiltins=additionalBuiltins)\n nsMgr = NamespaceManager(Graph(ruleStore))\n ruleGraph = Graph(ruleStore,namespace_manager=nsMgr)\n\n\n and ...\n\n .. code-block:: pycon\n\n >>> import rdflib\n >>> from rdflib import Graph\n >>> from rdflib.namespace import Namespace, NamespaceManager\n >>> exNs = Namespace('http://example.com/')\n >>> namespace_manager = NamespaceManager(Graph())\n >>> namespace_manager.bind('ex', exNs, override=False)\n >>> g = Graph()\n >>> g.namespace_manager = namespace_manager\n >>> all_ns = [n for n in g.namespace_manager.namespaces()]\n >>> assert ('ex', rdflib.term.URIRef('http://example.com/')) in all_ns\n >>>\n\n ", '__init__': <function NamespaceManager.__init__>, '__contains__': <function NamespaceManager.__contains__>, 'reset': <function NamespaceManager.reset>, 'store': <property object>, 'qname': <function NamespaceManager.qname>, 'qname_strict': <function NamespaceManager.qname_strict>, 'normalizeUri': <function NamespaceManager.normalizeUri>, 'compute_qname': <function NamespaceManager.compute_qname>, 'compute_qname_strict': <function NamespaceManager.compute_qname_strict>, 'bind': <function NamespaceManager.bind>, 'namespaces': <function NamespaceManager.namespaces>, 'absolutize': <function NamespaceManager.absolutize>, '__dict__': <attribute '__dict__' of 'NamespaceManager' objects>, '__weakref__': <attribute '__weakref__' of 'NamespaceManager' objects>, '__annotations__': {}})
  __init__(graph)
  __module__ = 'rdflib.namespace'
  __weakref__

    list of weak references to the object (if defined)

  absolutize(uri, defrag=1)
  bind(prefix, namespace, override=True, replace=False)

    bind a given namespace to the prefix

    if override, rebind, even if the given namespace is already bound to another prefix.

    if replace, replace any existing prefix with the new namespace

  compute_qname(uri, generate=True)
  compute_qname_strict(uri, generate=True)
  namespaces()
  normalizeUri(rdfTerm) → str

    Takes an RDF Term and ‘normalizes’ it into a QName (using the registered prefix) or (unlike compute_qname) the Notation 3 form for URIs: <…URI…>

  qname(uri)
  qname_strict(uri)
  reset()
  property store

rdflib.namespace.is_ncname(name)

rdflib.namespace.split_uri(uri, split_start=['Ll', 'Lu', 'Lo', 'Lt', 'Nl', 'Nd'])