@@ -49,7 +49,7 @@ import sys, os

 # If extensions (or modules to document with autodoc) are in another directory,

 # add these directories to sys.path here. If the directory is relative to the

 # documentation root, use os.path.abspath to make it absolute, like shown here.

-sys.path.insert(0, os.path.abspath('../../..'))

+sys.path.insert(0, os.path.abspath('../..'))

 # -- General configuration -----------------------------------------------------

@@ -1,4 +1,4 @@

-from . import proxy

+from jsonrpc import proxy

 import optparse

 def main(host, path=None):

@@ -32,11 +32,14 @@

 #

 from twisted.internet import reactor, ssl

 from twisted.web import server

+import traceback

-from .server import ServerEvents, JSON_RPC

+from jsonrpc.server import ServerEvents, JSON_RPC

 class JSONRPCTest(ServerEvents):

-	def log(self, *a): print a

+	def log(self, *a):

+		print a

+

 	def findmethod(self, method):

 		if method in set(['add', 'subtract']):

 			return getattr(self, method)

@@ -32,12 +32,8 @@

 #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #

 #

-import cgi

-import copy

-import time

-import itertools

 import jsonrpc.jsonutil

-import json

+from jsonrpc.utilities import public

 # Twisted imports

 from twisted.web import server

@@ -48,19 +44,20 @@ from twisted.web.resource import Resource

 import UserDict, collections

 collections.Mapping.register(UserDict.DictMixin)

+@public

 class ServerEvents(object):

 	'''Subclass this and pass to :py:meth:`jsonrpc.customize` to customize the jsonrpc server'''

-	def __init__(self, jsonrpc):

+	def __init__(self, server):

 		#: A link to the JSON-RPC server instance

-		self.server = jsonrpc

+		self.server = server

-	def callmethod(self, request, method, kwargs, args, **kw):

+	def callmethod(self, txrequest, rpcrequest):

 		'''Finds the method and calls it with the specified args'''

-		method = self.findmethod(method)

+		method = self.findmethod(rpcrequest.method)

 		if method is None: raise MethodNotFound

-		return method(*args, **kwargs)

+		return method(*rpcrequest.args, **rpcrequest.kwargs)

 	def findmethod(self, method):

 		'''Override to allow server to define methods'''

@@ -79,29 +76,90 @@ class ServerEvents(object):

 		return content

+@public

 class ServerError(Exception):

+	'''Base Exception for JSON-RPC Errors, if this or a subclass of this is raised by a JSON-RPC method,

+	The server will convert it into an appropriate error object

+	'''

+

+	#: Error code

 	code = 0

+	#: Error message

 	msg = ""

-	id = None

 	def json_equivalent(self):

-		return dict(jsonrpc="2.0", error=dict(code=self.code, message=self.msg), id=self.id)

+		'''return a dictionary which matches an JSON-RPC Response'''

+		return dict(code=self.code, message=self.msg)

+

 	def __str__(self):

 		return jsonrpc.jsonutil.encode(self)

+@public

 class InvalidRequest(ServerError):

+	'''Raise this when the Request object does not match the schema'''

 	code = -32600

 	msg = "Invalid Request."

+@public

 class MethodNotFound(ServerError):

+	'''Raise this when the desired method is not found'''

 	code = -32601

 	msg = "Procedure not found."

+@public

 class ParseError(ServerError):

+	'''Raise this when the request contains invalid JSON'''

 	code = -32700

 	msg = "Parse error."

+class Request(object):

+	def __init__(self, content):

+		self.version = content.get('jsonrpc')

+		self.id = content.get('id')

+

+		self.method = content.get('method')

+

+		kwargs = content.get('params', {})

+		args = ()

+		if not isinstance(kwargs, dict):

+			args = tuple(kwargs)

+			kwargs = {}

+		else:

+			args = kwargs.pop('__args', args)

+

+		self.args = args

+		self.kwargs = dict( (str(k), v) for k,v in kwargs.items() )

+

+	def check(self):

+		if self.version != '2.0': raise InvalidRequest

+		if not isinstance(self.method, (str, unicode)): raise InvalidRequest

+

+	@classmethod

+	def from_list(cls, content):

+		result = []

+		for req in content:

+			result.append(cls(req))

+		return result

+

+

+class Response(object):

+	def __init__(self, id=None, result=None, error=None):

+		self.version = '2.0'

+		self.id = id

+		self.result = result

+		self.error = error

+

+	def json_equivalent(self):

+		res = dict(jsonrpc=self.version, id=self.id)

+		if self.error is None:

+			res['result'] = self.result

+		else:

+			res['error'] = self.error

+		return res

+

+

 ## Base class providing a JSON-RPC 2.0 implementation with 2 customizable hooks

+@public

 class JSON_RPC(Resource):

 	'''This class implements a JSON-RPC 2.0 server as a Twisted Resource'''

 	isLeaf = True

@@ -133,14 +191,58 @@ class JSON_RPC(Resource):

 			content = self.eventhandler.processcontent(content, request)

+			if isinstance(content, list):

+				content = Request.from_list(content)

+			else:

+				content = Request(content)

+

+			try:

+				if hasattr(content, 'check'):

+					content.check()

+				else:

+					for item in content: item.check()

+

+			except ServerError, e:

+				self._ebRender(e, request, content.id if hasattr(content, 'id') else None)

+

 			d = threads.deferToThread(self._action, request, content)

 			d.addCallback(self._cbRender, request)

-			d.addErrback(self._ebRender, request, content.get('id') if hasattr(content, 'get') else None)

+			d.addErrback(self._ebRender, request, content.id if hasattr(content, 'id') else None)

 		except BaseException, e:

 			self._ebRender(e, request, None)

 		return server.NOT_DONE_YET

+	def _action(self, request, contents):

+		result = []

+

+		islist = (True if isinstance(contents, list) else False)

+		if not islist: contents = [contents]

+

+		if contents == []: raise InvalidRequest

+

+		for rpcrequest in contents:

+			res = None

+

+			try:

+				res = Response(id=rpcrequest.id, result=self.eventhandler.callmethod(request, rpcrequest))

+				res = self.eventhandler.processrequest(res, request.args)

+			except Exception, e:

+				res = self.render_error(e, rpcrequest.id)

+

+			if res.id is not None:

+				result.append(res)

+

+

+		self.eventhandler.log(result, request)

+

+		if result != []:

+			if not islist: result = result[0]

+		else: result = None

+

+		return result

+

+

 	def _cbRender(self, result, request):

 		if result is not None:

@@ -169,69 +271,15 @@ class JSON_RPC(Resource):

 		request.write(result)

 		if finish: request.finish()

-	def _parse_data(self, content):

-		if content.get('jsonrpc') != '2.0': raise InvalidRequest

-

-		method = content.get('method')

-		if not isinstance(method, (str, unicode)): raise InvalidRequest

-

-		kwargs = content.get('params', {})

-		args = ()

-		if not isinstance(kwargs, dict):

-			args = tuple(kwargs)

-			kwargs = {}

-		else:

-			args = kwargs.pop('__args', args)

-		kwargs = dict( (str(k), v) for k,v in kwargs.items() )

-

-		return method, kwargs, args

-

-

 	def render_error(self, e, id):

 		if isinstance(e, ServerError):

-			e.id = id

-			err = e.json_equivalent()

+			err = Response(id=id, error=e)

 		else:

-			err = dict(

-				jsonrpc='2.0',

-				id = id,

-				error= dict(

-					code=0,

-					message=str(e),

-					data = e.args

-			))

+			err = Response(id=id, error=dict(code=0, message=str(e), data=e.args))

 		return err

-	def _action(self, request, contents):

-		result = []

-		ol = (True if isinstance(contents, list) else False)

-		if not ol: contents = [contents]

-

-		if contents == []: raise InvalidRequest

-

-		for content in contents:

-			try:

-				res = dict(jsonrpc='2.0', id=content.get('id'), result=self.eventhandler.callmethod(request, *self._parse_data(content)))

-

-				res = self.eventhandler.processrequest(res, request.args)

-

-				if res['id'] is not None: result.append(res)

-			except Exception, e:

-				err = self.render_error(e, content.get('id'))

-				if err['id'] is not None: result.append(err)

-

-

-

-		self.eventhandler.log(result, request)

-

-		if result != []:

-			if not ol: result = result[0]

-		else: result = None

-

-		return result

-

@@ -40,7 +40,7 @@ class testobj(object):

 	value = 'This is the json value'

 	def json_equivalent(self): return self.value

-class TestSequenceFunctions(unittest.TestCase):

+class TestJSONUTIL(unittest.TestCase):

 	def setUp(self):

 		# simple tests

@@ -92,11 +92,10 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert True

-			assert resource.eventhandler.processcontent.called

-			assert resource.eventhandler.callmethod.called

-			assert resource.eventhandler.processrequest.called

-			assert resource.eventhandler.log.called

+			self.assertTrue(resource.eventhandler.processcontent.called)

+			self.assertTrue(resource.eventhandler.callmethod.called)

+			self.assertTrue(resource.eventhandler.processrequest.called)

+			self.assertTrue(resource.eventhandler.log.called)

 		return d

@@ -113,10 +112,10 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data == {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": None}

+			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32700, "message": "Parse error."}, "id": None})

 		return d

@@ -132,9 +131,9 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data == {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_}

+			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

 		return d

@@ -150,9 +149,9 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data == {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_}

+			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": self.id_})

 		return d

 	def test_missingmethod(self):

@@ -167,9 +166,9 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data == {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": self.id_}

+			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Procedure not found."}, "id": self.id_})

 		return d

@@ -186,11 +185,11 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data['id'] == self.id_

-			assert data['result'] == self.param

+			self.assertEqual(data['id'], self.id_)

+			self.assertEqual(data['result'], self.param)

 		return d

 	def test_notify(self):

@@ -205,7 +204,7 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 0

+			self.assertEqual(len(request.written), 0)

 		return d

@@ -222,11 +221,11 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data['id'] == self.id_

-			assert data['result'] == self.param

+			self.assertEqual(data['id'], self.id_)

+			self.assertEqual(data['result'], self.param)

 		return d

@@ -243,11 +242,11 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored, *a):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data['id'] == self.id_

-			assert data.get('error', False)

+			self.assertEqual(data['id'], self.id_)

+			self.assertTrue(data.get('error', False))

 		return rendered

 	def test_batchcall(self):

@@ -265,13 +264,13 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored, *a):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert len(data) == 2

-			assert set(x['id'] for x in data) == set("12")

-			assert set(x['result'] for x in data) == set([3,5])

+			self.assertEqual(len(data), 2)

+			self.assertEqual(set(x['id'] for x in data), set("12"))

+			self.assertEqual(set(x['result'] for x in data), set([3,5]))

-			assert not any(x.get('error', False) for x in data)

+			self.assertFalse(any(x.get('error', False) for x in data))

 		return rendered

 	def test_batchcall_1err(self):

@@ -289,13 +288,13 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored, *a):

-			assert len(request.written) == 1

+			self.assertEqual(len(request.written), 1)

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert len(data) == 2

-			assert set(x['id'] for x in data) == set("12")

-			assert set(x.get('result', False) for x in data) == set([3,False])

+			self.assertEqual(len(data), 2)

+			self.assertEqual(set(x['id'] for x in data), set("12"))

+			self.assertEqual(set(x.get('result', False) for x in data), set([3,False]))

-			assert len(filter(None, [x.get('error') for x in data])) == 1

+			self.assertEqual(len(filter(None, [x.get('error') for x in data])), 1)

 		return rendered

@@ -313,7 +312,7 @@ class TestJSONRPCServer(unittest.TestCase):

 		@d.addCallback

 		def rendered(ignored, *a):

 			data = jsonrpc.jsonutil.decode(request.written[0])

-			assert data == {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": None}

+			self.assertEqual(data, {"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid Request."}, "id": None})

 		return rendered