def __init__(self, service_name, name, procedures, documentation, sort): super(Class, self).__init__() self.service_name = service_name self.name = name self.fullname = service_name+'.'+name self.documentation = documentation self.cref = 'T:%s.%s' % (service_name, name) members = [] properties = defaultdict(lambda: dict()) for pname,pinfo in procedures.iteritems(): #assert(Attributes.is_a_class_member(pinfo['attributes'])) #assert(Attributes.get_class_name(pinfo['attributes']) == name) if Attributes.is_a_class_method(pinfo['attributes']): members.append(ClassMethod(service_name, name, pname, **pinfo)) elif Attributes.is_a_class_static_method(pinfo['attributes']): members.append(ClassStaticMethod(service_name, name, pname, **pinfo)) elif Attributes.is_a_class_property_accessor(pinfo['attributes']): propname = Attributes.get_class_property_name(pinfo['attributes']) proc = Procedure(service_name, pname, **pinfo) if Attributes.is_a_class_property_getter(pinfo['attributes']): properties[propname]['getter'] = proc else: properties[propname]['setter'] = proc for propname,prop in properties.iteritems(): members.append(ClassProperty(service_name, name, propname, **prop)) self.members = OrderedDict((member.name, member) for member in sorted(members, key=sort))
def __init__(self, service_name, name, procedures, documentation, sort): super(Class, self).__init__() self.service_name = service_name self.name = name self.fullname = service_name + '.' + name self.documentation = documentation self.cref = 'T:%s.%s' % (service_name, name) members = [] properties = defaultdict(dict) for pname, pinfo in procedures.iteritems(): if Attributes.is_a_class_method(pinfo['attributes']): members.append(ClassMethod(service_name, name, pname, **pinfo)) elif Attributes.is_a_class_static_method(pinfo['attributes']): members.append( ClassStaticMethod(service_name, name, pname, **pinfo)) elif Attributes.is_a_class_property_accessor(pinfo['attributes']): propname = Attributes.get_class_property_name( pinfo['attributes']) proc = Procedure(service_name, pname, **pinfo) if Attributes.is_a_class_property_getter(pinfo['attributes']): properties[propname]['getter'] = proc else: properties[propname]['setter'] = proc for propname, prop in properties.iteritems(): members.append(ClassProperty(service_name, name, propname, **prop)) self.members = OrderedDict( (member.name, member) for member in sorted(members, key=sort))
def test_get_class_name(self): self.assertRaises(ValueError, Attributes.get_class_name, []) self.assertRaises(ValueError, Attributes.get_class_name, ['Property.Get(PropertyName)']) self.assertRaises(ValueError, Attributes.get_class_name, ['Property.Set(PropertyName)']) self.assertEqual('ClassName', Attributes.get_class_name(['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertEqual('ClassName', Attributes.get_class_name(['Class.StaticMethod(ServiceName.ClassName,MethodName)'])) self.assertEqual('ClassName', Attributes.get_class_name(['Class.Property.Get(ServiceName.ClassName,PropertyName)'])) self.assertEqual('ClassName', Attributes.get_class_name(['Class.Property.Set(ServiceName.ClassName,PropertyName)']))
def test_get_return_type_attributes(self): self.assertEqual([], Attributes.get_return_type_attrs([])) self.assertEqual([], Attributes.get_return_type_attrs( ['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertEqual( ['Class(ServiceName.ClassName)'], Attributes.get_return_type_attrs( ['ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual( ['Class(ServiceName.ClassName)'], Attributes.get_return_type_attrs( ['Class.Method(ServiceName.ClassName,MethodName)', 'ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual( ['List(string)'], Attributes.get_return_type_attrs( ['ReturnType.List(string)'])) self.assertEqual( ['Dictionary(int32,string)'], Attributes.get_return_type_attrs( ['ReturnType.Dictionary(int32,string)'])) self.assertEqual( ['Set(string)'], Attributes.get_return_type_attrs( ['ReturnType.Set(string)'])) self.assertEqual( ['List(Dictionary(int32,string))'], Attributes.get_return_type_attrs( ['ReturnType.List(Dictionary(int32,string))'])) self.assertEqual( ['Dictionary(int32,List(ServiceName.ClassName))'], Attributes.get_return_type_attrs( ['ReturnType.Dictionary(int32,List(ServiceName.ClassName))']))
def test_get_property_name(self): self.assertRaises(ValueError, Attributes.get_property_name, 'ProcedureName') self.assertEqual('PropertyName', Attributes.get_property_name('get_PropertyName')) self.assertEqual('PropertyName', Attributes.get_property_name('set_PropertyName')) self.assertRaises(ValueError, Attributes.get_property_name, 'ClassName_MethodName') self.assertRaises(ValueError, Attributes.get_property_name, 'ClassName_StaticMethodName') self.assertRaises(ValueError, Attributes.get_property_name, 'ClassName_get_PropertyName)') self.assertRaises(ValueError, Attributes.get_property_name, 'ClassName_set_PropertyName)')
def test_get_class_name(self): self.assertRaises(ValueError, Attributes.get_class_name, []) self.assertRaises( ValueError, Attributes.get_class_name, ['Property.Get(PropertyName)']) self.assertRaises( ValueError, Attributes.get_class_name, ['Property.Set(PropertyName)']) self.assertEqual('ClassName', Attributes.get_class_name( ['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertEqual('ClassName', Attributes.get_class_name( ['Class.StaticMethod(ServiceName.ClassName,MethodName)'])) self.assertEqual('ClassName', Attributes.get_class_name( ['Class.Property.Get(ServiceName.ClassName,PropertyName)'])) self.assertEqual('ClassName', Attributes.get_class_name( ['Class.Property.Set(ServiceName.ClassName,PropertyName)']))
def __init__(self, service_name, class_name, name, parameters, documentation, return_type=None, return_is_nullable=False, game_scenes=None): super(ClassStaticMethod, self).__init__() name = Attributes.get_class_member_name(name) self.service_name = service_name self.class_name = class_name self.name = name self.fullname = service_name + '.' + class_name + '.' + name if return_type is not None: self.return_type = as_type(self.types, return_type) else: self.return_type = None self.return_is_nullable = return_is_nullable self.parameters = [ Parameter(documentation=documentation, **info) for info in parameters ] self.game_scenes = game_scenes self.documentation = documentation self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def __init__(self, service_name, class_name, name, parameters, attributes, documentation, return_type=None): super(ClassStaticMethod, self).__init__() name = Attributes.get_class_method_name(attributes) self.service_name = service_name self.class_name = class_name self.name = name self.fullname = service_name + '.' + class_name + '.' + name if return_type is not None: self.return_type = self.types.get_return_type( return_type, attributes) else: self.return_type = None self.parameters = [ Parameter(position=i, attributes=attributes, documentation=documentation, **info) for i, info in enumerate(parameters) ] self.attributes = attributes self.documentation = documentation self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def __init__(self, rpc_connection, stream_connection): self._types = Types() self._rpc_connection = rpc_connection self._rpc_connection_lock = threading.Lock() self._stream_connection = stream_connection self._request_type = self._types.as_type("KRPC.Request") self._response_type = self._types.as_type("KRPC.Response") # Set up the main KRPC service self.krpc = KRPC(self) services = self.krpc.get_services().services # Create class types # TODO: is this needed?!? for service in services: for procedure in service.procedures: try: name = Attributes.get_class_name(procedure.attributes) self._types.as_type("Class(" + service.name + "." + name + ")") except ValueError: pass # Set up services for service in services: if service.name != "KRPC": setattr(self, _to_snake_case(service.name), create_service(self, service)) # Set up stream update thread if stream_connection is not None: self._stream_thread = threading.Thread(target=krpc.stream.update_thread, args=(stream_connection,)) self._stream_thread.daemon = True self._stream_thread.start() else: self._stream_thread = None
def __init__(self, service_name, class_name, name, getter=None, setter=None): super(ClassProperty, self).__init__() self.service_name = service_name self.class_name = class_name if getter is not None: name = Attributes.get_class_property_name(getter.attributes) self.type = getter.return_type self.documentation = getter.documentation else: name = Attributes.get_class_property_name(setter.attributes) self.type = setter.parameters[1].type self.documentation = setter.documentation self.name = name self.fullname = service_name+'.'+class_name+'.'+name self.getter = getter self.setter = setter self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def __init__(self, service_name, name, procedures, documentation): super(Class, self).__init__() self.service_name = service_name self.name = name self.fullname = service_name+'.'+name self.documentation = documentation self.cref = 'T:%s.%s' % (service_name, name) self.members = {} for pname,pinfo in procedures.items(): if Attributes.is_a_class_member(pinfo['attributes']) and \ Attributes.get_class_name(pinfo['attributes']) == name: if Attributes.is_a_class_method(pinfo['attributes']): member = ClassMethod(service_name, name, pname, **pinfo) elif Attributes.is_a_class_static_method(pinfo['attributes']): member = ClassStaticMethod(service_name, name, pname, **pinfo) else: continue self.members[member.name] = member properties = {} for pname,pinfo in procedures.items(): if Attributes.is_a_class_property_accessor(pinfo['attributes']): propname = Attributes.get_class_property_name(pinfo['attributes']) if propname not in properties: properties[propname] = {} if Attributes.is_a_class_property_getter(pinfo['attributes']): properties[propname]['getter'] = Procedure(service_name, pname, **pinfo) else: properties[propname]['setter'] = Procedure(service_name, pname, **pinfo) for propname,prop in properties.items(): prop = ClassProperty(service_name, name, propname, **prop) self.members[prop.name] = prop
def test_get_class_name(self): self.assertRaises(ValueError, Attributes.get_class_name, 'ProcedureName') self.assertRaises(ValueError, Attributes.get_class_name, 'get_PropertyName') self.assertRaises(ValueError, Attributes.get_class_name, 'set_PropertyName') self.assertEqual('ClassName', Attributes.get_class_name('ClassName_MethodName')) self.assertEqual('ClassName', Attributes.get_class_name( 'ClassName_StaticMethodName')) self.assertEqual('ClassName', Attributes.get_class_name( 'ClassName_get_PropertyName)')) self.assertEqual('ClassName', Attributes.get_class_name( 'ClassName_set_PropertyName)'))
def test_is_a_class_property_setter(self): self.assertFalse(Attributes.is_a_class_property_setter([])) self.assertFalse(Attributes.is_a_class_property_setter(['Property.Get(PropertyName)'])) self.assertFalse(Attributes.is_a_class_property_setter(['Property.Set(PropertyName)'])) self.assertFalse(Attributes.is_a_class_property_setter(['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertFalse(Attributes.is_a_class_property_setter(['Class.StaticMethod(ServiceName.ClassName,MethodName)'])) self.assertFalse(Attributes.is_a_class_property_setter(['Class.Property.Get(ServiceName.ClassName,PropertyName)'])) self.assertTrue(Attributes.is_a_class_property_setter(['Class.Property.Set(ServiceName.ClassName,PropertyName)']))
def get_return_type(self, typ, attrs): """ Return a type object for the return value with the given protocol buffer type and procedure attributes """ attrs = Attributes.get_return_type_attrs(attrs) for attr in attrs: try: return self.as_type(attr) except ValueError: pass return self.as_type(typ)
def get_parameter_type(self, pos, typ, attrs): """ Return a type object for a parameter at the given position, with the given protocol buffer type and attributes """ attrs = Attributes.get_parameter_type_attrs(pos, attrs) for attr in attrs: try: return self.as_type(attr) except ValueError: pass return self.as_type(typ)
def __init__(self, name, procedures, classes, enumerations, documentation): super(Service, self).__init__() self.name = name self.fullname = name self.documentation = documentation self.cref = 'T:%s' % name self.members = {} for pname,info in procedures.items(): if Attributes.is_a_procedure(info['attributes']): proc = Procedure(name, pname, **info) self.members[proc.name] = proc properties = {} for pname,info in procedures.items(): if Attributes.is_a_property_accessor(info['attributes']): propname = Attributes.get_property_name(info['attributes']) if propname not in properties: properties[propname] = {} if Attributes.is_a_property_getter(info['attributes']): properties[propname]['getter'] = Procedure(name, pname, **info) else: properties[propname]['setter'] = Procedure(name, pname, **info) for propname,prop in properties.items(): prop = Property(name, propname, **prop) self.members[prop.name] = prop self.classes = {} for cname,cinfo in classes.items(): cprocedures = dict(filter( lambda (name,info): Attributes.is_a_class_member(info['attributes']) and \ Attributes.get_class_name(info['attributes']) == cname, procedures.items())) self.classes[cname] = Class(name, cname, cprocedures, **cinfo) self.enumerations = dict([(ename,Enumeration(name, ename, **einfo)) for ename,einfo in enumerations.items()])
def __init__(self, name, procedures, classes, enumerations, documentation, sort): super(Service, self).__init__() self.name = name self.fullname = name self.documentation = documentation self.cref = 'T:%s' % name members = [] cprocedures = defaultdict(lambda: dict()) properties = defaultdict(lambda: dict()) for pname,info in procedures.iteritems(): if Attributes.is_a_procedure(info['attributes']): members.append(Procedure(name, pname, **info)) elif Attributes.is_a_property_accessor(info['attributes']): propname = Attributes.get_property_name(info['attributes']) if Attributes.is_a_property_getter(info['attributes']): properties[propname]['getter'] = Procedure(name, pname, **info) else: properties[propname]['setter'] = Procedure(name, pname, **info) elif Attributes.is_a_class_member(info['attributes']): cname = Attributes.get_class_name(info['attributes']) cprocedures[cname][pname] = info for propname,prop in properties.iteritems(): members.append(Property(name, propname, **prop)) self.classes = {cname: Class(name, cname, cprocedures[cname], sort=sort, **cinfo) for (cname,cinfo) in classes.iteritems()} self.enumerations = {ename: Enumeration(name, ename, sort=sort, **einfo) for (ename,einfo) in enumerations.iteritems()} self.members = OrderedDict((member.name, member) for member in sorted(members, key=sort))
def __init__(self, service_name, class_name, name, getter=None, setter=None): super(ClassProperty, self).__init__() self.service_name = service_name self.class_name = class_name if getter is not None: name = Attributes.get_class_property_name(getter.attributes) self.type = getter.return_type self.documentation = getter.documentation else: name = Attributes.get_class_property_name(setter.attributes) self.type = setter.parameters[1].type self.documentation = setter.documentation self.name = name self.fullname = service_name + '.' + class_name + '.' + name self.getter = getter self.setter = setter self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def test_get_return_type_attributes(self): self.assertEqual([], Attributes.get_return_type_attrs([])) self.assertEqual([], Attributes.get_return_type_attrs( ['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertEqual(['Class(ServiceName.ClassName)'], Attributes.get_return_type_attrs( ['ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual(['Class(ServiceName.ClassName)'], Attributes.get_return_type_attrs( ['Class.Method(ServiceName.ClassName,MethodName)', 'ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual(['List(string)'], Attributes.get_return_type_attrs( ['ReturnType.List(string)'])) self.assertEqual(['Dictionary(int32,string)'], Attributes.get_return_type_attrs( ['ReturnType.Dictionary(int32,string)'])) self.assertEqual(['Set(string)'], Attributes.get_return_type_attrs( ['ReturnType.Set(string)'])) self.assertEqual(['List(Dictionary(int32,string))'], Attributes.get_return_type_attrs( ['ReturnType.List(Dictionary(int32,string))'])) self.assertEqual(['Dictionary(int32,List(ServiceName.ClassName))'], Attributes.get_return_type_attrs( ['ReturnType.Dictionary(int32,List(ServiceName.ClassName))']))
def __init__(self, service_name, class_name, name, parameters, attributes, documentation, return_type=None): super(ClassStaticMethod, self).__init__() name = Attributes.get_class_method_name(attributes) self.service_name = service_name self.class_name = class_name self.name = name self.fullname = service_name+'.'+class_name+'.'+name if return_type is not None: self.return_type = types.get_return_type(return_type, attributes) else: self.return_type = None self.parameters = [Parameter(position=i, attributes=attributes, documentation=documentation, **info) for i,info in enumerate(parameters)] self.attributes = attributes self.documentation = documentation self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def __init__(self, name, procedures, classes, enumerations, exceptions, documentation, sort): super(Service, self).__init__() self.name = name self.fullname = name self.documentation = documentation self.cref = 'T:%s' % name members = [] cprocedures = defaultdict(dict) properties = defaultdict(dict) for pname, info in procedures.iteritems(): del info['id'] if 'game_scenes' in info: info['game_scenes'] = ', '.join( x.replace('_', ' ').title() for x in info['game_scenes']) else: info['game_scenes'] = 'All' if Attributes.is_a_procedure(pname): members.append(Procedure(name, pname, **info)) elif Attributes.is_a_property_accessor(pname): propname = Attributes.get_property_name(pname) if Attributes.is_a_property_getter(pname): properties[propname]['getter'] = Procedure( name, pname, **info) else: properties[propname]['setter'] = Procedure( name, pname, **info) elif Attributes.is_a_class_member(pname): cname = Attributes.get_class_name(pname) cprocedures[cname][pname] = info for propname, prop in properties.iteritems(): members.append(Property(name, propname, **prop)) self.classes = { cname: Class(name, cname, cprocedures[cname], sort=sort, **cinfo) for (cname, cinfo) in classes.iteritems() } self.enumerations = { ename: Enumeration(name, ename, sort=sort, **einfo) for (ename, einfo) in enumerations.iteritems() } self.exceptions = { ename: ExceptionNode(name, ename, **einfo) for (ename, einfo) in exceptions.iteritems() } self.members = OrderedDict( (member.name, member) for member in sorted(members, key=sort))
def test_is_a_class_property_getter(self): self.assertFalse(Attributes.is_a_class_property_getter([])) self.assertFalse(Attributes.is_a_class_property_getter( ['Property.Get(PropertyName)'])) self.assertFalse(Attributes.is_a_class_property_getter( ['Property.Set(PropertyName)'])) self.assertFalse(Attributes.is_a_class_property_getter( ['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertFalse(Attributes.is_a_class_property_getter( ['Class.StaticMethod(ServiceName.ClassName,MethodName)'])) self.assertTrue(Attributes.is_a_class_property_getter( ['Class.Property.Get(ServiceName.ClassName,PropertyName)'])) self.assertFalse(Attributes.is_a_class_property_getter( ['Class.Property.Set(ServiceName.ClassName,PropertyName)']))
def __init__(self, service_name, class_name, name, parameters, documentation, return_type=None, return_is_nullable=False): super(ClassStaticMethod, self).__init__() name = Attributes.get_class_member_name(name) self.service_name = service_name self.class_name = class_name self.name = name self.fullname = service_name+'.'+class_name+'.'+name if return_type is not None: self.return_type = as_type(self.types, return_type) else: self.return_type = None self.return_is_nullable = return_is_nullable self.parameters = [Parameter(documentation=documentation, **info) for info in parameters] self.documentation = documentation self.cref = 'M:%s.%s.%s' % (service_name, class_name, name)
def __init__(self, name, procedures, classes, enumerations, documentation, sort): super(Service, self).__init__() self.name = name self.fullname = name self.documentation = documentation self.cref = 'T:%s' % name members = [] cprocedures = defaultdict(dict) properties = defaultdict(dict) for pname, info in procedures.iteritems(): if Attributes.is_a_procedure(info['attributes']): members.append(Procedure(name, pname, **info)) elif Attributes.is_a_property_accessor(info['attributes']): propname = Attributes.get_property_name(info['attributes']) if Attributes.is_a_property_getter(info['attributes']): properties[propname]['getter'] = Procedure( name, pname, **info) else: properties[propname]['setter'] = Procedure( name, pname, **info) elif Attributes.is_a_class_member(info['attributes']): cname = Attributes.get_class_name(info['attributes']) cprocedures[cname][pname] = info for propname, prop in properties.iteritems(): members.append(Property(name, propname, **prop)) self.classes = { cname: Class(name, cname, cprocedures[cname], sort=sort, **cinfo) for (cname, cinfo) in classes.iteritems() } self.enumerations = { ename: Enumeration(name, ename, sort=sort, **einfo) for (ename, einfo) in enumerations.iteritems() } self.members = OrderedDict( (member.name, member) for member in sorted(members, key=sort))
def generate_context(self): procedures = {} properties = {} classes = {} enumerations = {} exceptions = {} for name, cls in self._defs['classes'].items(): classes[name] = { 'methods': {}, 'static_methods': {}, 'properties': {}, 'documentation': self.parse_documentation(cls['documentation']) } for name, enumeration in self._defs['enumerations'].items(): enumerations[name] = { 'values': [{ 'name': self.parse_name(x['name']), 'value': x['value'], 'documentation': self.parse_documentation( x['documentation']) } for x in enumeration['values']], 'documentation': self.parse_documentation( enumeration['documentation']) } for name, exception in self._defs['exceptions'].items(): exceptions[name] = { 'documentation': self.parse_documentation( exception['documentation']) } for name, procedure in self._defs['procedures'].items(): if Attributes.is_a_procedure(name): procedures[self.parse_name(name)] = { 'procedure': procedure, 'remote_name': name, 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_property_getter(name): property_name = self.parse_name( Attributes.get_property_name(name)) if property_name not in properties: properties[property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } properties[property_name]['getter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_property_setter(name): property_name = self.parse_name( Attributes.get_property_name(name)) params = self.generate_context_parameters(procedure) if property_name not in properties: properties[property_name] = { 'type': params[0]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } properties[property_name]['setter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_class_method(name): class_name = Attributes.get_class_name(name) method_name = self.parse_name( Attributes.get_class_member_name(name)) params = self.generate_context_parameters(procedure) classes[class_name]['methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'parameters': params[1:], 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_class_static_method(name): class_name = Attributes.get_class_name(name) method_name = self.parse_name( Attributes.get_class_member_name(name)) classes[class_name]['static_methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_class_property_getter(name): class_name = Attributes.get_class_name(name) property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in classes[class_name]['properties']: classes[class_name]['properties'][property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } classes[class_name]['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_class_property_setter(name): class_name = Attributes.get_class_name(name) property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in classes[class_name]['properties']: params = self.generate_context_parameters(procedure) classes[class_name]['properties'][property_name] = { 'type': params[1]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } classes[class_name]['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name } def sort(objs): if isinstance(objs, dict): return collections.OrderedDict( sorted([(x, sort(y)) for x, y in objs.items()], key=lambda x: x[0])) return objs return { 'service_name': self._service, 'procedures': sort(procedures), 'properties': sort(properties), 'classes': sort(classes), 'enumerations': sort(enumerations), 'exceptions': sort(exceptions) }
def generate_context(self): procedures = {} properties = {} classes = {} enumerations = {} for name, cls in self._defs["classes"].items(): classes[name] = { "methods": {}, "static_methods": {}, "properties": {}, "documentation": self.parse_documentation(cls["documentation"]), } for name, enumeration in self._defs["enumerations"].items(): enumerations[name] = { "values": [ { "name": self.parse_name(x["name"]), "value": x["value"], "documentation": self.parse_documentation(x["documentation"]), } for x in enumeration["values"] ], "documentation": self.parse_documentation(enumeration["documentation"]), } for name, procedure in self._defs["procedures"].items(): if Attributes.is_a_procedure(procedure["attributes"]): procedures[self.parse_name(name)] = { "procedure": procedure, "remote_name": name, "parameters": self.generate_context_parameters(procedure), "return_type": self.parse_return_type(procedure), "documentation": self.parse_documentation(procedure["documentation"]), } elif Attributes.is_a_property_getter(procedure["attributes"]): property_name = self.parse_name(Attributes.get_property_name(procedure["attributes"])) if property_name not in properties: properties[property_name] = { "type": self.parse_return_type(procedure), "getter": None, "setter": None, "documentation": self.parse_documentation(procedure["documentation"]), } properties[property_name]["getter"] = {"procedure": procedure, "remote_name": name} elif Attributes.is_a_property_setter(procedure["attributes"]): property_name = self.parse_name(Attributes.get_property_name(procedure["attributes"])) if property_name not in properties: properties[property_name] = { "type": self.generate_context_parameters(procedure)[0]["type"], "getter": None, "setter": None, "documentation": self.parse_documentation(procedure["documentation"]), } properties[property_name]["setter"] = {"procedure": procedure, "remote_name": name} elif Attributes.is_a_class_method(procedure["attributes"]): class_name = Attributes.get_class_name(procedure["attributes"]) method_name = self.parse_name(Attributes.get_class_method_name(procedure["attributes"])) classes[class_name]["methods"][method_name] = { "procedure": procedure, "remote_name": name, "parameters": self.generate_context_parameters(procedure)[1:], "return_type": self.parse_return_type(procedure), "documentation": self.parse_documentation(procedure["documentation"]), } elif Attributes.is_a_class_static_method(procedure["attributes"]): class_name = Attributes.get_class_name(procedure["attributes"]) method_name = self.parse_name(Attributes.get_class_method_name(procedure["attributes"])) classes[class_name]["static_methods"][method_name] = { "procedure": procedure, "remote_name": name, "parameters": self.generate_context_parameters(procedure), "return_type": self.parse_return_type(procedure), "documentation": self.parse_documentation(procedure["documentation"]), } elif Attributes.is_a_class_property_getter(procedure["attributes"]): class_name = Attributes.get_class_name(procedure["attributes"]) property_name = self.parse_name(Attributes.get_class_property_name(procedure["attributes"])) if property_name not in classes[class_name]["properties"]: classes[class_name]["properties"][property_name] = { "type": self.parse_return_type(procedure), "getter": None, "setter": None, "documentation": self.parse_documentation(procedure["documentation"]), } classes[class_name]["properties"][property_name]["getter"] = { "procedure": procedure, "remote_name": name, } elif Attributes.is_a_class_property_setter(procedure["attributes"]): class_name = Attributes.get_class_name(procedure["attributes"]) property_name = self.parse_name(Attributes.get_class_property_name(procedure["attributes"])) if property_name not in classes[class_name]["properties"]: classes[class_name]["properties"][property_name] = { "type": self.generate_context_parameters(procedure)[1]["type"], "getter": None, "setter": None, "documentation": self.parse_documentation(procedure["documentation"]), } classes[class_name]["properties"][property_name]["setter"] = { "procedure": procedure, "remote_name": name, } def sort(d): if type(d) == dict: return collections.OrderedDict(sorted([(x, sort(y)) for x, y in d.items()], key=lambda x: x[0])) else: return d return { "service_name": self._service, "procedures": sort(procedures), "properties": sort(properties), "classes": sort(classes), "enumerations": sort(enumerations), }
def test_get_parameter_type_attributes(self): self.assertEqual([], Attributes.get_parameter_type_attrs(0, [])) self.assertEqual([], Attributes.get_parameter_type_attrs( 0, ['Class.Method(ServiceName.ClassName,MethodName)'])) self.assertEqual([], Attributes.get_parameter_type_attrs( 0, ['ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual([], Attributes.get_parameter_type_attrs( 0, ['Class.Method(ServiceName.ClassName,MethodName)', 'ReturnType.Class(ServiceName.ClassName)'])) self.assertEqual([], Attributes.get_parameter_type_attrs( 1, ['ParameterType(2).Class(ServiceName.ClassName)'])) self.assertEqual(['Class(ServiceName.ClassName)'], Attributes.get_parameter_type_attrs( 2, ['ParameterType(2).Class(ServiceName.ClassName)'])) self.assertEqual(['Class(ServiceName.ClassName2)'], Attributes.get_parameter_type_attrs( 2, ['ParameterType(0).Class(ServiceName.ClassName1)', 'ParameterType(2).Class(ServiceName.ClassName2)'])) self.assertEqual(['Class(ServiceName.ClassName)'], Attributes.get_parameter_type_attrs( 1, ['Class.Method(ServiceName.ClassName,MethodName)', 'ParameterType(1).Class(ServiceName.ClassName)'])) self.assertEqual(['List(string)'], Attributes.get_parameter_type_attrs( 1, ['ParameterType(1).List(string)'])) self.assertEqual(['Dictionary(int32,string)'], Attributes.get_parameter_type_attrs( 1, ['ParameterType(1).Dictionary(int32,string)'])) self.assertEqual(['Set(string)'], Attributes.get_parameter_type_attrs( 1, ['ParameterType(1).Set(string)'])) self.assertEqual(['List(Dictionary(int32,string))'], Attributes.get_parameter_type_attrs( 1, ['ParameterType(1).List(Dictionary(int32,string))'])) self.assertEqual(['Dictionary(int32,List(ServiceName.ClassName))'], Attributes.get_parameter_type_attrs( 1, ['ParameterType(1).Dictionary(int32,List(ServiceName.ClassName))']))
def generate_context(self): context = { 'service_name': self._service, 'service_id': self._defs['id'], 'procedures': {}, 'properties': {}, 'classes': {}, 'enumerations': {}, 'exceptions': {} } for name, cls in self._get_defs('classes'): context['classes'][name] = { 'methods': {}, 'static_methods': {}, 'properties': {}, 'documentation': self.parse_documentation(cls['documentation']) } for name, enumeration in self._get_defs('enumerations'): context['enumerations'][name] = { 'values': [{ 'name': self.parse_name(x['name']), 'value': x['value'], 'documentation': self.parse_documentation(x['documentation']) } for x in enumeration['values']], 'documentation': self.parse_documentation(enumeration['documentation']) } for name, exception in self._get_defs('exceptions'): context['exceptions'][name] = { 'documentation': self.parse_documentation(exception['documentation']) } for name, procedure in self._get_defs('procedures'): if Attributes.is_a_procedure(name): context['procedures'][self.parse_name(name)] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type(self.get_return_type(procedure)), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_property_getter(name): property_name = self.parse_name( Attributes.get_property_name(name)) if property_name not in context['properties']: context['properties'][property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } context['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_property_setter(name): property_name = self.parse_name( Attributes.get_property_name(name)) params = self.generate_context_parameters(procedure) if property_name not in context['properties']: context['properties'][property_name] = { 'type': params[0]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } context['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_class_method(name): class_name = Attributes.get_class_name(name) method_name = self.parse_name( Attributes.get_class_member_name(name)) params = self.generate_context_parameters(procedure) context['classes'][class_name]['methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': params[1:], 'return_type': self.parse_return_type(self.get_return_type(procedure)), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_class_static_method(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] method_name = self.parse_name( Attributes.get_class_member_name(name)) cls['static_methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type(self.get_return_type(procedure)), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_class_property_getter(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in cls['properties']: cls['properties'][property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } cls['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_class_property_setter(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in cls['properties']: params = self.generate_context_parameters(procedure) cls['properties'][property_name] = { 'type': params[1]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } cls['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } # Sort the context def sort_dict(x): return collections.OrderedDict( sorted(x.items(), key=lambda x: x[0])) context['procedures'] = sort_dict(context['procedures']) context['properties'] = sort_dict(context['properties']) context['enumerations'] = sort_dict(context['enumerations']) context['classes'] = sort_dict(context['classes']) context['exceptions'] = sort_dict(context['exceptions']) for cls in context['classes'].values(): cls['methods'] = sort_dict(cls['methods']) cls['static_methods'] = sort_dict(cls['static_methods']) cls['properties'] = sort_dict(cls['properties']) return context
def generate_context(self): context = { 'service_name': self._service, 'service_id': self._defs['id'], 'procedures': {}, 'properties': {}, 'classes': {}, 'enumerations': {}, 'exceptions': {} } for name, cls in self._get_defs('classes'): context['classes'][name] = { 'methods': {}, 'static_methods': {}, 'properties': {}, 'documentation': self.parse_documentation( cls['documentation']) } for name, enumeration in self._get_defs('enumerations'): context['enumerations'][name] = { 'values': [{ 'name': self.parse_name(x['name']), 'value': x['value'], 'documentation': self.parse_documentation( x['documentation']) } for x in enumeration['values']], 'documentation': self.parse_documentation( enumeration['documentation']) } for name, exception in self._get_defs('exceptions'): context['exceptions'][name] = { 'documentation': self.parse_documentation( exception['documentation']) } for name, procedure in self._get_defs('procedures'): if Attributes.is_a_procedure(name): context['procedures'][self.parse_name(name)] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': self.generate_context_parameters( procedure), 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_property_getter(name): property_name = self.parse_name( Attributes.get_property_name(name)) if property_name not in context['properties']: context['properties'][property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } context['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_property_setter(name): property_name = self.parse_name( Attributes.get_property_name(name)) params = self.generate_context_parameters(procedure) if property_name not in context['properties']: context['properties'][property_name] = { 'type': params[0]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } context['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_class_method(name): class_name = Attributes.get_class_name(name) method_name = self.parse_name( Attributes.get_class_member_name(name)) params = self.generate_context_parameters(procedure) context['classes'][class_name]['methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': params[1:], 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_class_static_method(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] method_name = self.parse_name( Attributes.get_class_member_name(name)) cls['static_methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'], 'parameters': self.generate_context_parameters( procedure), 'return_type': self.parse_return_type( self.get_return_type(procedure)), 'documentation': self.parse_documentation( procedure['documentation']) } elif Attributes.is_a_class_property_getter(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in cls['properties']: cls['properties'][property_name] = { 'type': self.parse_return_type( self.get_return_type(procedure)), 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } cls['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } elif Attributes.is_a_class_property_setter(name): class_name = Attributes.get_class_name(name) cls = context['classes'][class_name] property_name = self.parse_name( Attributes.get_class_member_name(name)) if property_name not in cls['properties']: params = self.generate_context_parameters(procedure) cls['properties'][property_name] = { 'type': params[1]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation( procedure['documentation']) } cls['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name, 'remote_id': procedure['id'] } # Sort the context def sort_dict(x): return collections.OrderedDict( sorted(x.items(), key=lambda x: x[0])) context['procedures'] = sort_dict(context['procedures']) context['properties'] = sort_dict(context['properties']) context['enumerations'] = sort_dict(context['enumerations']) context['classes'] = sort_dict(context['classes']) context['exceptions'] = sort_dict(context['exceptions']) for cls in context['classes'].values(): cls['methods'] = sort_dict(cls['methods']) cls['static_methods'] = sort_dict(cls['static_methods']) cls['properties'] = sort_dict(cls['properties']) return context
def generate_context(self): procedures = {} properties = {} classes = {} enumerations = {} for name,cls in self._defs['classes'].items(): classes[name] = { 'methods': {}, 'static_methods': {}, 'properties': {}, 'documentation': self.parse_documentation(cls['documentation']) } for name,enumeration in self._defs['enumerations'].items(): enumerations[name] = { 'values': [{ 'name': self.parse_name(x['name']), 'value': x['value'], 'documentation': self.parse_documentation(x['documentation']) } for x in enumeration['values']], 'documentation': self.parse_documentation(enumeration['documentation']) } for name,procedure in self._defs['procedures'].items(): if Attributes.is_a_procedure(procedure['attributes']): procedures[self.parse_name(name)] = { 'procedure': procedure, 'remote_name': name, 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type(procedure), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_property_getter(procedure['attributes']): property_name = self.parse_name(Attributes.get_property_name(procedure['attributes'])) if property_name not in properties: properties[property_name] = { 'type': self.parse_return_type(procedure), 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } properties[property_name]['getter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_property_setter(procedure['attributes']): property_name = self.parse_name(Attributes.get_property_name(procedure['attributes'])) if property_name not in properties: properties[property_name] = { 'type': self.generate_context_parameters(procedure)[0]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } properties[property_name]['setter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_class_method(procedure['attributes']): class_name = Attributes.get_class_name(procedure['attributes']) method_name = self.parse_name(Attributes.get_class_method_name(procedure['attributes'])) classes[class_name]['methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'parameters': self.generate_context_parameters(procedure)[1:], 'return_type': self.parse_return_type(procedure), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_class_static_method(procedure['attributes']): class_name = Attributes.get_class_name(procedure['attributes']) method_name = self.parse_name(Attributes.get_class_method_name(procedure['attributes'])) classes[class_name]['static_methods'][method_name] = { 'procedure': procedure, 'remote_name': name, 'parameters': self.generate_context_parameters(procedure), 'return_type': self.parse_return_type(procedure), 'documentation': self.parse_documentation(procedure['documentation']) } elif Attributes.is_a_class_property_getter(procedure['attributes']): class_name = Attributes.get_class_name(procedure['attributes']) property_name = self.parse_name(Attributes.get_class_property_name(procedure['attributes'])) if property_name not in classes[class_name]['properties']: classes[class_name]['properties'][property_name] = { 'type': self.parse_return_type(procedure), 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } classes[class_name]['properties'][property_name]['getter'] = { 'procedure': procedure, 'remote_name': name } elif Attributes.is_a_class_property_setter(procedure['attributes']): class_name = Attributes.get_class_name(procedure['attributes']) property_name = self.parse_name(Attributes.get_class_property_name(procedure['attributes'])) if property_name not in classes[class_name]['properties']: classes[class_name]['properties'][property_name] = { 'type': self.generate_context_parameters(procedure)[1]['type'], 'getter': None, 'setter': None, 'documentation': self.parse_documentation(procedure['documentation']) } classes[class_name]['properties'][property_name]['setter'] = { 'procedure': procedure, 'remote_name': name } def sort(d): if type(d) == dict: return collections.OrderedDict(sorted([(x,sort(y)) for x,y in d.items()], key=lambda x: x[0])) else: return d return { 'service_name': self._service, 'procedures': sort(procedures), 'properties': sort(properties), 'classes': sort(classes), 'enumerations': sort(enumerations) }
def create_service(client, service): """ Create a new service type """ cls = type( str(service.name), (ServiceBase,), { '_client': client, '_name': service.name, '__doc__': _parse_documentation(service.documentation) } ) # Add class types to service for cls2 in service.classes: cls._add_service_class(cls2) # Add enumeration types to service for enum in service.enumerations: cls._add_service_enumeration(enum) # Add procedures for procedure in service.procedures: if Attributes.is_a_procedure(procedure.attributes): cls._add_service_procedure(procedure) # Add properties properties = defaultdict(lambda: [None, None]) for procedure in service.procedures: if Attributes.is_a_property_accessor(procedure.attributes): name = Attributes.get_property_name(procedure.attributes) if Attributes.is_a_property_getter(procedure.attributes): properties[name][0] = procedure else: properties[name][1] = procedure for name, procedures in properties.items(): cls._add_service_property(name, procedures[0], procedures[1]) # Add class methods for procedure in service.procedures: if Attributes.is_a_class_method(procedure.attributes): class_name = Attributes.get_class_name(procedure.attributes) method_name = Attributes.get_class_method_name(procedure.attributes) cls._add_service_class_method(class_name, method_name, procedure) # Add static class methods for procedure in service.procedures: if Attributes.is_a_class_static_method(procedure.attributes): class_name = Attributes.get_class_name(procedure.attributes) method_name = Attributes.get_class_method_name(procedure.attributes) cls._add_service_class_static_method(class_name, method_name, procedure) # Add class properties properties = defaultdict(lambda: [None, None]) for procedure in service.procedures: if Attributes.is_a_class_property_accessor(procedure.attributes): class_name = Attributes.get_class_name(procedure.attributes) property_name = Attributes.get_class_property_name(procedure.attributes) key = (class_name, property_name) if Attributes.is_a_class_property_getter(procedure.attributes): properties[key][0] = procedure else: properties[key][1] = procedure for (class_name, property_name), procedures in properties.items(): cls._add_service_class_property(class_name, property_name, procedures[0], procedures[1]) return cls()
def create_service(client, service): """ Create a new service type """ cls = type( str(service.name), (ServiceBase,), { '_client': client, '_name': service.name, '__doc__': _parse_documentation(service.documentation) } ) # Add class types to service for cls2 in service.classes: cls._add_service_class(cls2) # Add enumeration types to service for enumeration in service.enumerations: cls._add_service_enumeration(enumeration) # Add exception types to service for exception in service.exceptions: cls._add_service_exception(exception) # Add procedures for procedure in service.procedures: if Attributes.is_a_procedure(procedure.name): cls._add_service_procedure(procedure) # Add properties properties = defaultdict(lambda: [None, None]) for procedure in service.procedures: if Attributes.is_a_property_accessor(procedure.name): name = Attributes.get_property_name(procedure.name) if Attributes.is_a_property_getter(procedure.name): properties[name][0] = procedure else: properties[name][1] = procedure for name, procedures in properties.items(): cls._add_service_property(name, procedures[0], procedures[1]) # Add class methods for procedure in service.procedures: if Attributes.is_a_class_method(procedure.name): class_name = Attributes.get_class_name(procedure.name) method_name = Attributes.get_class_member_name(procedure.name) cls._add_service_class_method(class_name, method_name, procedure) # Add static class methods for procedure in service.procedures: if Attributes.is_a_class_static_method(procedure.name): class_name = Attributes.get_class_name(procedure.name) method_name = Attributes.get_class_member_name(procedure.name) cls._add_service_class_static_method( class_name, method_name, procedure) # Add class properties properties = defaultdict(lambda: [None, None]) for procedure in service.procedures: if Attributes.is_a_class_property_accessor(procedure.name): class_name = Attributes.get_class_name(procedure.name) property_name = Attributes.get_class_member_name(procedure.name) key = (class_name, property_name) if Attributes.is_a_class_property_getter(procedure.name): properties[key][0] = procedure else: properties[key][1] = procedure for (class_name, property_name), procedures in properties.items(): cls._add_service_class_property( class_name, property_name, procedures[0], procedures[1]) return cls()