Merge lp:~roger-lp/ladon/trunk into lp:ladon

[roger]

Contains implementation of JSON-RPC 1.0 specification for request and response, notifications hasn't implemented yet. Also contains fix for python 3.3 __qualname__ (PEP 3155 -- Qualified name for classes and functions).

[Mikhus (mikhus)]

Please, remove .bzrignore from merge

review: Needs Fixing

[roger (roger-lp)]

.bzrignore was removed

[jsgaarde (jakob-simon-gaarde)]

Please explain what these do and why they are nessecary:
add_passback_params(), get_passback_params()

[roger (roger-lp)]

I have decided to implement these two methods because I have faced with needs of interaction with request parameters which should be returned to client without changes (pass back parameters), it means that such parameters are used as markers, like "id" parameter in json-rpc requests and responses.

get_passback_params() is used for extracting "pass back parameters" from request parameters list.
add_passback_params() is used for putting, earlier extracted, "pass back parameters" into response parameters list.

[roger (roger-lp)]

One more clarification, these methods are needed for implementation request/response id mechanism as described in json-rpc 1.0 specification.

[jsgaarde (jakob-simon-gaarde)]

OK, I faced the same problem with jsonwsp implementing the mirror/reflection mechanism (built it into dispatcher as a general rule for all service protocols). To be honest - it should probably have been done something like your solution.
I'll finish my review tonight :-)

[jsgaarde (jakob-simon-gaarde)]

Only one more question. What is the effect of not having check for '__qualname__' in the TypeManager?
/ Jakob

[jsgaarde (jakob-simon-gaarde)]

Changes needed:

1. Here is something I don't do everyday, I'm going to ask you to to un-nice your solution (but to my defense it's for simplicity)

I have thought about the passback methods in interfaces.base.* - I think your solution is nice and everything, but I don't think we should extend the interfaces.base.Base* classes just to copy an id.
So I suggest a smaller not as nice solution for now:

http://pastebin.com/raw.php?i=GyPMSTBV

I know you meen to make the nicest solution I'm just worried about extending the interfaces.base.Base* classes much more - they are bloated enough already and these are exactly the classes we want to attract other people to use for contributing new interfaces.

2. please remove the methodname argument in call_method() of the dispatcher it is redundant cause the methodname _MUST_ recide in req_dict["methodname"] - we have to stick to some kind of format in req_dict and res_dict as they are very central in Ladon's design.
That also means you have to change your jsonrpc10 interface class so the method name doesn't end up in req_dict["method"].

Best Regards Jakob

[roger (roger-lp)]

If there are not check for '__qualname__' when I run ladon application using python 3.3 I get following exception for any exposed with ladonize method:

Traceback (most recent call last):
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_application.py", line 318, in __call__
    self.import_services(self.service_list)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_application.py", line 274, in import_services
    __import__(service)
  File "/home/roger/projects/ladon/frameworks/python/tests/services/attachmenttests.py", line 23, in <module>
    class AttachmentTestService(object):
  File "/home/roger/projects/ladon/frameworks/python/tests/services/attachmenttests.py", line 30, in AttachmentTestService
    @ladonize(File,rtype=UploadFileResponse)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/decorator.py", line 88, in decorator
    ladon_method_info = global_service_collection().add_service_method(f,*def_args,**def_kw)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/collection.py", line 133, in add_service_method
    method = self.services[(src_fname,clsname)].add_method(f,*def_args,**def_kw)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/collection.py", line 325, in add_method
    method = LadonMethodInfo(self,f,*def_args,**def_kw)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/collection.py", line 507, in __init__
    self._multipart_response_required = sinfo.typemanager.analyze_param(self._rtype)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typemanager.py", line 158, in analyze_param
    self.analyze_class(param)
  File "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typemanager.py", line 116, in analyze_class
    raise NeedToDefineParseTimeException("class attributes on LadonTypes must be defined as types, lists.\\nclass: %s\\nattr: %s" % (cls.__name__,attr))\nladon.exceptions.types.NeedToDefineParseTimeException: class attributes on LadonTypes must be defined as types, lists.
class: UploadFileResponse\nattr: __qualname__

[jsgaarde (jakob-simon-gaarde)]

OK, so this is a fix Python 3.3+? good :-)

> If there are not check for '__qualname__' when I run ladon application using
> python 3.3 I get following exception for any exposed with ladonize method:
>
> Traceback (most recent call last):
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_a
> pplication.py", line 318, in __call__
> self.import_services(self.service_list)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_a
> pplication.py", line 274, in import_services
> __import__(service)
> File "/home/roger/projects/ladon/frameworks/python/tests/services/attachment
> tests.py", line 23, in <module>
> class AttachmentTestService(object):
> File "/home/roger/projects/ladon/frameworks/python/tests/services/attachment
> tests.py", line 30, in AttachmentTestService
> @ladonize(File,rtype=UploadFileResponse)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/dec
> orator.py", line 88, in decorator
> ladon_method_info =
> global_service_collection().add_service_method(f,*def_args,**def_kw)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> lection.py", line 133, in add_service_method
> method =
> self.services[(src_fname,clsname)].add_method(f,*def_args,**def_kw)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> lection.py", line 325, in add_method
> method = LadonMethodInfo(self,f,*def_args,**def_kw)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> lection.py", line 507, in __init__
> self._multipart_response_required =
> sinfo.typemanager.analyze_param(self._rtype)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typeman
> ager.py", line 158, in analyze_param
> self.analyze_class(param)
> File "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typeman
> ager.py", line 116, in analyze_class
> raise NeedToDefineParseTimeException("class attributes on LadonTypes must
> be defined as types, lists.\\nclass: %s\\nattr: %s" %
> (cls.__name__,attr))\nladon.exceptions.types.NeedToDefineParseTimeException:
> class attributes on LadonTypes must be defined as types, lists.
> class: UploadFileResponse\nattr: __qualname__

[roger (roger-lp)]

Yup :)

> OK, so this is a fix Python 3.3+? good :-)
>
> > If there are not check for '__qualname__' when I run ladon application using
> > python 3.3 I get following exception for any exposed with ladonize method:
> >
> > Traceback (most recent call last):
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_a
> > pplication.py", line 318, in __call__
> > self.import_services(self.service_list)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/server/wsgi_a
> > pplication.py", line 274, in import_services
> > __import__(service)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/services/attachment
> > tests.py", line 23, in <module>
> > class AttachmentTestService(object):
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/services/attachment
> > tests.py", line 30, in AttachmentTestService
> > @ladonize(File,rtype=UploadFileResponse)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/dec
> > orator.py", line 88, in decorator
> > ladon_method_info =
> > global_service_collection().add_service_method(f,*def_args,**def_kw)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> > lection.py", line 133, in add_service_method
> > method =
> > self.services[(src_fname,clsname)].add_method(f,*def_args,**def_kw)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> > lection.py", line 325, in add_method
> > method = LadonMethodInfo(self,f,*def_args,**def_kw)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/ladonizer/col
> > lection.py", line 507, in __init__
> > self._multipart_response_required =
> > sinfo.typemanager.analyze_param(self._rtype)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typeman
> > ager.py", line 158, in analyze_param
> > self.analyze_class(param)
> > File
> "/home/roger/projects/ladon/frameworks/python/tests/ladon/types/typeman
> > ager.py", line 116, in analyze_class
> > raise NeedToDefineParseTimeException("class attributes on LadonTypes
> must
> > be defined as types, lists.\\nclass: %s\\nattr: %s" %
> > (cls.__name__,attr))\nladon.exceptions.types.NeedToDefineParseTimeException:
> > class attributes on LadonTypes must be defined as types, lists.
> > class: UploadFileResponse\nattr: __qualname__

[roger (roger-lp)]

Remarks were applied.

Regards Roger

> Changes needed:
>
> 1. Here is something I don't do everyday, I'm going to ask you to to un-nice
> your solution (but to my defense it's for simplicity)
>
> I have thought about the passback methods in interfaces.base.* - I think your
> solution is nice and everything, but I don't think we should extend the
> interfaces.base.Base* classes just to copy an id.
> So I suggest a smaller not as nice solution for now:
>
> http://pastebin.com/raw.php?i=GyPMSTBV
>
> I know you meen to make the nicest solution I'm just worried about extending
> the interfaces.base.Base* classes much more - they are bloated enough already
> and these are exactly the classes we want to attract other people to use for
> contributing new interfaces.
>
> 2. please remove the methodname argument in call_method() of the dispatcher it
> is redundant cause the methodname _MUST_ recide in req_dict["methodname"] - we
> have to stick to some kind of format in req_dict and res_dict as they are very
> central in Ladon's design.
> That also means you have to change your jsonrpc10 interface class so the
> method name doesn't end up in req_dict["method"].
>
> Best Regards Jakob

[lp:~roger-lp/ladon/trunk]

95. By jsgaarde on 2012-10-26

Merged Rogers json-rpc 1.0 interface

[jsgaarde (jakob-simon-gaarde)]

Merged - thanks Roger!

review: Approve (code)

=== modified file 'frameworks/python/src/ladon/interfaces/__init__.py'
--- frameworks/python/src/ladon/interfaces/__init__.py	2012-05-04 14:43:58 +0000
+++ frameworks/python/src/ladon/interfaces/__init__.py	2012-10-26 11:52:28 +0000
@@ -71,3 +71,4 @@
 import ladon.interfaces.soap
 import ladon.interfaces.soap11
 import ladon.interfaces.jsonwsp
+import ladon.interfaces.jsonrpc10

=== added file 'frameworks/python/src/ladon/interfaces/base.py'
--- frameworks/python/src/ladon/interfaces/base.py	1970-01-01 00:00:00 +0000
+++ frameworks/python/src/ladon/interfaces/base.py	2012-10-26 11:52:28 +0000
@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+import inspect
+
+class BaseInterface(object):
+	"""All interface implementations must descend from BaseInterface. The interface
+	implementation can be thought of as an aggregator that ties the three basic functions
+	of a web service protocol together:
+	
+		1. ServiceDescriptor - A generator class that can provide a description for the service.
+		   ie. WSDL for soap.
+		2. BaseRequestHandler - A handler that can parse the raw request objects from the client and
+		   convert them into a so-called req_dict (Request dictionary)
+		3. BaseResponseHandler - A handler that can process the res_dict (Result Dictionary) of a
+		   service call and build a response object that fit's the protocol being implemented.
+		4. BaseFaultHandler - A handler that can convert a ladon.exceptions.service.ServiceFault object
+		   to a fault response that fits the interface.
+	
+	"""
+	def __init__(self,sinfo,**kw):
+		self._sinfo = sinfo
+		sd = ServiceDescriptor()
+		if 'service_descriptor' in kw:
+			sd = kw['service_descriptor']
+			if inspect.getmro(sd).count(ServiceDescriptor):
+				self._service_descriptor = sd()
+		if 'request_handler' in kw:
+			req_handler = kw['request_handler']
+			if inspect.getmro(req_handler).count(BaseRequestHandler):
+				self._request_handler = req_handler()
+		if 'response_handler' in kw:
+			resp_handler = kw['response_handler']
+			if inspect.getmro(resp_handler).count(BaseResponseHandler):
+				self._response_handler = resp_handler()
+		if 'fault_handler' in kw:
+			fault_handler = kw['fault_handler']
+			if inspect.getmro(fault_handler).count(BaseFaultHandler):
+				self._fault_handler = fault_handler()
+
+	@staticmethod
+	def _interface_name(typ):
+		return None
+
+	@staticmethod
+	def _accept_basetype(typ):
+		return False
+
+	@staticmethod
+	def _accept_list():
+		return False
+
+	@staticmethod
+	def _accept_dict():
+		return False
+	
+	def service_info(self):
+		return self._sinfo
+	
+	def parse_request(self,soap_body,encoding='UTF-8'):
+		return self._request_handler.parse_request(soap_body,self._sinfo,encoding)
+
+	def build_response(self,res_dict,encoding='UTF-8'):
+		return self._response_handler.build_response(res_dict,self._sinfo,encoding)
+
+	def build_fault_response(self,exc,methodname=None,encoding='UTF-8'):
+		return self._fault_handler.build_fault_response(exc,self._sinfo,methodname,encoding)
+
+	def stringify_res_dict(self):
+		return self._response_handler._stringify_res_dict
+
+	def response_content_type(self):
+		return self._response_handler._content_type
+
+	def description(self,service_url,encoding='UTF-8'):
+		return self._service_descriptor.generate(
+			self._sinfo.servicename,
+			self._sinfo.servicenumber,
+			self._sinfo.typemanager,
+			self._sinfo.method_list(),
+			service_url,encoding)
+
+	def description_content_type(self):
+		return self._service_descriptor._content_type
+
+class ServiceDescriptor(object):
+	
+	_content_type = 'text/plain'
+	
+	def generate(self,servicename,servicenumber,typemanager,methodlist,encoding):
+		"""
+		Implement the method that can generate a service description file for the
+		type of interface you are developing. Thus if you were developing a new
+		and better SOAP interface and a new and better service descriptor for it,
+		you will be implementing a WSDL generator in this method.
+		
+		@param servicename This is a string containing the service class name
+		@param servicenumber An integer that reflects the order in which the service classes are parsed (useful for creating namespaces)
+		@param typemanager An instance of ladon.ladonizer.collection.TypeManager which manages the types used by the service
+		@param methodlist The list of methods exposed by the service
+		@param encoding The client-side controlled encoding to use in the descriptor
+		
+		@rtype String representation of the service descriptor (ie. wsdl-formatted if it were SOAP)
+		"""
+		return ''
+
+
+class BaseRequestHandler(object):
+	
+	def parse_request(self,req,sinfo,encoding):
+		return {}
+
+
+class BaseResponseHandler(object):
+	
+	"""
+	This is the base class of all response handlers. To implement a new response handler
+	inherit it and overload the build_response() method so it implements the protocol you are
+	extending Ladon with.
+	
+	set _stringify_res_dict to True if you want the Ladon dispatcher to convert all result
+	values to unicode regardless of their defined types during ladonization. This can be useful
+	in some interfaces. ie. SOAP where all values are presented the same way inside XML tags no
+	matter if it is a string or a number (example: <name>string</name><age>37</age>)
+	"""
+	_content_type = 'text/plain'
+	_stringify_res_dict = False
+	
+	def build_response(self,method_result,sinfo,encoding):
+		return ''
+
+class BaseFaultHandler(object):
+	
+	"""
+	This is the base class of all fault handlers. To implement a new fault handler
+	inherit it and overload the build_fault_response() method so it implements the
+	protocol you are extending Ladon with.
+	
+	set _stringify_res_dict to True if you want the Ladon dispatcher to convert all result
+	values to unicode regardless of their defined types during ladonization. This can be useful
+	in some interfaces. ie. SOAP where all values are presented the same way inside XML tags no
+	matter if it is a string or a number (example: <name>string</name><age>37</age>)
+	"""
+	_content_type = 'text/plain'
+	_stringify_res_dict = False
+	
+	def build_fault_response(self,exc,sinfo,methodname,encoding):
+		return ''

=== removed file 'frameworks/python/src/ladon/interfaces/base.py'
--- frameworks/python/src/ladon/interfaces/base.py	2012-01-06 12:44:37 +0000
+++ frameworks/python/src/ladon/interfaces/base.py	1970-01-01 00:00:00 +0000
@@ -1,147 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import inspect
-
-class BaseInterface(object):
-	"""All interface implementations must descend from BaseInterface. The interface
-	implementation can be thought of as an aggregator that ties the three basic functions
-	of a web service protocol together:
-	
-		1. ServiceDescriptor - A generator class that can provide a description for the service.
-		   ie. WSDL for soap.
-		2. BaseRequestHandler - A handler that can parse the raw request objects from the client and
-		   convert them into a so-called req_dict (Request dictionary)
-		3. BaseResponseHandler - A handler that can process the res_dict (Result Dictionary) of a
-		   service call and build a response object that fit's the protocol being implemented.
-		4. BaseFaultHandler - A handler that can convert a ladon.exceptions.service.ServiceFault object
-		   to a fault response that fits the interface.
-	
-	"""
-	def __init__(self,sinfo,**kw):
-		self._sinfo = sinfo
-		sd = ServiceDescriptor()
-		if 'service_descriptor' in kw:
-			sd = kw['service_descriptor']
-			if inspect.getmro(sd).count(ServiceDescriptor):
-				self._service_descriptor = sd()
-		if 'request_handler' in kw:
-			req_handler = kw['request_handler']
-			if inspect.getmro(req_handler).count(BaseRequestHandler):
-				self._request_handler = req_handler()
-		if 'response_handler' in kw:
-			resp_handler = kw['response_handler']
-			if inspect.getmro(resp_handler).count(BaseResponseHandler):
-				self._response_handler = resp_handler()
-		if 'fault_handler' in kw:
-			fault_handler = kw['fault_handler']
-			if inspect.getmro(fault_handler).count(BaseFaultHandler):
-				self._fault_handler = fault_handler()
-
-	@staticmethod
-	def _interface_name(typ):
-		return None
-
-	@staticmethod
-	def _accept_basetype(typ):
-		return False
-
-	@staticmethod
-	def _accept_list():
-		return False
-
-	@staticmethod
-	def _accept_dict():
-		return False
-	
-	def service_info(self):
-		return self._sinfo
-	
-	def parse_request(self,soap_body,encoding='UTF-8'):
-		return self._request_handler.parse_request(soap_body,self._sinfo,encoding)
-
-	def build_response(self,res_dict,encoding='UTF-8'):
-		return self._response_handler.build_response(res_dict,self._sinfo,encoding)
-
-	def build_fault_response(self,exc,methodname=None,encoding='UTF-8'):
-		return self._fault_handler.build_fault_response(exc,self._sinfo,methodname,encoding)
-
-	def stringify_res_dict(self):
-		return self._response_handler._stringify_res_dict
-
-	def response_content_type(self):
-		return self._response_handler._content_type
-
-	def description(self,service_url,encoding='UTF-8'):
-		return self._service_descriptor.generate(
-			self._sinfo.servicename,
-			self._sinfo.servicenumber,
-			self._sinfo.typemanager,
-			self._sinfo.method_list(),
-			service_url,encoding)
-
-	def description_content_type(self):
-		return self._service_descriptor._content_type
-
-class ServiceDescriptor(object):
-	
-	_content_type = 'text/plain'
-	
-	def generate(self,servicename,servicenumber,typemanager,methodlist,encoding):
-		"""
-		Implement the method that can generate a service description file for the
-		type of interface you are developing. Thus if you were developing a new
-		and better SOAP interface and a new and better service descriptor for it,
-		you will be implementing a WSDL generator in this method.
-		
-		@param servicename This is a string containing the service class name
-		@param servicenumber An integer that reflects the order in which the service classes are parsed (useful for creating namespaces)
-		@param typemanager An instance of ladon.ladonizer.collection.TypeManager which manages the types used by the service
-		@param methodlist The list of methods exposed by the service
-		@param encoding The client-side controlled encoding to use in the descriptor
-		
-		@rtype String representation of the service descriptor (ie. wsdl-formatted if it were SOAP)
-		"""
-		return ''
-
-
-class BaseRequestHandler(object):
-	
-	def parse_request(self,req,sinfo,encoding):
-		return {}
-
-
-class BaseResponseHandler(object):
-	
-	"""
-	This is the base class of all response handlers. To implement a new response handler
-	inherit it and overload the build_response() method so it implements the protocol you are
-	extending Ladon with.
-	
-	set _stringify_res_dict to True if you want the Ladon dispatcher to convert all result
-	values to unicode regardless of their defined types during ladonization. This can be useful
-	in some interfaces. ie. SOAP where all values are presented the same way inside XML tags no
-	matter if it is a string or a number (example: <name>string</name><age>37</age>)
-	"""
-	_content_type = 'text/plain'
-	_stringify_res_dict = False
-	
-	def build_response(self,method_result,sinfo,encoding):
-		return ''
-
-class BaseFaultHandler(object):
-	
-	"""
-	This is the base class of all fault handlers. To implement a new fault handler
-	inherit it and overload the build_fault_response() method so it implements the
-	protocol you are extending Ladon with.
-	
-	set _stringify_res_dict to True if you want the Ladon dispatcher to convert all result
-	values to unicode regardless of their defined types during ladonization. This can be useful
-	in some interfaces. ie. SOAP where all values are presented the same way inside XML tags no
-	matter if it is a string or a number (example: <name>string</name><age>37</age>)
-	"""
-	_content_type = 'text/plain'
-	_stringify_res_dict = False
-	
-	def build_fault_response(self,exc,sinfo,methodname,encoding):
-		return ''

=== added file 'frameworks/python/src/ladon/interfaces/jsonrpc10.py'
--- frameworks/python/src/ladon/interfaces/jsonrpc10.py	1970-01-01 00:00:00 +0000
+++ frameworks/python/src/ladon/interfaces/jsonrpc10.py	2012-10-26 11:52:28 +0000
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+
+from ladon.interfaces.base import BaseInterface,ServiceDescriptor,BaseRequestHandler,BaseResponseHandler,BaseFaultHandler
+from ladon.interfaces import expose
+from ladon.compat import type_to_jsontype,pytype_support,PORTABLE_STRING
+import json,sys,traceback
+from ladon.exceptions.service import ServiceFault
+from ladon.exceptions.base import LadonException
+
+def _add_passback_params(res_dict,passback_dict):
+	merged_dict = dict((k,v) for (k,v) in res_dict.items())	
+	for k,v in passback_dict.items():
+		merged_dict[k] = v
+	return merged_dict
+
+class RequestPropFault(ServiceFault):
+	def __init__(self,prop, passback_dict):
+		self.prop = prop
+		self.passback_dict = passback_dict
+		super(RequestPropFault,self).__init__('service','Request doesn\'t have "%s" property.' % self.prop, None, 2)
+
+	def __str__(self):
+		return self.faultstring
+
+class RequestParamFault(ServiceFault):
+	def __init__(self,param, passback_dict):
+		self.param = param
+		self.passback_dict = passback_dict
+		super(RequestParamFault,self).__init__('service','Request doesn\'t have "%s" parameter.' % self.param, None, 2)
+
+	def __str__(self):
+		return self.faultstring
+
+class JSONRPCServiceDescriptor(ServiceDescriptor):	
+	javascript_type_map = type_to_jsontype
+	version = '1.0'
+	_content_type = 'application/json'
+
+	def generate(self,servicename,servicenumber,typemanager,methodlist,service_url,encoding):
+		type_dict = typemanager.type_dict
+		type_order = typemanager.type_order
+
+		def map_type(typ):
+			if typ in JSONRPCServiceDescriptor.javascript_type_map:
+				return JSONRPCServiceDescriptor.javascript_type_map[typ]
+			else:
+				return typ.__name__
+
+		desc = {
+			'servicename': servicename,
+			'url': service_url,
+			'type': 'jsonrpc/description',
+			'version': self.version,
+			'types': {},
+			'methods': {}
+		}
+		
+		types = desc['types']
+		for typ in type_order:
+			if type(typ)==dict:
+				desc_type = {}
+				types[typ['name']] = desc_type
+				for k,v,props in typ['attributes']:
+					if type(v)==list:
+						desc_type_val = [map_type(v[0])]
+					else:
+						desc_type_val = map_type(v)
+					desc_type[k] = desc_type_val
+
+		methods = desc['methods']
+		for m in methodlist:
+			desc_mparams = {}
+			order = 1
+			desc_method = {'params': desc_mparams, 'doc_lines': m._method_doc}
+			methods[m.name()] = desc_method
+			for arg in m.args():
+				if [list,tuple].count(type(arg['type'])):
+					desc_param_type = [map_type(arg['type'][0])]
+				else:
+					desc_param_type = map_type(arg['type'])
+				desc_mparams[arg['name']] = {
+					"type": desc_param_type,
+					"def_order": order,
+					"optional": arg['optional'],
+					}
+				if 'doc' in arg:
+					desc_mparams[arg['name']]["doc_lines"] = arg['doc']
+				else:
+					desc_mparams[arg['name']]["doc_lines"] = []
+				order += 1
+				
+			if [list,tuple].count(type(m._rtype)):
+				desc_rtype = [map_type(m._rtype[0])]
+			else:
+				desc_rtype = map_type(m._rtype)
+			desc_method['ret_info'] = {
+				'type': desc_rtype,
+				'doc_lines': m._rtype_doc
+			}
+			
+		if sys.version_info[0]>=3:
+			return json.dumps(desc)
+		return json.dumps(desc,encoding=encoding)
+
+class JSONRPCRequestHandler(BaseRequestHandler):
+	def parse_request(self,json_body,sinfo,encoding):
+		def parse_number(x):
+			return PORTABLE_STRING(x)
+		def parse_constant(x):
+			if x=='null':
+				return PORTABLE_STRING("None")
+			return PORTABLE_STRING(x)
+		req_dict = json.loads(PORTABLE_STRING(json_body,encoding), parse_int=parse_number, parse_float=parse_number, \
+			parse_constant=parse_constant)
+		passback_dict = self.get_passback_params(req_dict)
+		if 'method' not in req_dict:
+			raise RequestPropFault('method',passback_dict)
+		if 'params' not in req_dict:
+			raise RequestPropFault('params',passback_dict)
+		if 'id' not in req_dict:
+			raise RequestPropFault('id',passback_dict)
+		minfo = sinfo.methods[req_dict['method']]
+		if (req_dict['params'] is None or len(req_dict['params']) == 0) and len(minfo.args()) > 0:
+			raise RequestParamFault(minfo.args()[0]['name'],passback_dict)
+		else:
+			for arg in minfo.args():
+				isgiven = False
+				for param in req_dict['params']:
+					if param == arg['name']:
+						isgiven = True
+				if not isgiven:
+					raise RequestParamFault(arg['name'],passback_dict)
+		req_dict['args'] = req_dict['params']
+		req_dict['methodname'] = req_dict['method']
+		del req_dict['params']
+		del req_dict['method']
+		return req_dict
+	
+	def get_passback_params(self, req_dict):
+		if 'id' in req_dict:
+			return {'id': req_dict['id']}
+		else:
+			return {}
+
+class JSONRPCResponseHandler(BaseResponseHandler):
+	_content_type = 'application/json'
+	_stringify_res_dict = False
+	
+	def build_response(self,res_dict,sinfo,encoding):
+		res_dict['error'] = None
+		del res_dict['servicenumber']
+		del res_dict['servicename']
+		del res_dict['method']
+		return json.dumps(res_dict,ensure_ascii=False).encode(encoding)
+
+class JSONRPCFaultHandler(BaseFaultHandler):
+	_content_type = 'application/json'
+	_stringify_res_dict = False
+	
+	def build_fault_response(self,service_exc,sinfo,methodname,encoding):
+		if service_exc.detail:
+			detail = service_exc.detail
+		else:
+			detail = traceback.format_exc()
+		detail = detail.replace('\r\n','\n').split('\n')
+		fault_dict = {
+			'result': None,
+			'error': {
+				'code': service_exc.faultcode,
+				'string': service_exc.faultstring,
+				'detail': detail,
+				'filename': service_exc.mod,
+				'lineno': service_exc.lineno
+			},
+		}
+		if hasattr(service_exc,'passback_dict'):
+			fault_dict = _add_passback_params(fault_dict,service_exc.passback_dict)
+		return json.dumps(fault_dict,ensure_ascii=False).encode(encoding)
+
+@expose
+class JSONRPCInterface(BaseInterface):
+	def __init__(self,sinfo,**kw):
+		def_kw = {
+			'service_descriptor': JSONRPCServiceDescriptor,
+			'request_handler': JSONRPCRequestHandler,
+			'response_handler': JSONRPCResponseHandler,
+			'fault_handler': JSONRPCFaultHandler}
+		def_kw.update(kw)
+		BaseInterface.__init__(self,sinfo,**def_kw)
+
+	@staticmethod
+	def _interface_name():
+		return 'jsonrpc10'
+
+	@staticmethod
+	def _accept_basetype(typ):
+		return pytype_support.count(typ)>0
+
+	@staticmethod
+	def _accept_list():
+		return True
+
+	@staticmethod
+	def _accept_dict():
+		return False
\ No newline at end of file

=== modified file 'frameworks/python/src/ladon/server/dispatcher.py'
--- frameworks/python/src/ladon/server/dispatcher.py	2012-09-05 12:39:33 +0000
+++ frameworks/python/src/ladon/server/dispatcher.py	2012-10-26 11:52:28 +0000
@@ -178,6 +178,8 @@
 		res_dict = self.result_to_dict(method,result,tc,export_dict['response_attachments'],log_line=log_line)
 		if 'mirror' in req_dict:
 			res_dict['reflection'] = req_dict['mirror']
+		if 'id' in req_dict:
+			res_dict['id'] = req_dict['id']
 		response = self.iface.build_response(res_dict,encoding=self.response_encoding)
 		if self.logging:
 			debug('\t%s' % ('\t'.join(log_line)))

=== modified file 'frameworks/python/src/ladon/types/typemanager.py'
--- frameworks/python/src/ladon/types/typemanager.py	2012-01-28 14:40:18 +0000
+++ frameworks/python/src/ladon/types/typemanager.py	2012-10-26 11:52:28 +0000
@@ -9,7 +9,9 @@
 	this_cls_attrs = dir(cls)
 	res = []
 	for attr in this_cls_attrs:
-		if base_attrs.count(attr) or (exclude_methods and inspect.ismethod(getattr(cls,attr))):
+		# attr == '__qualname__'
+		# Python 3.3 __qualname__ (PEP 3155 -- Qualified name for classes and functions) fix
+		if base_attrs.count(attr) or (exclude_methods and inspect.ismethod(getattr(cls,attr))) or attr == '__qualname__':
 			continue
 		res += [attr]
 	return res

=== modified file 'frameworks/python/tests/servicerunner.py'
--- frameworks/python/tests/servicerunner.py	2012-10-15 15:05:09 +0000
+++ frameworks/python/tests/servicerunner.py	2012-10-26 11:52:28 +0000
@@ -9,6 +9,7 @@
 	'stringtests',
 	'typetests',
 	'attachmenttests',
+	'jsonrpc10',
 	'collectiontest'
 ]
 

=== added file 'frameworks/python/tests/services/jsonrpc10.py'
--- frameworks/python/tests/services/jsonrpc10.py	1970-01-01 00:00:00 +0000
+++ frameworks/python/tests/services/jsonrpc10.py	2012-10-26 11:52:28 +0000
@@ -0,0 +1,54 @@
+from ladon.ladonizer import ladonize
+from ladon.compat import PORTABLE_BYTES,PORTABLE_STRING
+import binascii
+import sys
+
+class JsonPrc10Service(object):
+    @ladonize(rtype=PORTABLE_STRING)
+    def return_string(self):
+        if sys.version_info[0]>=3:
+            return 'Yo!!!'
+        return PORTABLE_STRING('Yo!!!','utf-8')
+    
+    @ladonize(rtype=int)
+    def return_int(self):
+        return 11
+    
+    @ladonize(rtype=float)
+    def return_float(self):
+        return 11.11
+    
+    @ladonize(rtype=bool)
+    def return_bool(self):
+        return True
+    
+    @ladonize(rtype=PORTABLE_BYTES)
+    def return_bytes(self):
+        if sys.version_info[0]>=3:
+            return PORTABLE_BYTES('Yo!!!','utf-8')
+        return 'Yo!!!'
+    
+    @ladonize(PORTABLE_STRING, rtype=PORTABLE_STRING)
+    def passback_string(self,arg):
+        return arg
+    
+    @ladonize(int,rtype=int)
+    def passback_int(self,arg):
+        return arg
+    
+    @ladonize(float,rtype=float)
+    def passback_float(self,arg):
+        return arg
+    
+    @ladonize(bool,rtype=bool)
+    def passback_bool(self,arg):
+        return arg
+    
+    @ladonize(PORTABLE_BYTES,rtype=PORTABLE_BYTES)
+    def passback_bytes(self,arg):
+        return arg
+    
+    @ladonize(int,float,PORTABLE_STRING,rtype=bool)
+    def params(self,arg0,arg1,arg2):
+        return True
+        
\ No newline at end of file

=== added file 'frameworks/python/tests/testjsonrpc10.py'
--- frameworks/python/tests/testjsonrpc10.py	1970-01-01 00:00:00 +0000
+++ frameworks/python/tests/testjsonrpc10.py	2012-10-26 11:52:28 +0000
@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+
+import unittest
+import servicerunner
+import sys
+import xml.dom.minidom as md
+if sys.version_info[0]>=3:
+	from urllib.parse import urlparse,splitport
+	from http.client import HTTPConnection, HTTPSConnection
+else:
+	from urllib import splitport
+	from urlparse import urlparse
+	from httplib import HTTPConnection, HTTPSConnection
+import sys,json
+from ladon.compat import PORTABLE_BYTES,PORTABLE_STRING,PORTABLE_STRING_TYPES
+from testladon import HTTPRequestPoster
+from testladon import str_to_portable_string
+import binascii
+
+class JsonRpc10Tests(unittest.TestCase):
+
+	def setUp(self):
+		self.post_helper = HTTPRequestPoster('http://localhost:2376/JsonPrc10Service')
+
+	def test_get_string(self):
+		req = {'method':'return_string','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = str_to_portable_string('Yo!!!')
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_get_int(self):
+		req = {'method':'return_int','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = 11
+		self.assertEqual(res['result'], expected_result)
+	
+	def test_get_float(self):
+		req = {'method':'return_float','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = 11.11
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_get_bool(self):
+		req = {'method':'return_bool','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = True
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_get_bytes(self):
+		req = {'method':'return_bytes','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = 'Yo!!!'
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_passback_string(self):
+		val = 'Yo!!!'
+		req = {'method':'passback_string','params':{'arg':val},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = str_to_portable_string(val)
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_passback_int(self):
+		val = 11
+		req = {'method':'passback_int','params':{'arg':val},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = val
+		self.assertEqual(res['result'], expected_result)
+	
+	def test_passback_float(self):
+		val = 11.11
+		req = {'method':'passback_float','params':{'arg':val},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = val
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_passback_bool(self):
+		val = True
+		req = {'method':'passback_bool','params':{'arg':val},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		expected_result = val
+		self.assertEqual(res['result'], expected_result)
+		
+	def test_passback_bytes(self):
+		val = 'Yo!!!'
+		req = {'method':'passback_bytes','params':{'arg':val},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		self.assertEqual(res['result'], val)
+		
+	def test_validate_request_response_structure(self):
+		req = {}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+
+		self.assertIs(type(res['error']), dict)
+		self.assertTrue('id' is not res)
+		self.assertIs(res['result'], None)
+		self.assertTrue('"method"' in res['error']['string'])
+		
+		req = {'method':'passback_string'}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		self.assertIs(type(res['error']), dict)
+		self.assertTrue('id' is not res)
+		self.assertIs(res['result'], None)
+		self.assertTrue('"params"' in res['error']['string'])
+		
+		req = {'method':'passback_string','params':None}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		self.assertIs(type(res['error']), dict)
+		self.assertTrue('id' is not res)
+		self.assertIs(res['result'], None)
+		self.assertTrue('"id"' in res['error']['string'])
+		
+		req = {'method':'passback_string','params':None,'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		
+		self.assertIs(type(res['error']), dict)
+		self.assertEqual(res['id'], '0')
+		self.assertIs(res['result'], None)
+		
+		req = {'method':'passback_string','params':None,'id':'0'}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+		
+		self.assertIs(type(res['error']), dict)
+		self.assertEqual(res['id'], '0')
+		self.assertIs(res['result'], None)
+		
+		req = {'method':'passback_string','params':{'arg': 'Yo!!!'},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+
+		self.assertIs(res['error'], None)
+		self.assertEqual(res['id'], '0')
+		self.assertEqual(res['result'], 'Yo!!!')
+		
+		req = {'method':'params','params':{},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+
+		self.assertIs(type(res['error']), dict)
+		self.assertEqual(res['id'], '0')
+		self.assertTrue('"arg0"' in res['error']['string'])
+		
+		req = {'method':'params','params':{'arg0':11},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+
+		self.assertIs(type(res['error']), dict)
+		self.assertEqual(res['id'], '0')
+		self.assertTrue('"arg1"' in res['error']['string'])
+		
+		req = {'method':'params','params':{'arg0':11, 'arg1':11.11},'id':0}
+		jreq = json.dumps(req)
+		
+		status,reason,resdata = self.post_helper.post_request(jreq.encode('utf-8'),extra_path='jsonrpc10',encoding='utf-8')
+		
+		self.assertEqual(status, 200)
+		res = json.loads(PORTABLE_STRING(resdata,'utf-8'))
+
+		self.assertIs(type(res['error']), dict)
+		self.assertEqual(res['id'], '0')
+		self.assertTrue('"arg2"' in res['error']['string'])
+
+if __name__ == '__main__':
+	import servicerunner
+	servicerunner
+	service_thread = servicerunner.serve_test_service(as_thread=True)
+	unittest.main(exit=False)
+	service_thread.server.shutdown()
\ No newline at end of file