def test_class_types(self):
types = Types()
typ = types.as_type('Class(ServiceName.ClassName)')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertEqual('Class(ServiceName.ClassName)', typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type('Class(ServiceName.ClassName)')
self.assertEqual(typ, typ2)
def test_class_types(self):
types = Types()
typ = types.as_type('Class(ServiceName.ClassName)')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertTrue('Class(ServiceName.ClassName)', typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type('Class(ServiceName.ClassName)')
self.assertEqual(typ, typ2)
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0,1,2), [0,1,2], 'Tuple(int32,int32,int32)'),
([0,1,2], (0,1,2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
self.assertEqual(['foo','bar'], types.coerce_to(['foo','bar'], types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None, types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '', types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True, types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(), types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ["foo",2], types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1], types.as_type('Tuple(string)'))
def test_enumeration_types(self):
types = Types()
typ = types.enumeration_type('ServiceName', 'EnumName',
'enum documentation')
self.assertTrue(isinstance(typ, EnumerationType))
self.assertIsNone(typ.python_type)
self.check_protobuf_type(Type.ENUMERATION, 'ServiceName', 'EnumName',
0, typ.protobuf_type)
typ.set_values({
'a': {
'value': 0,
'doc': 'doca'
},
'b': {
'value': 42,
'doc': 'docb'
},
'c': {
'value': 100,
'doc': 'docc'
}
})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEqual('enum documentation', typ.python_type.__doc__)
self.assertEqual(0, typ.python_type.a.value)
self.assertEqual(42, typ.python_type.b.value)
self.assertEqual(100, typ.python_type.c.value)
self.assertEqual('doca', typ.python_type.a.__doc__)
self.assertEqual('docb', typ.python_type.b.__doc__)
self.assertEqual('docc', typ.python_type.c.__doc__)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def test_value_types(self):
types = Types()
for protobuf_typ in PROTOBUF_VALUE_TYPES:
python_typ = PROTOBUF_TO_PYTHON_VALUE_TYPE[protobuf_typ]
typ = types.as_type(protobuf_typ)
self.assertTrue(isinstance(typ, ValueType))
self.assertEqual(protobuf_typ, typ.protobuf_type)
self.assertEqual(python_typ, typ.python_type)
self.assertRaises(ValueError, ValueType, 'invalid')
def test_value_types(self):
types = Types()
for protobuf_typ in PROTOBUF_VALUE_TYPES:
python_typ = PROTOBUF_TO_PYTHON_VALUE_TYPE[protobuf_typ]
typ = types.as_type(protobuf_typ)
self.assertTrue(isinstance(typ, ValueType))
self.assertEqual(protobuf_typ, typ.protobuf_type)
self.assertEqual(python_typ, typ.python_type)
self.assertRaises(ValueError, ValueType, 'invalid')
def test_tuple_types(self):
types = Types()
typ = types.as_type('Tuple(bool)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(bool)', typ.protobuf_type)
self.assertEqual(1, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertEqual('bool', typ.value_types[0].protobuf_type)
self.assertEqual(bool, typ.value_types[0].python_type)
typ = types.as_type('Tuple(int32,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(int32,string)', typ.protobuf_type)
self.assertEqual(2, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertEqual('int32', typ.value_types[0].protobuf_type)
self.assertEqual('string', typ.value_types[1].protobuf_type)
self.assertEqual(int, typ.value_types[0].python_type)
self.assertEqual(str, typ.value_types[1].python_type)
typ = types.as_type('Tuple(float,int64,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(float,int64,string)', typ.protobuf_type)
self.assertEqual(3, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertTrue(isinstance(typ.value_types[2], ValueType))
self.assertEqual('float', typ.value_types[0].protobuf_type)
self.assertEqual('int64', typ.value_types[1].protobuf_type)
self.assertEqual('string', typ.value_types[2].protobuf_type)
self.assertEqual(float, typ.value_types[0].python_type)
self.assertEqual(long, typ.value_types[1].python_type)
self.assertEqual(str, typ.value_types[2].python_type)
self.assertRaises(ValueError, types.as_type, 'Tuple')
self.assertRaises(ValueError, types.as_type, 'Tuple(')
self.assertRaises(ValueError, types.as_type, 'Tuple()')
self.assertRaises(ValueError, types.as_type, 'Tuple(foo')
self.assertRaises(ValueError, types.as_type, 'Tuple(string,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,string)')
self.assertRaises(ValueError, types.as_type, 'Tuple(int,string))')
def test_tuple_types(self):
types = Types()
typ = types.as_type('Tuple(bool)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(bool)', typ.protobuf_type)
self.assertEqual(1, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertEqual('bool', typ.value_types[0].protobuf_type)
self.assertEqual(bool, typ.value_types[0].python_type)
typ = types.as_type('Tuple(int32,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(int32,string)', typ.protobuf_type)
self.assertEqual(2, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertEqual('int32', typ.value_types[0].protobuf_type)
self.assertEqual('string', typ.value_types[1].protobuf_type)
self.assertEqual(int, typ.value_types[0].python_type)
self.assertEqual(str, typ.value_types[1].python_type)
typ = types.as_type('Tuple(float,int64,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(float,int64,string)', typ.protobuf_type)
self.assertEqual(3, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertTrue(isinstance(typ.value_types[2], ValueType))
self.assertEqual('float', typ.value_types[0].protobuf_type)
self.assertEqual('int64', typ.value_types[1].protobuf_type)
self.assertEqual('string', typ.value_types[2].protobuf_type)
self.assertEqual(float, typ.value_types[0].python_type)
self.assertEqual(long, typ.value_types[1].python_type)
self.assertEqual(str, typ.value_types[2].python_type)
self.assertRaises(ValueError, types.as_type, 'Tuple')
self.assertRaises(ValueError, types.as_type, 'Tuple(')
self.assertRaises(ValueError, types.as_type, 'Tuple()')
self.assertRaises(ValueError, types.as_type, 'Tuple(foo')
self.assertRaises(ValueError, types.as_type, 'Tuple(string,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,string)')
self.assertRaises(ValueError, types.as_type, 'Tuple(int,string))')
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0, 1, 2), [0, 1, 2], 'Tuple(int32,int32,int32)'),
([0, 1, 2], (0, 1, 2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
strings = [
u'foo', u'\xe2\x84\xa2',
u'Mystery Goo\xe2\x84\xa2 Containment Unit'
]
for string in strings:
self.assertEqual(string,
types.coerce_to(string, types.as_type('string')))
self.assertEqual(['foo', 'bar'],
types.coerce_to(['foo', 'bar'],
types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '',
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(),
types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ['foo', 2],
types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1],
types.as_type('Tuple(string)'))
def test_enum_types(self):
types = Types()
typ = types.as_type('Enum(ServiceName.EnumName)')
self.assertTrue(isinstance(typ, EnumType))
self.assertEqual(None, typ.python_type)
self.assertTrue('Enum(ServiceName.EnumName)', typ.protobuf_type)
typ.set_values({'a': 0, 'b': 42, 'c': 100})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEquals(0, typ.python_type.a.value)
self.assertEquals(42, typ.python_type.b.value)
self.assertEquals(100, typ.python_type.c.value)
def test_get_parameter_type(self):
types = Types()
self.assertEqual(float, types.get_parameter_type(0, 'float', []).python_type)
self.assertEqual('int32', types.get_parameter_type(0, 'int32', []).protobuf_type)
self.assertEqual('KRPC.Response', types.get_parameter_type(1, 'KRPC.Response', []).protobuf_type)
class_parameter = types.get_parameter_type(0, 'uint64', ['ParameterType(0).Class(ServiceName.ClassName)'])
self.assertEqual(types.as_type('Class(ServiceName.ClassName)'), class_parameter)
self.assertTrue(isinstance(class_parameter, ClassType))
self.assertTrue(issubclass(class_parameter.python_type, ClassBase))
self.assertEqual('Class(ServiceName.ClassName)', class_parameter.protobuf_type)
self.assertEqual('uint64', types.get_parameter_type(0, 'uint64', ['ParameterType(1).Class(ServiceName.ClassName)']).protobuf_type)
def test_protobuf_enum_types(self):
types = Types()
typ = types.as_type('Test.TestEnum')
self.assertTrue(isinstance(typ, ProtobufEnumType))
self.assertEqual(int, typ.python_type)
self.assertEqual('Test.TestEnum', typ.protobuf_type)
self.assertRaises(ValueError, types.as_type, 'Test.DoesntExist')
self.assertRaises(ValueError, ProtobufEnumType, '')
self.assertRaises(ValueError, ProtobufEnumType, 'invalid')
self.assertRaises(ValueError, ProtobufEnumType, '.')
self.assertRaises(ValueError, ProtobufEnumType, 'foo.bar')
def test_message_types(self):
types = Types()
typ = types.as_type('KRPC.Request')
self.assertTrue(isinstance(typ, MessageType))
self.assertEqual(krpc.schema.KRPC.Request, typ.python_type)
self.assertEqual('KRPC.Request', typ.protobuf_type)
self.assertRaises(ValueError, types.as_type, 'KRPC.DoesntExist')
self.assertRaises(ValueError, MessageType, '')
self.assertRaises(ValueError, MessageType, 'invalid')
self.assertRaises(ValueError, MessageType, '.')
self.assertRaises(ValueError, MessageType, 'foo.bar')
def test_message_types(self):
types = Types()
typ = types.as_type('KRPC.Request')
self.assertTrue(isinstance(typ, MessageType))
self.assertEqual(krpc.schema.KRPC.Request, typ.python_type)
self.assertEqual('KRPC.Request', typ.protobuf_type)
self.assertRaises(ValueError, types.as_type, 'KRPC.DoesntExist')
self.assertRaises(ValueError, MessageType, '')
self.assertRaises(ValueError, MessageType, 'invalid')
self.assertRaises(ValueError, MessageType, '.')
self.assertRaises(ValueError, MessageType, 'foo.bar')
def test_enum_types(self):
types = Types()
typ = types.as_type('Enum(ServiceName.EnumName)')
self.assertTrue(isinstance(typ, EnumType))
self.assertEqual(None, typ.python_type)
self.assertTrue('Enum(ServiceName.EnumName)', typ.protobuf_type)
typ.set_values({'a': 0, 'b': 42, 'c': 100})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEquals(0, typ.python_type.a.value)
self.assertEquals(42, typ.python_type.b.value)
self.assertEquals(100, typ.python_type.c.value)
def test_list_types(self):
types = Types()
typ = types.as_type('List(int32)')
self.assertTrue(isinstance(typ, ListType))
self.assertEqual(typ.python_type, list)
self.assertEqual('List(int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'List')
self.assertRaises(ValueError, types.as_type, 'List(')
self.assertRaises(ValueError, types.as_type, 'List()')
self.assertRaises(ValueError, types.as_type, 'List(foo')
self.assertRaises(ValueError, types.as_type, 'List(int32,string)')
def test_list_types(self):
types = Types()
typ = types.as_type('List(int32)')
self.assertTrue(isinstance(typ, ListType))
self.assertEqual(typ.python_type, list)
self.assertEqual('List(int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'List')
self.assertRaises(ValueError, types.as_type, 'List(')
self.assertRaises(ValueError, types.as_type, 'List()')
self.assertRaises(ValueError, types.as_type, 'List(foo')
self.assertRaises(ValueError, types.as_type, 'List(int32,string)')
def test_class_types(self):
types = Types()
typ = types.class_type(
'ServiceName', 'ClassName', 'class documentation')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertEqual('class documentation', typ.python_type.__doc__)
self.check_protobuf_type(
Type.CLASS, 'ServiceName', 'ClassName', 0, typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def test_class_types(self):
types = Types()
typ = types.class_type('ServiceName', 'ClassName',
'class documentation')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertEqual('class documentation', typ.python_type.__doc__)
self.check_protobuf_type(Type.CLASS, 'ServiceName', 'ClassName', 0,
typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def test_set_types(self):
types = Types()
typ = types.as_type('Set(string)')
self.assertTrue(isinstance(typ, SetType))
self.assertEqual(typ.python_type, set)
self.assertEqual('Set(string)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('string', typ.value_type.protobuf_type)
self.assertEqual(str, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Set')
self.assertRaises(ValueError, types.as_type, 'Set(')
self.assertRaises(ValueError, types.as_type, 'Set()')
self.assertRaises(ValueError, types.as_type, 'Set(string,)')
self.assertRaises(ValueError, types.as_type, 'Set(,)')
self.assertRaises(ValueError, types.as_type, 'Set(,string)')
self.assertRaises(ValueError, types.as_type, 'Set(int,string))')
def test_set_types(self):
types = Types()
typ = types.as_type('Set(string)')
self.assertTrue(isinstance(typ, SetType))
self.assertEqual(typ.python_type, set)
self.assertEqual('Set(string)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('string', typ.value_type.protobuf_type)
self.assertEqual(str, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Set')
self.assertRaises(ValueError, types.as_type, 'Set(')
self.assertRaises(ValueError, types.as_type, 'Set()')
self.assertRaises(ValueError, types.as_type, 'Set(string,)')
self.assertRaises(ValueError, types.as_type, 'Set(,)')
self.assertRaises(ValueError, types.as_type, 'Set(,string)')
self.assertRaises(ValueError, types.as_type, 'Set(int,string))')
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0, 1, 2), [0, 1, 2], 'Tuple(int32,int32,int32)'),
([0, 1, 2], (0, 1, 2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
strings = [
u'foo',
u'\xe2\x84\xa2',
u'Mystery Goo\xe2\x84\xa2 Containment Unit'
]
for string in strings:
self.assertEqual(string, types.coerce_to(string, types.as_type('string')))
self.assertEqual(['foo', 'bar'], types.coerce_to(['foo', 'bar'], types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None, types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '', types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True, types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(), types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ['foo', 2], types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1], types.as_type('Tuple(string)'))
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0, 1, 2), [0, 1, 2], 'Tuple(int32,int32,int32)'),
([0, 1, 2], (0, 1, 2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
self.assertEqual(['foo', 'bar'],
types.coerce_to(['foo', 'bar'],
types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '',
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(),
types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ["foo", 2],
types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1],
types.as_type('Tuple(string)'))
def test_dictionary_types(self):
types = Types()
typ = types.as_type('Dictionary(string,int32)')
self.assertTrue(isinstance(typ, DictionaryType))
self.assertEqual(typ.python_type, dict)
self.assertEqual('Dictionary(string,int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.key_type, ValueType))
self.assertEqual('string', typ.key_type.protobuf_type)
self.assertEqual(str, typ.key_type.python_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Dictionary')
self.assertRaises(ValueError, types.as_type, 'Dictionary(')
self.assertRaises(ValueError, types.as_type, 'Dictionary()')
self.assertRaises(ValueError, types.as_type, 'Dictionary(foo')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(int,string))')
def test_dictionary_types(self):
types = Types()
typ = types.as_type('Dictionary(string,int32)')
self.assertTrue(isinstance(typ, DictionaryType))
self.assertEqual(typ.python_type, dict)
self.assertEqual('Dictionary(string,int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.key_type, ValueType))
self.assertEqual('string', typ.key_type.protobuf_type)
self.assertEqual(str, typ.key_type.python_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Dictionary')
self.assertRaises(ValueError, types.as_type, 'Dictionary(')
self.assertRaises(ValueError, types.as_type, 'Dictionary()')
self.assertRaises(ValueError, types.as_type, 'Dictionary(foo')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(int,string))')
def test_enumeration_types(self):
types = Types()
typ = types.enumeration_type(
'ServiceName', 'EnumName', 'enum documentation')
self.assertTrue(isinstance(typ, EnumerationType))
self.assertIsNone(typ.python_type)
self.check_protobuf_type(
Type.ENUMERATION, 'ServiceName', 'EnumName', 0, typ.protobuf_type)
typ.set_values({
'a': {'value': 0, 'doc': 'doca'},
'b': {'value': 42, 'doc': 'docb'},
'c': {'value': 100, 'doc': 'docc'}
})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEqual('enum documentation', typ.python_type.__doc__)
self.assertEquals(0, typ.python_type.a.value)
self.assertEquals(42, typ.python_type.b.value)
self.assertEquals(100, typ.python_type.c.value)
self.assertEquals('doca', typ.python_type.a.__doc__)
self.assertEquals('docb', typ.python_type.b.__doc__)
self.assertEquals('docc', typ.python_type.c.__doc__)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def test_get_parameter_type(self):
types = Types()
self.assertEqual(float,
types.get_parameter_type(0, 'float', []).python_type)
self.assertEqual(
'int32',
types.get_parameter_type(0, 'int32', []).protobuf_type)
self.assertEqual(
'KRPC.Response',
types.get_parameter_type(1, 'KRPC.Response', []).protobuf_type)
class_parameter = types.get_parameter_type(
0, 'uint64', ['ParameterType(0).Class(ServiceName.ClassName)'])
self.assertEqual(types.as_type('Class(ServiceName.ClassName)'),
class_parameter)
self.assertTrue(isinstance(class_parameter, ClassType))
self.assertTrue(issubclass(class_parameter.python_type, ClassBase))
self.assertEqual('Class(ServiceName.ClassName)',
class_parameter.protobuf_type)
self.assertEqual(
'uint64',
types.get_parameter_type(
0, 'uint64', ['ParameterType(1).Class(ServiceName.ClassName)'
]).protobuf_type)
class Client(object):
"""
A kRPC client, through which all Remote Procedure Calls are made.
Services provided by the server that the client connects to are automatically added.
RPCs can be made using client.ServiceName.ProcedureName(parameter)
"""
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')
# Get the services
services = self._invoke(
'KRPC',
'GetServices',
return_type=self._types.as_type('KRPC.Services')).services
# Set up services
for service in services:
setattr(self, snake_case(service.name),
create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(
target=krpc.stream.update_thread,
args=(stream_connection, self._stream_thread_stop))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def close(self):
self._rpc_connection.close()
if self._stream_thread is not None:
self._stream_thread_stop.set()
self._stream_thread.join()
def __enter__(self):
return self
def __exit__(self, typ, value, traceback):
self.close()
def add_stream(self, func, *args, **kwargs):
if self._stream_connection is None:
raise RuntimeError('Not connected to stream server')
return krpc.stream.add_stream(self, func, *args, **kwargs)
@contextmanager
def stream(self, func, *args, **kwargs):
""" 'with' support """
s = self.add_stream(func, *args, **kwargs)
try:
yield s
finally:
s.remove()
def _invoke(self,
service,
procedure,
args=[],
kwargs={},
param_names=[],
param_types=[],
return_type=None):
""" Execute an RPC """
# Build the request
request = self._build_request(service, procedure, args, kwargs,
param_names, param_types, return_type)
# Send the request
with self._rpc_connection_lock:
self._send_request(request)
response = self._receive_response()
# Check for an error response
if response.has_error:
raise RPCError(response.error)
# Decode the response and return the (optional) result
result = None
if return_type is not None:
result = Decoder.decode(response.return_value, return_type)
return result
def _build_request(self,
service,
procedure,
args=[],
kwargs={},
param_names=[],
param_types=[],
return_type=None):
""" Build a KRPC.Request object """
def encode_argument(i, value):
typ = param_types[i]
if type(value) != typ.python_type:
# Try coercing to the correct type
try:
value = self._types.coerce_to(value, typ)
except ValueError:
raise TypeError('%s.%s() argument %d must be a %s, got a %s' % \
(service, procedure, i, typ.python_type, type(value)))
return Encoder.encode(value, typ)
if len(args) > len(param_types):
raise TypeError('%s.%s() takes exactly %d arguments (%d given)' % \
(service, procedure, len(param_types), len(args)))
arguments = []
nargs = len(args)
for i, param in enumerate(param_names):
add = False
if i < nargs and not isinstance(args[i], DefaultArgument):
arg = args[i]
add = True
elif param in kwargs:
arg = kwargs[param]
add = True
if add:
argument = krpc.schema.KRPC.Argument()
argument.position = i
argument.value = encode_argument(i, arg)
arguments.append(argument)
# Build the request object
request = krpc.schema.KRPC.Request()
request.service = service
request.procedure = procedure
request.arguments.extend(arguments)
return request
def _send_request(self, request):
""" Send a KRPC.Request object to the server """
data = Encoder.encode_delimited(request, self._request_type)
self._rpc_connection.send(data)
def _receive_response(self):
""" Receive data from the server and decode it into a KRPC.Response object """
# Read the size and position of the response message
data = b''
while True:
try:
data += self._rpc_connection.partial_receive(1)
size, position = Decoder.decode_size_and_position(data)
break
except IndexError:
pass
# Read and decode the response message
data = self._rpc_connection.receive(size)
return Decoder.decode(data, self._response_type)
class Client(object):
"""
A kRPC client, through which all Remote Procedure Calls are made.
Services provided by the server that the client connects to are automatically added.
RPCs can be made using client.ServiceName.ProcedureName(parameter)
"""
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._stream_cache = {}
self._stream_cache_lock = threading.Lock()
self._request_type = self._types.as_type('KRPC.Request')
self._response_type = self._types.as_type('KRPC.Response')
# Get the services
services = self._invoke('KRPC', 'GetServices', [], [], [], self._types.as_type('KRPC.Services')).services
# Set up services
for service in services:
setattr(self, snake_case(service.name), create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(target=krpc.stream.update_thread,
args=(stream_connection, self._stream_thread_stop,
self._stream_cache, self._stream_cache_lock))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def close(self):
self._rpc_connection.close()
if self._stream_thread is not None:
self._stream_thread_stop.set()
self._stream_thread.join()
def __enter__(self):
return self
def __exit__(self, typ, value, traceback):
self.close()
def add_stream(self, func, *args, **kwargs):
if self._stream_connection is None:
raise RuntimeError('Not connected to stream server')
return krpc.stream.add_stream(self, func, *args, **kwargs)
@contextmanager
def stream(self, func, *args, **kwargs):
""" 'with' support """
stream = self.add_stream(func, *args, **kwargs)
try:
yield stream
finally:
stream.remove()
def _invoke(self, service, procedure, args, param_names, param_types, return_type):
""" Execute an RPC """
# Build the request
request = self._build_request(service, procedure, args, param_names, param_types, return_type)
# Send the request
with self._rpc_connection_lock:
self._send_request(request)
response = self._receive_response()
# Check for an error response
if response.has_error:
raise RPCError(response.error)
# Decode the response and return the (optional) result
result = None
if return_type is not None:
result = Decoder.decode(response.return_value, return_type)
return result
def _build_request(self, service, procedure, args,
param_names, param_types, return_type): #pylint: disable=unused-argument
""" Build a KRPC.Request object """
request = krpc.schema.KRPC.Request(service=service, procedure=procedure)
for i, (value, typ) in enumerate(itertools.izip(args, param_types)):
if isinstance(value, DefaultArgument):
continue
if not isinstance(value, typ.python_type):
try:
value = self._types.coerce_to(value, typ)
except ValueError:
raise TypeError('%s.%s() argument %d must be a %s, got a %s' % \
(service, procedure, i, typ.python_type, type(value)))
request.arguments.add(position=i, value=Encoder.encode(value, typ))
return request
def _send_request(self, request):
""" Send a KRPC.Request object to the server """
data = Encoder.encode_delimited(request, self._request_type)
self._rpc_connection.send(data)
def _receive_response(self):
""" Receive data from the server and decode it into a KRPC.Response object """
# Read the size and position of the response message
data = b''
while True:
try:
data += self._rpc_connection.partial_receive(1)
size, _ = Decoder.decode_size_and_position(data)
break
except IndexError:
pass
# Read and decode the response message
data = self._rpc_connection.receive(size)
return Decoder.decode(data, self._response_type)
class Client(object):
"""
A kRPC client, through which all Remote Procedure Calls are made.
Services provided by the server that the client connects
to are automatically added. RPCs can be made using
client.ServiceName.ProcedureName(parameter)
"""
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._stream_cache = {}
self._stream_cache_lock = threading.Lock()
self._request_type = self._types.as_type('KRPC.Request')
self._response_type = self._types.as_type('KRPC.Response')
# Get the services
services = self._invoke('KRPC', 'GetServices', [], [], [],
self._types.as_type('KRPC.Services')).services
# Set up services
for service in services:
setattr(self, snake_case(service.name),
create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(
target=krpc.stream.update_thread,
args=(stream_connection, self._stream_thread_stop,
self._stream_cache, self._stream_cache_lock))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def close(self):
self._rpc_connection.close()
if self._stream_thread is not None:
self._stream_thread_stop.set()
self._stream_thread.join()
def __enter__(self):
return self
def __exit__(self, typ, value, traceback):
self.close()
def add_stream(self, func, *args, **kwargs):
if self._stream_connection is None:
raise RuntimeError('Not connected to stream server')
return krpc.stream.add_stream(self, func, *args, **kwargs)
@contextmanager
def stream(self, func, *args, **kwargs):
""" 'with' support """
stream = self.add_stream(func, *args, **kwargs)
try:
yield stream
finally:
stream.remove()
def _invoke(self, service, procedure, args,
param_names, param_types, return_type):
""" Execute an RPC """
# Build the request
request = self._build_request(
service, procedure, args, param_names, param_types, return_type)
# Send the request
with self._rpc_connection_lock:
self._send_request(request)
response = self._receive_response()
# Check for an error response
if response.has_error:
raise RPCError(response.error)
# Decode the response and return the (optional) result
result = None
if return_type is not None:
result = Decoder.decode(response.return_value, return_type)
return result
# pylint: disable=unused-argument
def _build_request(self, service, procedure, args,
param_names, param_types, return_type):
""" Build a KRPC.Request object """
request = KRPC.Request(service=service, procedure=procedure)
for i, (value, typ) in enumerate(itertools.izip(args, param_types)):
if isinstance(value, DefaultArgument):
continue
if not isinstance(value, typ.python_type):
try:
value = self._types.coerce_to(value, typ)
except ValueError:
raise TypeError(
'%s.%s() argument %d must be a %s, got a %s' %
(service, procedure, i, typ.python_type, type(value)))
request.arguments.add(position=i, value=Encoder.encode(value, typ))
return request
def _send_request(self, request):
""" Send a KRPC.Request object to the server """
data = Encoder.encode_delimited(request, self._request_type)
self._rpc_connection.send(data)
def _receive_response(self):
""" Receive data from the server and
decode it into a KRPC.Response object """
# Read the size and position of the response message
data = b''
while True:
try:
data += self._rpc_connection.partial_receive(1)
size, _ = Decoder.decode_size_and_position(data)
break
except IndexError:
pass
# Read and decode the response message
data = self._rpc_connection.receive(size)
return Decoder.decode(data, self._response_type)
class Client(object):
"""
A kRPC client, through which all Remote Procedure Calls are made.
Services provided by the server that the client connects to are automatically added.
RPCs can be made using client.ServiceName.ProcedureName(parameter)
"""
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 close(self):
self._rpc_connection.close()
if self._stream_connection is not None:
self._stream_connection.close()
def __enter__(self):
return self
def __exit__(self, typ, value, traceback):
self.close()
def add_stream(self, func, *args, **kwargs):
if self._stream_connection is None:
raise RuntimeError("Not connected to stream server")
return krpc.stream.add_stream(self, func, *args, **kwargs)
@contextmanager
def stream(self, func, *args, **kwargs):
""" 'with' support """
s = self.add_stream(func, *args, **kwargs)
try:
yield s
finally:
s.remove()
def _invoke(self, service, procedure, args=[], kwargs={}, param_names=[], param_types=[], return_type=None):
""" Execute an RPC """
# Build the request
request = self._build_request(service, procedure, args, kwargs, param_names, param_types, return_type)
# Send the request
with self._rpc_connection_lock:
self._send_request(request)
response = self._receive_response()
# Check for an error response
if response.HasField("error"):
raise RPCError(response.error)
# Decode the response and return the (optional) result
result = None
if return_type is not None:
result = Decoder.decode(response.return_value, return_type)
return result
def _build_request(self, service, procedure, args=[], kwargs={}, param_names=[], param_types=[], return_type=None):
""" Build a KRPC.Request object """
def encode_argument(i, value):
typ = param_types[i]
if type(value) != typ.python_type:
# Try coercing to the correct type
try:
value = self._types.coerce_to(value, typ)
except ValueError:
raise TypeError(
"%s.%s() argument %d must be a %s, got a %s"
% (service, procedure, i, typ.python_type, type(value))
)
return Encoder.encode(value, typ)
if len(args) > len(param_types):
raise TypeError(
"%s.%s() takes exactly %d arguments (%d given)" % (service, procedure, len(param_types), len(args))
)
arguments = []
nargs = len(args)
for i, param in enumerate(param_names):
add = False
if i < nargs and not isinstance(args[i], DefaultArgument):
arg = args[i]
add = True
elif param in kwargs:
arg = args[param]
add = True
if add:
argument = krpc.schema.KRPC.Argument()
argument.position = i
argument.value = encode_argument(i, arg)
arguments.append(argument)
# Build the request object
request = krpc.schema.KRPC.Request()
request.service = service
request.procedure = procedure
request.arguments.extend(arguments)
return request
def _send_request(self, request):
""" Send a KRPC.Request object to the server """
data = Encoder.encode_delimited(request, self._request_type)
self._rpc_connection.send(data)
def _receive_response(self):
""" Receive data from the server and decode it into a KRPC.Response object """
# Read the size and position of the response message
data = b""
while True:
try:
data += self._rpc_connection.partial_receive(1)
size, position = Decoder.decode_size_and_position(data)
break
except IndexError:
pass
# Read and decode the response message
data = self._rpc_connection.receive(size)
return Decoder.decode(data, self._response_type)
