merged in changes from naming_cleanup branch; bumped version to 2.5.0

43 files changed, 413 insertions, 411 deletions

diff --git a/LICENSE b/LICENSE
index 8a408519..4792949e 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
-LICENSE AGREEMENT FOR RDFLIB 0.9.0 THROUGH 2.4.1
+LICENSE AGREEMENT FOR RDFLIB 0.9.0 THROUGH 2.5.0
 ------------------------------------------------
-Copyright (c) 2002-2007, Daniel Krech, http://eikeon.com/
+Copyright (c) 2002-2009, Daniel Krech, http://eikeon.com/
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/README b/README
index 576665c5..ee63beb0 100644
--- a/README
+++ b/README
@@ -1,5 +1,5 @@
 
-See http://rdflib.net/2.4.1/ for the release notes. ...
+See http://rdflib.net/2.5.0/ for the release notes. ...
 
 Also see http://rdflib.net/contributors/ for the list of contributors.
 
diff --git a/rdflib/BNode.py b/rdflib/BNode.py
deleted file mode 100644
index feb22767..00000000
--- a/rdflib/BNode.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# TODO: where can we move _unique_id and _serial_number_generator?
-from string import ascii_letters
-from random import choice
-
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5    
-
-def _unique_id():
-    """Create a (hopefully) unique prefix"""
-    id = ""
-    for i in xrange(0,8):
-        id += choice(ascii_letters)
-    return id
-
-def _serial_number_generator():
-    i = 0
-    while 1:
-        yield i
-        i = i + 1
-
-from rdflib.Identifier import Identifier
-from rdflib.syntax.xml_names import is_ncname
-import threading
-
-bNodeLock = threading.RLock()
-
-class BNode(Identifier):
-    """
-    Blank Node: http://www.w3.org/TR/rdf-concepts/#section-blank-nodes
-
-    "In non-persistent O-O software construction, support for object
-    identity is almost accidental: in the simplest implementation,
-    each object resides at a certain address, and a reference to the
-    object uses that address, which serves as immutable object
-    identity.
-
-    ...
-
-    Maintaining object identity in shared databases raises problems:
-    every client that needs to create objects must obtain a unique
-    identity for them; " -- Bertand Meyer
-    """
-    __slots__ = ()
-
-    def __new__(cls, value=None, # only store implementations should pass in a value
-                _sn_gen=_serial_number_generator(), _prefix=_unique_id()):
-        if value==None:
-            # so that BNode values do not
-            # collide with ones created with a different instance of this module
-            # at some other time.
-            bNodeLock.acquire()
-            node_id = _sn_gen.next()
-            bNodeLock.release()
-            value = "%s%s" % (_prefix, node_id)
-        else:
-            # TODO: check that value falls within acceptable bnode value range
-            # for RDF/XML needs to be something that can be serialzed as a nodeID
-            # for N3 ??
-            # Unless we require these constraints be enforced elsewhere?
-            pass #assert is_ncname(unicode(value)), "BNode identifiers must be valid NCNames"
-
-        return Identifier.__new__(cls, value)
-
-    def n3(self):
-        return "_:%s" % self
-
-    def __getnewargs__(self):
-        return (unicode(self), )
-
-    def __reduce__(self):
-        return (BNode, (unicode(self),))
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __eq__(self, other):
-        """
-        >>> from rdflib.URIRef import URIRef
-        >>> from rdflib.BNode import BNode
-        >>> BNode("foo")==None
-        False
-        >>> BNode("foo")==URIRef("foo")
-        False
-        >>> URIRef("foo")==BNode("foo")
-        False
-        >>> BNode("foo")!=URIRef("foo")
-        True
-        >>> URIRef("foo")!=BNode("foo")
-        True
-        """
-        if isinstance(other, BNode):
-            return unicode(self)==unicode(other)
-        else:
-            return False
-
-    def __str__(self):
-        return self.encode("unicode-escape")
-
-    def __repr__(self):
-        return """rdflib.BNode('%s')""" % str(self)
-
-    def md5_term_hash(self):
-        d = md5(str(self))
-        d.update("B")
-        return d.hexdigest()
-
diff --git a/rdflib/Collection.py b/rdflib/Collection.py
index c4a739f3..16afc3ca 100644
--- a/rdflib/Collection.py
+++ b/rdflib/Collection.py
@@ -5,8 +5,6 @@ class Collection(object):
     """
     See 3.3.5 Emulating container types: http://docs.python.org/ref/sequence-types.html#l2h-232
 
-    >>> from rdflib.BNode import BNode
-    >>> from rdflib.Literal import Literal
     >>> from rdflib.Graph import Graph    
     >>> listName = BNode()
     >>> g = Graph('IOMemory')
@@ -38,8 +36,6 @@ class Collection(object):
 
     def n3(self):
         """
-        >>> from rdflib.BNode import BNode
-        >>> from rdflib.Literal import Literal
         >>> from rdflib.Graph import Graph    
         >>> listName = BNode()
         >>> g = Graph('IOMemory')
diff --git a/rdflib/Graph.py b/rdflib/Graph.py
index f0ba38ec..b3a06e73 100644
--- a/rdflib/Graph.py
+++ b/rdflib/Graph.py
@@ -7,7 +7,7 @@ Instanciating Graphs with default store (IOMemory) and default identifier (a BNo
     >>> g.store.__class__
     <class 'rdflib.store.IOMemory.IOMemory'>
     >>> g.identifier.__class__
-    <class 'rdflib.BNode.BNode'>
+    <class 'rdflib.term.BNode'>
 
 Instanciating Graphs with a specific kind of store (IOMemory) and a default identifier (a BNode):
 
@@ -22,11 +22,11 @@ Other store kinds: Sleepycat, MySQL, ZODB, SQLite
 
 Instanciating Graphs with Sleepycat store and an identifier - <http://rdflib.net>:
 
-    >>> g=Graph('Sleepycat',URIRef("http://rdflib.net"))
+    >>> g=Graph('IOMemory',URIRef("http://rdflib.net"))
     >>> g.identifier
     rdflib.URIRef('http://rdflib.net')
     >>> str(g)
-    "<http://rdflib.net> a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'Sleepycat']."
+    "<http://rdflib.net> a rdfg:Graph;rdflib:storage [a rdflib:Store;rdfs:label 'IOMemory']."
 
 Creating a ConjunctiveGraph - The top level container for all named Graphs in a 'database':
 
@@ -48,10 +48,10 @@ Adding / removing reified triples to Graph and iterating over it directly or via
     4
     >>> for s,p,o in g:  print type(s)
     ...
-    <class 'rdflib.BNode.BNode'>
-    <class 'rdflib.BNode.BNode'>
-    <class 'rdflib.BNode.BNode'>
-    <class 'rdflib.BNode.BNode'>
+    <class 'rdflib.term.BNode'>
+    <class 'rdflib.term.BNode'>
+    <class 'rdflib.term.BNode'>
+    <class 'rdflib.term.BNode'>
     
     >>> for s,p,o in g.triples((None,RDF.object,None)):  print o
     ...
@@ -151,7 +151,7 @@ from cStringIO import StringIO
 from rdflib import URIRef, BNode, Namespace, Literal, Variable
 from rdflib import RDF, RDFS
 
-from rdflib.Node import Node
+from rdflib.term import Node
 
 from rdflib import plugin, exceptions
 
diff --git a/rdflib/Identifier.py b/rdflib/Identifier.py
deleted file mode 100644
index acea6c57..00000000
--- a/rdflib/Identifier.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from rdflib.Node import Node
-
-class Identifier(Node,unicode): # we allow Identifiers to be Nodes in our Graph
-    """
-    See http://www.w3.org/2002/07/rdf-identifer-terminology/
-    regarding choice of terminology.
-    """
-    __slots__ = ()
-    def __new__(cls, value):
-        return unicode.__new__(cls,value)
diff --git a/rdflib/Namespace.py b/rdflib/Namespace.py
deleted file mode 100644
index c6ab28b8..00000000
--- a/rdflib/Namespace.py
+++ /dev/null
@@ -1,55 +0,0 @@
-from rdflib.URIRef import URIRef
-
-import logging
-
-_logger = logging.getLogger(__name__)
-
-
-class Namespace(URIRef):
-
-    def term(self, name):
-        return URIRef(self + name)
-
-    def __getitem__(self, key, default=None):
-        return self.term(key)
-
-    def __getattr__(self, name):
-        if name.startswith("__"): # ignore any special Python names!
-            raise AttributeError
-        else:
-            return self.term(name)
-
-
-class NamespaceDict(dict):
-
-    def __new__(cls, uri=None, context=None):
-        inst = dict.__new__(cls)
-        inst.uri = uri # TODO: do we need to set these both here and in __init__ ??
-        inst.__context = context
-        return inst
-
-    def __init__(self, uri, context=None):
-        self.uri = uri
-        self.__context = context
-
-    def term(self, name):
-        uri = self.get(name)
-        if uri is None:
-            uri = URIRef(self.uri + name)
-            if self.__context and (uri, None, None) not in self.__context:
-                _logger.warning("%s not defined" % uri)
-            self[name] = uri
-        return uri 
-
-    def __getattr__(self, name):
-        return self.term(name)
-
-    def __getitem__(self, key, default=None):
-        return self.term(key) or default
-
-    def __str__(self):
-        return self.uri
-
-    def __repr__(self):
-        return """rdflib.NamespaceDict('%s')""" % str(self.uri)
-
diff --git a/rdflib/Node.py b/rdflib/Node.py
deleted file mode 100644
index 690d9e7e..00000000
--- a/rdflib/Node.py
+++ /dev/null
@@ -1,5 +0,0 @@
-class Node(object):
-    """
-    A Node in the Graph.
-    """
-    __slots__ = ()
diff --git a/rdflib/RDF.py b/rdflib/RDF.py
index 881cde01..7285a7db 100644
--- a/rdflib/RDF.py
+++ b/rdflib/RDF.py
@@ -1,4 +1,4 @@
-from rdflib.Namespace import Namespace
+from rdflib.term import Namespace
 
 RDFNS = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
 
diff --git a/rdflib/RDFS.py b/rdflib/RDFS.py
index 88430082..d3555209 100644
--- a/rdflib/RDFS.py
+++ b/rdflib/RDFS.py
@@ -1,4 +1,4 @@
-from rdflib.Namespace import Namespace
+from rdflib.term import Namespace
 
 RDFSNS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
 
diff --git a/rdflib/Statement.py b/rdflib/Statement.py
deleted file mode 100644
index a71383b5..00000000
--- a/rdflib/Statement.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from rdflib.Node import Node
-
-
-class Statement(Node, tuple):
-
-    def __new__(cls, (subject, predicate, object), context):
-        return tuple.__new__(cls, ((subject, predicate, object), context))
-
-    def __reduce__(self):
-        return (Statement, (self[0], self[1]))
-
diff --git a/rdflib/TextIndex.py b/rdflib/TextIndex.py
index a20c2d0d..8e836358 100644
--- a/rdflib/TextIndex.py
+++ b/rdflib/TextIndex.py
@@ -3,11 +3,11 @@ try:
 except ImportError:
     from md5 import md5
     
-from rdflib.BNode import BNode
+from rdflib.term import BNode
 from rdflib.Graph import ConjunctiveGraph
-from rdflib.Literal import Literal
-from rdflib.Namespace import NamespaceDict as Namespace
-from rdflib.URIRef import URIRef
+from rdflib.term import Literal
+from rdflib.term import NamespaceDict as Namespace
+from rdflib.term import URIRef
 from rdflib.store import TripleAddedEvent, TripleRemovedEvent
 from rdflib.store.IOMemory import IOMemory
 import logging
diff --git a/rdflib/URIRef.py b/rdflib/URIRef.py
deleted file mode 100644
index fbc17949..00000000
--- a/rdflib/URIRef.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from sys import version_info
-
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5    
-
-if version_info[0:2] > (2, 2):
-    from unicodedata import normalize
-else:
-    normalize = None
-
-from urlparse import urlparse, urljoin, urldefrag
-
-from rdflib.Identifier import Identifier
-from rdflib.compat import rsplit
-
-
-class URIRef(Identifier):
-    """
-    RDF URI Reference: http://www.w3.org/TR/rdf-concepts/#section-Graph-URIref
-    """
-
-    __slots__ = ()
-
-    def __new__(cls, value, base=None):
-        if base is not None:
-            ends_in_hash = value.endswith("#")
-            value = urljoin(base, value, allow_fragments=1)
-            if ends_in_hash:
-                if not value.endswith("#"):
-                    value += "#"
-        #if normalize and value and value != normalize("NFC", value):
-        #    raise Error("value must be in NFC normalized form.")
-        try:
-            rt = unicode.__new__(cls,value)
-        except UnicodeDecodeError:
-            rt = unicode.__new__(cls,value,'utf-8')
-        return rt
-
-    def n3(self):
-        return "<%s>" % self
-
-    def concrete(self):
-        if "#" in self:
-            return URIRef("/".join(rsplit(self, "#", 1)))
-        else:
-            return self
-
-    def abstract(self):
-        if "#" not in self:
-            scheme, netloc, path, params, query, fragment = urlparse(self)
-            if path:
-                return URIRef("#".join(rsplit(self, "/", 1)))
-            else:
-                if not self.endswith("#"):
-                    return URIRef("%s#" % self)
-                else:
-                    return self
-        else:
-            return self
-
-
-    def defrag(self):
-        if "#" in self:
-            url, frag = urldefrag(self)
-            return URIRef(url)
-        else:
-            return self
-
-    def __reduce__(self):
-        return (URIRef, (unicode(self),))
-
-    def __getnewargs__(self):
-        return (unicode(self), )
-
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __eq__(self, other):
-        if isinstance(other, URIRef):
-            return unicode(self)==unicode(other)
-        else:
-            return False
-
-    def __str__(self):
-        return self.encode("unicode-escape")
-
-    def __repr__(self):
-        return """rdflib.URIRef('%s')""" % str(self)
-
-    def md5_term_hash(self):
-        d = md5(str(self))
-        d.update("U")
-        return d.hexdigest()
diff --git a/rdflib/Variable.py b/rdflib/Variable.py
deleted file mode 100644
index e417a363..00000000
--- a/rdflib/Variable.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from rdflib.Identifier import Identifier
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5    
-
-class Variable(Identifier):
-    """
-    """
-    __slots__ = ()
-    def __new__(cls, value):
-        if value[0]=='?':
-            value=value[1:]
-        return unicode.__new__(cls, value)
-
-    def __repr__(self):
-        return self.n3()
-
-    def n3(self):
-        return "?%s" % self
-
-    def __reduce__(self):
-        return (Variable, (unicode(self),))
-
-    def md5_term_hash(self):
-        d = md5(str(self))
-        d.update("V")
-        return d.hexdigest()
\ No newline at end of file
diff --git a/rdflib/__init__.py b/rdflib/__init__.py
index af2c219a..35dc29d9 100644
--- a/rdflib/__init__.py
+++ b/rdflib/__init__.py
@@ -1,6 +1,6 @@
 # RDF Library
 
-__version__ = "2.4.1"
+__version__ = "2.5.0"
 __date__ = "not/yet/released"
 
 import sys
@@ -12,20 +12,19 @@ import logging
 _logger = logging.getLogger("rdflib")
 _logger.info("version: %s" % __version__)
 
-from rdflib.URIRef import URIRef
-from rdflib.BNode import BNode
-from rdflib.Literal import Literal
-from rdflib.Variable import Variable
-
-from rdflib.Namespace import Namespace
+from rdflib.term import URIRef
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import Variable
+from rdflib.term import Namespace
 
 # from rdflib.Graph import Graph # perhaps in 3.0, but for 2.x we
 # don't want to break compatibility.
 from rdflib.Graph import BackwardCompatGraph as Graph
 from rdflib.Graph import ConjunctiveGraph
 
-from rdflib import RDF
-from rdflib import RDFS
+#from rdflib import RDF
+#from rdflib import RDFS
 
 from rdflib.FileInputSource import FileInputSource
 from rdflib.URLInputSource import URLInputSource
diff --git a/rdflib/sparql/Query.py b/rdflib/sparql/Query.py
index d8ab8617..28d843fd 100644
--- a/rdflib/sparql/Query.py
+++ b/rdflib/sparql/Query.py
@@ -2,7 +2,7 @@ import types, sets
 from pprint import pprint
 from rdflib import URIRef, BNode, Literal, Variable, RDF
 from rdflib.Graph import Graph, ConjunctiveGraph, ReadOnlyGraphAggregate
-from rdflib.Identifier import Identifier
+from rdflib.term import Identifier
 from rdflib.util import check_subject, list2set
 from rdflib.sparql import SPARQLError
 from rdflib.sparql.sparqlGraph import SPARQLGraph
diff --git a/rdflib/sparql/bison/QName.py b/rdflib/sparql/bison/QName.py
index 1162b45c..e0dc9f3c 100644
--- a/rdflib/sparql/bison/QName.py
+++ b/rdflib/sparql/bison/QName.py
@@ -1,5 +1,5 @@
-from rdflib import URIRef
-from rdflib.Identifier import Identifier
+from rdflib.term import URIRef
+from rdflib.term import Identifier
 
 class QName(Identifier):
     __slots__ = ("localname", "prefix")
@@ -15,4 +15,4 @@ class QName(Identifier):
 class QNamePrefix(Identifier):
     def __init__(self,prefix):
         super(QNamePrefix,self).__init__(prefix)
-        
\ No newline at end of file
+        
diff --git a/rdflib/sparql/bison/SPARQLEvaluate.py b/rdflib/sparql/bison/SPARQLEvaluate.py
index 10ae99fe..861c4d65 100644
--- a/rdflib/sparql/bison/SPARQLEvaluate.py
+++ b/rdflib/sparql/bison/SPARQLEvaluate.py
@@ -8,8 +8,8 @@ from rdflib.sparql.Query import _variablesToArray, queryObject, SessionBNode
 from rdflib.Graph import ConjunctiveGraph, Graph, BackwardCompatGraph,ReadOnlyGraphAggregate
 from rdflib import URIRef,Variable,BNode, Literal, plugin, RDF
 from rdflib.store import Store
-from rdflib.Identifier import Identifier
-from rdflib.Literal import XSDToPython
+from rdflib.term import Identifier
+from rdflib.term import XSDToPython
 from IRIRef import NamedGraph,RemoteGraph
 from GraphPattern import *
 from Resource import *
diff --git a/rdflib/sparql/graphPattern.py b/rdflib/sparql/graphPattern.py
index fcba24ca..065e72df 100755
--- a/rdflib/sparql/graphPattern.py
+++ b/rdflib/sparql/graphPattern.py
@@ -7,10 +7,10 @@
 Graph pattern class used by the SPARQL implementation
 """
 import sys, os, time, datetime
-from rdflib.Literal     import Literal
-from rdflib.BNode       import BNode
-from rdflib.URIRef      import URIRef
-from rdflib import Variable
+from rdflib.term     import Literal
+from rdflib.term       import BNode
+from rdflib.term      import URIRef
+from rdflib.term import Variable
 from types import *
 from rdflib.syntax.NamespaceManager import NamespaceManager
 from rdflib.Graph import Graph
diff --git a/rdflib/sparql/parser.py b/rdflib/sparql/parser.py
index c21c0137..dab2bda0 100644
--- a/rdflib/sparql/parser.py
+++ b/rdflib/sparql/parser.py
@@ -31,7 +31,7 @@ USAGE:
 
 import base64
 import re
-from rdflib.URIRef import URIRef
+from rdflib.term import URIRef
 from rdflib.sparql.graphPattern import GraphPattern
 
 def _escape(text): return base64.encodestring(text).replace("\n", "")
diff --git a/rdflib/sparql/sparqlOperators.py b/rdflib/sparql/sparqlOperators.py
index efa6eee8..cc645fb5 100755
--- a/rdflib/sparql/sparqlOperators.py
+++ b/rdflib/sparql/sparqlOperators.py
@@ -26,10 +26,10 @@
 ##
 
 import sys, os, re
-from rdflib.Literal     import Literal, _XSD_NS
-from rdflib.BNode       import BNode
-from rdflib.URIRef      import URIRef
-from rdflib             import Variable
+from rdflib.term     import Literal, _XSD_NS
+from rdflib.term       import BNode
+from rdflib.term      import URIRef
+from rdflib.term             import Variable
 from rdflib.sparql.graphPattern import _createResource
 from rdflib.sparql import _questChar, Debug
 
diff --git a/rdflib/store/FOPLRelationalModel/QuadSlot.py b/rdflib/store/FOPLRelationalModel/QuadSlot.py
index 07476a5a..27dae7db 100644
--- a/rdflib/store/FOPLRelationalModel/QuadSlot.py
+++ b/rdflib/store/FOPLRelationalModel/QuadSlot.py
@@ -4,10 +4,10 @@ Utility functions associated with RDF terms:
 - normalizing (to 64 bit integers via half-md5-hashes)
 - escaping literal's for SQL persistence
 """
-from rdflib.BNode import BNode
+from rdflib.term import BNode
 from rdflib import RDF
-from rdflib.Literal import Literal
-from rdflib.URIRef import URIRef
+from rdflib.term import Literal
+from rdflib.term import URIRef
 import md5
 from rdflib.term_utils import *
 from rdflib.Graph import QuotedGraph
@@ -96,4 +96,4 @@ class QuadSlot:
         elif self.term is None or isinstance(self.term,(list,REGEXTerm)):
             return self.term
         else:
-            return self.term.encode('utf-8')
\ No newline at end of file
+            return self.term.encode('utf-8')
diff --git a/rdflib/store/IOMemory.py b/rdflib/store/IOMemory.py
index 442f1bab..4cb41ea5 100644
--- a/rdflib/store/IOMemory.py
+++ b/rdflib/store/IOMemory.py
@@ -3,7 +3,7 @@ from __future__ import generators
 
 Any = None
 
-from rdflib.BNode import BNode
+from rdflib.term import BNode
 from rdflib.store import Store
 
 class IOMemory(Store):
diff --git a/rdflib/store/Sleepycat.py b/rdflib/store/Sleepycat.py
index 4eb5d3ed..e5819df9 100644
--- a/rdflib/store/Sleepycat.py
+++ b/rdflib/store/Sleepycat.py
@@ -1,5 +1,5 @@
 from rdflib.store import Store, VALID_STORE, CORRUPTED_STORE, NO_STORE, UNKNOWN
-from rdflib.URIRef import URIRef
+from rdflib.term import URIRef
 
 from bsddb import db
 
diff --git a/rdflib/store/__init__.py b/rdflib/store/__init__.py
index 682184de..09c55426 100644
--- a/rdflib/store/__init__.py
+++ b/rdflib/store/__init__.py
@@ -74,12 +74,12 @@ class Store(object):
     def __get_node_pickler(self):
         if self.__node_pickler is None:
             from rdflib.store.NodePickler import NodePickler
-            from rdflib.URIRef import URIRef
-            from rdflib.BNode import BNode
-            from rdflib.Literal import Literal
+            from rdflib.term import URIRef
+            from rdflib.term import BNode
+            from rdflib.term import Literal
             from rdflib.Graph import Graph, QuotedGraph, GraphValue
-            from rdflib.Variable import Variable
-            from rdflib.Statement import Statement
+            from rdflib.term import Variable
+            from rdflib.term import Statement
             self.__node_pickler = np = NodePickler()
             np.register(self, "S")
             np.register(URIRef, "U")
diff --git a/rdflib/syntax/parsers/RDFaParser.py b/rdflib/syntax/parsers/RDFaParser.py
index c941f669..17254e14 100644
--- a/rdflib/syntax/parsers/RDFaParser.py
+++ b/rdflib/syntax/parsers/RDFaParser.py
@@ -37,10 +37,10 @@ import sys, re, urllib, urlparse, cStringIO, string
 from xml.dom import pulldom
 from rdflib.syntax.parsers import Parser
 from rdflib.Graph import ConjunctiveGraph
-from rdflib.URIRef import URIRef
-from rdflib.BNode import BNode
-from rdflib.Literal import Literal
-from rdflib.Namespace import Namespace
+from rdflib.term import URIRef
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import Namespace
 
 __version__ = "$Id$"
 
diff --git a/rdflib/syntax/parsers/TriXHandler.py b/rdflib/syntax/parsers/TriXHandler.py
index 3d5f74b5..bcb70049 100644
--- a/rdflib/syntax/parsers/TriXHandler.py
+++ b/rdflib/syntax/parsers/TriXHandler.py
@@ -42,7 +42,7 @@ from urlparse import urljoin, urldefrag
 
 RDFNS = RDF.RDFNS
 
-TRIXNS=Namespace.Namespace("http://www.w3.org/2004/03/trix/trix-1/")
+TRIXNS=Namespace("http://www.w3.org/2004/03/trix/trix-1/")
 
 
 class TriXHandler(handler.ContentHandler):
diff --git a/rdflib/syntax/serializers/RecursiveSerializer.py b/rdflib/syntax/serializers/RecursiveSerializer.py
index 367f5791..c316ea03 100644
--- a/rdflib/syntax/serializers/RecursiveSerializer.py
+++ b/rdflib/syntax/serializers/RecursiveSerializer.py
@@ -1,6 +1,6 @@
-from rdflib.BNode import BNode
-from rdflib.Literal import Literal
-from rdflib.URIRef import URIRef
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import URIRef
 
 from rdflib.syntax.serializers.AbstractSerializer import AbstractSerializer
 
diff --git a/rdflib/syntax/serializers/TurtleSerializer.py b/rdflib/syntax/serializers/TurtleSerializer.py
index 47fa39ea..5c45d004 100644
--- a/rdflib/syntax/serializers/TurtleSerializer.py
+++ b/rdflib/syntax/serializers/TurtleSerializer.py
@@ -1,9 +1,9 @@
 import urlparse
 from xml.sax.saxutils import escape, quoteattr
 
-from rdflib.BNode import BNode
-from rdflib.Literal import Literal
-from rdflib.URIRef import URIRef
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import URIRef
 from rdflib.syntax.xml_names import split_uri 
 
 from rdflib.syntax.serializers.RecursiveSerializer import RecursiveSerializer
diff --git a/rdflib/syntax/serializers/XMLSerializer.py b/rdflib/syntax/serializers/XMLSerializer.py
index 1c81c3b3..b651caf3 100644
--- a/rdflib/syntax/serializers/XMLSerializer.py
+++ b/rdflib/syntax/serializers/XMLSerializer.py
@@ -2,9 +2,9 @@ from __future__ import generators
 
 from rdflib.syntax.serializers import Serializer
 
-from rdflib.URIRef import URIRef
-from rdflib.Literal import Literal
-from rdflib.BNode import BNode
+from rdflib.term import URIRef
+from rdflib.term import Literal
+from rdflib.term import BNode
 
 from rdflib.util import uniq
 from rdflib.exceptions import Error
diff --git a/rdflib/Literal.py b/rdflib/term.py
index 6e3deb80..5ec7f429 100644
--- a/rdflib/Literal.py
+++ b/rdflib/term.py
@@ -1,6 +1,238 @@
-from rdflib.Identifier import Identifier
-from rdflib.URIRef import URIRef
-from rdflib.Namespace import Namespace
+"""
+This module defines the different types of terms...
+
+"""
+
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class Node(object):
+    """
+    A Node in the Graph.
+    """
+
+    __slots__ = ()
+
+
+class Identifier(Node, unicode): # we allow Identifiers to be Nodes in our Graph
+    """
+    See http://www.w3.org/2002/07/rdf-identifer-terminology/
+    regarding choice of terminology.
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, value):
+        return unicode.__new__(cls,value)
+
+
+from sys import version_info
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import md5    
+
+if version_info[0:2] > (2, 2):
+    from unicodedata import normalize
+else:
+    normalize = None
+
+from urlparse import urlparse, urljoin, urldefrag
+
+from rdflib.compat import rsplit
+
+
+class URIRef(Identifier):
+    """
+    RDF URI Reference: http://www.w3.org/TR/rdf-concepts/#section-Graph-URIref
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, value, base=None):
+        if base is not None:
+            ends_in_hash = value.endswith("#")
+            value = urljoin(base, value, allow_fragments=1)
+            if ends_in_hash:
+                if not value.endswith("#"):
+                    value += "#"
+        #if normalize and value and value != normalize("NFC", value):
+        #    raise Error("value must be in NFC normalized form.")
+        try:
+            rt = unicode.__new__(cls,value)
+        except UnicodeDecodeError:
+            rt = unicode.__new__(cls,value,'utf-8')
+        return rt
+
+    def n3(self):
+        return "<%s>" % self
+
+    def concrete(self):
+        if "#" in self:
+            return URIRef("/".join(rsplit(self, "#", 1)))
+        else:
+            return self
+
+    def abstract(self):
+        if "#" not in self:
+            scheme, netloc, path, params, query, fragment = urlparse(self)
+            if path:
+                return URIRef("#".join(rsplit(self, "/", 1)))
+            else:
+                if not self.endswith("#"):
+                    return URIRef("%s#" % self)
+                else:
+                    return self
+        else:
+            return self
+
+
+    def defrag(self):
+        if "#" in self:
+            url, frag = urldefrag(self)
+            return URIRef(url)
+        else:
+            return self
+
+    def __reduce__(self):
+        return (URIRef, (unicode(self),))
+
+    def __getnewargs__(self):
+        return (unicode(self), )
+
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __eq__(self, other):
+        if isinstance(other, URIRef):
+            return unicode(self)==unicode(other)
+        else:
+            return False
+
+    def __str__(self):
+        return self.encode("unicode-escape")
+
+    def __repr__(self):
+        return """rdflib.URIRef('%s')""" % str(self)
+
+    def md5_term_hash(self):
+        d = md5(str(self))
+        d.update("U")
+        return d.hexdigest()
+
+
+
+# TODO: where can we move _unique_id and _serial_number_generator?
+from string import ascii_letters
+from random import choice
+
+try:
+    from hashlib import md5
+except ImportError:
+    from md5 import md5    
+
+def _unique_id():
+    """Create a (hopefully) unique prefix"""
+    id = ""
+    for i in xrange(0,8):
+        id += choice(ascii_letters)
+    return id
+
+def _serial_number_generator():
+    i = 0
+    while 1:
+        yield i
+        i = i + 1
+
+from rdflib.syntax.xml_names import is_ncname
+import threading
+
+bNodeLock = threading.RLock()
+
+class BNode(Identifier):
+    """
+    Blank Node: http://www.w3.org/TR/rdf-concepts/#section-blank-nodes
+
+    "In non-persistent O-O software construction, support for object
+    identity is almost accidental: in the simplest implementation,
+    each object resides at a certain address, and a reference to the
+    object uses that address, which serves as immutable object
+    identity.
+
+    ...
+
+    Maintaining object identity in shared databases raises problems:
+    every client that needs to create objects must obtain a unique
+    identity for them; " -- Bertand Meyer
+    """
+    __slots__ = ()
+
+    def __new__(cls, value=None, # only store implementations should pass in a value
+                _sn_gen=_serial_number_generator(), _prefix=_unique_id()):
+        if value==None:
+            # so that BNode values do not
+            # collide with ones created with a different instance of this module
+            # at some other time.
+            bNodeLock.acquire()
+            node_id = _sn_gen.next()
+            bNodeLock.release()
+            value = "%s%s" % (_prefix, node_id)
+        else:
+            # TODO: check that value falls within acceptable bnode value range
+            # for RDF/XML needs to be something that can be serialzed as a nodeID
+            # for N3 ??
+            # Unless we require these constraints be enforced elsewhere?
+            pass #assert is_ncname(unicode(value)), "BNode identifiers must be valid NCNames"
+
+        return Identifier.__new__(cls, value)
+
+    def n3(self):
+        return "_:%s" % self
+
+    def __getnewargs__(self):
+        return (unicode(self), )
+
+    def __reduce__(self):
+        return (BNode, (unicode(self),))
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __eq__(self, other):
+        """
+        >>> BNode("foo")==None
+        False
+        >>> BNode("foo")==URIRef("foo")
+        False
+        >>> URIRef("foo")==BNode("foo")
+        False
+        >>> BNode("foo")!=URIRef("foo")
+        True
+        >>> URIRef("foo")!=BNode("foo")
+        True
+        """
+        if isinstance(other, BNode):
+            return unicode(self)==unicode(other)
+        else:
+            return False
+
+    def __str__(self):
+        return self.encode("unicode-escape")
+
+    def __repr__(self):
+        return """rdflib.BNode('%s')""" % str(self)
+
+    def md5_term_hash(self):
+        d = md5(str(self))
+        d.update("B")
+        return d.hexdigest()
+
+
+
 from rdflib.exceptions import Error
 from datetime import date,time,datetime
 from time import strptime
@@ -11,9 +243,22 @@ try:
 except ImportError:
     from md5 import md5    
 
-import logging
 
-_logger = logging.getLogger(__name__)
+
+class Namespace(URIRef):
+
+    def term(self, name):
+        return URIRef(self + name)
+
+    def __getitem__(self, key, default=None):
+        return self.term(key)
+
+    def __getattr__(self, name):
+        if name.startswith("__"): # ignore any special Python names!
+            raise AttributeError
+        else:
+            return self.term(name)
+
 
 class Literal(Identifier):
     """
@@ -403,9 +648,78 @@ def bind(datatype, conversion_function):
 
 
 
+class Variable(Identifier):
+    """
+    """
+    __slots__ = ()
+    def __new__(cls, value):
+        if value[0]=='?':
+            value=value[1:]
+        return unicode.__new__(cls, value)
+
+    def __repr__(self):
+        return self.n3()
+
+    def n3(self):
+        return "?%s" % self
+
+    def __reduce__(self):
+        return (Variable, (unicode(self),))
+
+    def md5_term_hash(self):
+        d = md5(str(self))
+        d.update("V")
+        return d.hexdigest()
+
+
+class Statement(Node, tuple):
+
+    def __new__(cls, (subject, predicate, object), context):
+        return tuple.__new__(cls, ((subject, predicate, object), context))
+
+    def __reduce__(self):
+        return (Statement, (self[0], self[1]))
+
+
+class NamespaceDict(dict):
+
+    def __new__(cls, uri=None, context=None):
+        inst = dict.__new__(cls)
+        inst.uri = uri # TODO: do we need to set these both here and in __init__ ??
+        inst.__context = context
+        return inst
+
+    def __init__(self, uri, context=None):
+        self.uri = uri
+        self.__context = context
+
+    def term(self, name):
+        uri = self.get(name)
+        if uri is None:
+            uri = URIRef(self.uri + name)
+            if self.__context and (uri, None, None) not in self.__context:
+                _logger.warning("%s not defined" % uri)
+            self[name] = uri
+        return uri 
+
+    def __getattr__(self, name):
+        return self.term(name)
+
+    def __getitem__(self, key, default=None):
+        return self.term(key) or default
+
+    def __str__(self):
+        return self.uri
+
+    def __repr__(self):
+        return """rdflib.NamespaceDict('%s')""" % str(self.uri)
+
+
 def test():
     import doctest
     doctest.testmod()
 
 if __name__ == '__main__':
     test()
+
+
diff --git a/rdflib/util.py b/rdflib/util.py
index 6129c327..b19348f4 100644
--- a/rdflib/util.py
+++ b/rdflib/util.py
@@ -1,9 +1,9 @@
-from rdflib.URIRef import URIRef
-from rdflib.BNode import BNode
-from rdflib.Literal import Literal
-from rdflib.Variable import Variable
+from rdflib.term import URIRef
+from rdflib.term import BNode
+from rdflib.term import Literal
+from rdflib.term import Variable
+from rdflib.term import Statement
 from rdflib.Graph import Graph, QuotedGraph
-from rdflib.Statement import Statement
 
 from rdflib.exceptions import SubjectTypeError, PredicateTypeError, ObjectTypeError, ContextTypeError
 from rdflib.compat import rsplit
diff --git a/rdflib_tools/EARLPlugin.py b/rdflib_tools/EARLPlugin.py
index 1cd884d2..23b709bf 100644
--- a/rdflib_tools/EARLPlugin.py
+++ b/rdflib_tools/EARLPlugin.py
@@ -12,10 +12,10 @@ import sys
 from nose.plugins import Plugin
 from nose.suite import TestModule
 
-from rdflib import URIRef, BNode, Literal
+from rdflib.term import URIRef, BNode, Literal
 from rdflib import RDF, RDFS
 from rdflib.Graph import Graph
-from rdflib.Namespace import NamespaceDict as Namespace
+from rdflib.term import NamespaceDict as Namespace
 from rdflib.util import date_time
 
 log = logging.getLogger(__name__)
diff --git a/test/Sleepycat.py b/test/Sleepycat.py
index 0310f80b..6092c42f 100644
--- a/test/Sleepycat.py
+++ b/test/Sleepycat.py
@@ -1,3 +1,7 @@
+import logging
+
+_logger = logging.getLogger(__name__)
+
 from test.graph import GraphTestCase
 
 try:
diff --git a/test/advanced_sparql_constructs.py b/test/advanced_sparql_constructs.py
index a00b9aee..44a2a779 100644
--- a/test/advanced_sparql_constructs.py
+++ b/test/advanced_sparql_constructs.py
@@ -1,5 +1,5 @@
 import unittest
-from rdflib.Namespace import Namespace
+from rdflib.term import Namespace
 from rdflib import plugin,RDF,RDFS,URIRef
 from rdflib.store import Store
 from cStringIO import StringIO
@@ -81,4 +81,4 @@ class AdvancedTests(unittest.TestCase):
 
 if __name__ == '__main__':
     suite = unittest.makeSuite(AdvancedTests)
-    unittest.TextTestRunner(verbosity=3).run(suite)
\ No newline at end of file
+    unittest.TextTestRunner(verbosity=3).run(suite)
diff --git a/test/aggregate_graphs.py b/test/aggregate_graphs.py
index 823d352a..8fb5a27d 100644
--- a/test/aggregate_graphs.py
+++ b/test/aggregate_graphs.py
@@ -1,6 +1,6 @@
 import sys
 import unittest
-from rdflib.Namespace import Namespace
+from rdflib.term import Namespace
 from rdflib import plugin,RDF,RDFS,URIRef
 from rdflib.store import Store
 from cStringIO import StringIO
diff --git a/test/graph.py b/test/graph.py
index 636c0f65..f05ed1c4 100644
--- a/test/graph.py
+++ b/test/graph.py
@@ -2,7 +2,8 @@ import unittest
 
 from tempfile import mkdtemp
 
-from rdflib import URIRef, BNode, Literal, RDF
+from rdflib.term import URIRef, BNode, Literal
+from rdflib import RDF
 from rdflib.Graph import Graph
 
 class GraphTestCase(unittest.TestCase):
@@ -123,7 +124,7 @@ class GraphTestCase(unittest.TestCase):
     def testStatementNode(self):
         graph = self.graph
 
-        from rdflib.Statement import Statement
+        from rdflib.term import Statement
         c = URIRef("http://example.org/foo#c")
         r = URIRef("http://example.org/foo#r")
         s = Statement((self.michel, self.likes, self.pizza), c)
diff --git a/test/parser_rdfcore.py b/test/parser_rdfcore.py
index 26c789db..4d524e2c 100644
--- a/test/parser_rdfcore.py
+++ b/test/parser_rdfcore.py
@@ -1,7 +1,7 @@
 import unittest
 
 from rdflib import URIRef, BNode, Literal, RDF, RDFS
-from rdflib.Namespace import Namespace
+from rdflib.term import Namespace
 from rdflib.exceptions import ParserError
 
 from rdflib.Graph import Graph
diff --git a/test/test_datatype_parsing.py b/test/test_datatype_parsing.py
index 17cd5122..923ddb71 100644
--- a/test/test_datatype_parsing.py
+++ b/test/test_datatype_parsing.py
@@ -1,8 +1,8 @@
 # -*- coding: UTF-8 -*-
 import unittest
 from pprint import pprint
-from rdflib import ConjunctiveGraph, URIRef, Literal, RDFS, Namespace
-from rdflib.Literal import _XSD_NS
+from rdflib import ConjunctiveGraph, RDFS
+from rdflib.term import URIRef, Literal, Namespace, _XSD_NS
 from StringIO import StringIO
 from sets import Set
 
@@ -27,4 +27,4 @@ class TestSparqlOPT_FILTER(unittest.TestCase):
                 "Expecting %r, got instead : %r"%(double1,xd3Objs[0]))
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/test/test_issue_45.py b/test/test_issue_45.py
index 65ab3b7e..6ffde2ec 100644
--- a/test/test_issue_45.py
+++ b/test/test_issue_45.py
@@ -1,7 +1,7 @@
 import unittest
 
 from rdflib.Graph import ConjunctiveGraph as Graph
-from rdflib.Namespace import Namespace as NS
+from rdflib.term import Namespace as NS
 
 from rdflib.sparql import Algebra
 
diff --git a/test/test_not_equals.py b/test/test_not_equals.py
index dae60815..a279ec27 100644
--- a/test/test_not_equals.py
+++ b/test/test_not_equals.py
@@ -1,6 +1,7 @@
-from rdflib.Namespace import Namespace
-from rdflib import plugin,RDF,RDFS,URIRef, StringInputSource, Literal
-from rdflib.Graph import Graph,ReadOnlyGraphAggregate,ConjunctiveGraph
+from rdflib.term import URIRef, Literal, Namespace
+from rdflib import plugin, RDF, RDFS, StringInputSource
+from rdflib.RDF import RDFNS
+from rdflib.Graph import Graph, ReadOnlyGraphAggregate,ConjunctiveGraph
 
 import sys
 from pprint import pprint
diff --git a/test/test_sparql_told_bnodes.py b/test/test_sparql_told_bnodes.py
index a2828204..5b1935d6 100644
--- a/test/test_sparql_told_bnodes.py
+++ b/test/test_sparql_told_bnodes.py
@@ -1,5 +1,5 @@
-from rdflib.Namespace import Namespace
-from rdflib import plugin,RDF,RDFS,URIRef, StringInputSource, Literal, BNode, Variable
+from rdflib.term import URIRef, BNode, Literal, Namespace, Variable
+from rdflib import plugin, RDF, RDFS, StringInputSource
 from rdflib.Graph import Graph,ReadOnlyGraphAggregate,ConjunctiveGraph
 import unittest,sys
 from pprint import pprint
diff --git a/test/type_check.py b/test/type_check.py
index 4f330fab..15fdeb53 100644
--- a/test/type_check.py
+++ b/test/type_check.py
@@ -4,7 +4,7 @@ from rdflib.Graph import Graph
 from rdflib.exceptions import SubjectTypeError
 from rdflib.exceptions import PredicateTypeError
 from rdflib.exceptions import ObjectTypeError
-from rdflib.URIRef import URIRef
+from rdflib.term import URIRef
 
 foo = URIRef("foo")