def __new__(cls, value): """ Create new instance of Tarantool field (single tuple element) """ # Since parent class is immutable, we should # override __new__, not __init__ if isinstance(value, unicode): return super(field, cls).__new__(cls, value.encode("utf-8", "replace")) if sys.version_info.major < 3 and isinstance(value, str): return super(field, cls).__new__(cls, value) if isinstance(value, (bytearray, bytes)): return super(field, cls).__new__(cls, value) if isinstance(value, (int, long)): if 0 <= value <= 0xFFFFFFFF: # 32 bit integer return super(field, cls).__new__(cls, struct_L.pack(value)) elif 0xFFFFFFFF < value <= 0xFFFFFFFFFFFFFFFF: # 64 bit integer return super(field, cls).__new__(cls, struct_Q.pack(value)) else: raise ValueError("Integer argument out of range") # NOTE: It is posible to implement float raise TypeError("Unsupported argument type %s" % (type(value).__name__))
def __init__(self, proc_name, args, return_tuple): flags = 1 if return_tuple else 0 assert isinstance(args, (list, tuple)) # args explicitly casted to string due tarantool bug request_body = \ struct_L.pack(flags) + \ self.pack_field(proc_name) +\ self.pack_tuple(map(str, args)) self._bytes = self.header(len(request_body)) + request_body
def __init__(self, conn, proc_name, args, return_tuple): # pylint: disable=W0231 super(RequestCall, self).__init__(conn) flags = 1 if return_tuple else 0 assert isinstance(args, (list, tuple)) request_body = \ struct_L.pack(flags) + \ self.pack_field(proc_name) +\ self.pack_tuple([k for k in args]) self._bytes = self.header(len(request_body)) + request_body
def __init__(self, conn, space_name, key, op_list, return_tuple): # pylint: disable=W0231 super(RequestUpdate, self).__init__(conn) flags = 1 if return_tuple else 0 assert isinstance(key, (int, basestring)) space_no = self.conn.schema.space_no(space_name) request_body = \ struct_LL.pack(space_no, flags) + \ self.pack_key_tuple((key,), space_no, 0) + \ struct_L.pack(len(op_list)) +\ self.pack_operations(op_list) self._bytes = self.header(len(request_body)) + request_body
def pack_tuple(cls, values): """ Pack tuple of values <tuple> ::= <cardinality><field>+ :param value: tuple to be packed :type value: tuple of scalar values (bytes, str or int) :return: packed tuple :rtype: bytes """ assert isinstance(values, (tuple, list)) cardinality = struct_L.pack(len(values)) packed_items = [cls.pack_field(v) for v in values] packed_items.insert(0, cardinality) return b''.join(packed_items)
def __init__(self, space_no, key, op_list, return_tuple): flags = 1 if return_tuple else 0 if not isinstance(key, (int, bytes, basestring, tuple)): raise TypeError('Unsuppoted key type. Key must be instance ' 'of int, bytes, str or tuple.') if isinstance(key, (int, bytes, basestring)): key = (key, ) request_body = \ struct_LL.pack(space_no, flags) + \ self.pack_tuple(key) + \ struct_L.pack(len(op_list)) +\ self.pack_operations(op_list) self._bytes = self.header(len(request_body)) + request_body
def pack_fields(self, packed_values): '''\ Pack tuple of values <tuple> ::= <cardinality><field>+ :param value: tuple to be packed :type value: tuple of scalar values (bytes, str or int) :return: packed tuple :rtype: bytes ''' assert isinstance(packed_values, (tuple, list)) cardinality = struct_L.pack(len(packed_values)) packed_items = [] packed_items.append(cardinality) for value in packed_values: packed_items.append(self.pack_field(value)) return b"".join(packed_items)