def run(self, script, *args):
# print("run")
if not script or len(script.strip()) == 0:
raise Exception('Empty Script Received', script)
if not self.sessionID:
raise Exception(
'Connection has not been established yet; please call function connect!'
)
"""msg send"""
objs = []
if len(args):
""" function with arguments"""
body = "function\n" + script
body += "\n" + str(len(args)) + "\n"
body += "1" if self.remoteLittleEndian else "0"
message = "API " + self.sessionID + " " + str(
len(body.encode('utf-8'))) + '\n' + body
for arg in args:
objs.append(self.write_python_obj(arg))
else:
"""pure script"""
body = "script\n" + script
message = "API " + self.sessionID + " " + str(
len(body.encode('utf-8'))) + '\n' + body
reconnected = False
try:
# print(message)
# print(objs)
socket_util.sendall(self.socket, message, objs)
except IOError:
reconnected = self._reconnect(message)
"""msg receive"""
header = socket_util.readline(self.socket, self.socketbuffer)
while header == "MSG":
socket_util.read_string(
self.socket, self.socketbuffer
) # python API doesn't support progress listener
header = socket_util.readline(self.socket, self.socketbuffer)
headers = header.split()
if len(headers) != 3:
raise Exception('Header Length Incorrect', header)
if reconnected:
if not self.sessionID == headers[0]:
print(
"old sessionID %s is invalid after reconnection; new sessionID is %s\n"
% (self.sessionID, headers[0]))
self.sessionID = headers[0]
sid, obj_num, _ = headers
msg = socket_util.readline(self.socket, self.socketbuffer)
if msg != 'OK':
raise Exception('Server Exception', msg)
if int(obj_num) == 0:
return None
return self.read_dolphindb_obj
def rpc(self, function_name, *args):
"""
:param function_name: remote function call name
:param args: arguments for remote function
:return: return remote function call result
"""
"""msg send"""
# if len(args):
""" function with arguments"""
body = "function\n" + function_name
body += "\n" + str(len(args)) + "\n"
body += "1" if self.remoteLittleEndian else "0"
message = "API " + self.sessionID + " " + str(len(
body.encode('utf-8'))) + '\n' + body
for arg in args:
message = self.write_python_obj(arg)
# else:
# """pure script"""
# body = "script\n"+function_name
# message = "API "+self.sessionID + " " + str(len(body)) + '\n' + body
#print(message)
reconnected = False
try:
socket_util.sendall(self.socket, message)
except IOError:
reconnected = self._reconnect(message)
"""msg receive"""
header = socket_util.readline(self.socket, self.socketbuffer)
while header == "MSG":
socket_util.read_string(
self.socket, self.socketbuffer
) # python API doesn't support progress listener
header = socket_util.readline(self.socket, self.socketbuffer)
headers = header.split()
if len(headers) != 3:
raise Exception('Header Length Incorrect', header)
if reconnected:
if not self.sessionID == headers[0]:
print(
"old sessionID %s is invalid after reconnection; new sessionID is %s\n"
% (self.sessionID, headers[0]))
self.sessionID = headers[0]
sid, obj_num, _ = headers
msg = socket_util.readline(self.socket, self.socketbuffer)
if msg != 'OK':
raise Exception('Server Exception', msg)
if int(obj_num) == 0:
return None
return self.read_dolphindb_obj
def vec_generator_df(socket, data_type, buffer, nullMap):
row = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
col = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
size = row * col
if data_type in [DT_SYMBOL, DT_STRING]:
return [read_string(socket, buffer) for i in range(size)]
else:
return list(DATA_UNPACKER[data_type](socket, size, buffer, nullMap))
def table_generator(socket, buffer, nullMap):
"""
Generate a pandas data frame from dolphindb table object
:param socket:
:return:
"""
rows = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
cols = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
tableName = read_string(socket, buffer)
""" read column names """
colNameDict = dict()
colNames = []
for i in range(cols):
name = read_string(socket, buffer)
colNameDict[name] = len(colNameDict)
colNames.append(name)
""" read columns and generate a pandas data frame"""
df = pd.DataFrame()
with warnings.catch_warnings():
warnings.simplefilter("ignore")
df.__2xdbColumnTypes__ = dict()
for col in colNames:
data_form, data_type = get_form_type(socket, buffer, nullMap)
# print(data_type)
if data_form != DF_VECTOR:
raise Exception("column " + col + "in table " + tableName +
" must be a vector!")
df[col] = TABLE_GEN_HANDLER.get(data_type,
_default_handler)(data_type, socket,
buffer, nullMap)
# print(df)
if data_type in [DT_BYTE, DT_SHORT]:
data_type = DT_INT
if data_type in [DT_SYMBOL]:
data_type = DT_STRING
if data_type in [DT_FLOAT]:
data_type = DT_DOUBLE
if data_type >= 6 and data_type <= 14:
# TODO: improve datetime transmission
data_type = DT_DATETIME64
df.__2xdbColumnTypes__[col] = data_type
return df
def vec_generator(socket, data_type, buffer, nullMap):
'''
generate a numpy array from a dolphindb vector
:param socket: TCP socket
:param data_type: dolphindb data type
:return: the python corresponding data type
'''
row = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
col = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
size = row * col
if data_type in [DT_SYMBOL, DT_STRING]:
# print("size",size)
"""
while True:
packet = recvall(socket, 4096)
if not packet or not len(packet):
break
data += packet
(data.split('\x00\x00')[0].split('\x00')[:size])
"""
return [read_string(socket, buffer) for i in range(size)]
else:
return list(DATA_UNPACKER[data_type](socket, size, buffer, nullMap))
def table_str_col_generator(socket, buffer, nullMap):
row = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
col = DATA_UNPACKER_SCALAR[DT_INT](socket, buffer, nullMap)
size = row * col
vc = np.array([read_string(socket, buffer) for i in range(size)])
return vc
(recvall(x, DATA_SIZE[DT_TIMESTAMP], y)))[0])
DATA_UNPACKER_SCALAR[DT_NANOTIME] = lambda x, y, nullMap: NanoTime(
Struct(endianness('q')).unpack(recvall(x, DATA_SIZE[DT_NANOTIME], y))[0])
DATA_UNPACKER_SCALAR[DT_NANOTIMESTAMP] = lambda x, y, nullMap: NanoTimestamp(
Struct(endianness('q')).unpack(
(recvall(x, DATA_SIZE[DT_NANOTIMESTAMP], y)))[0])
DATA_UNPACKER_SCALAR[DT_DATETIME64] = lambda x, y, nullMap: NanoTimestamp(
Struct(endianness('q')).unpack(recvall(x, DATA_SIZE[DT_NANOTIMESTAMP], y))[
0])
DATA_UNPACKER_SCALAR[DT_FLOAT] = lambda x, y, nullMap: swap_fromxxdb(
Struct(endianness('f')).unpack(recvall(x, DATA_SIZE[DT_FLOAT], y))[0],
DT_FLOAT, nullMap)
DATA_UNPACKER_SCALAR[DT_DOUBLE] = lambda x, y, nullMap: swap_fromxxdb(
Struct(endianness('d')).unpack(
(recvall(x, DATA_SIZE[DT_DOUBLE], y)))[0], DT_DOUBLE, nullMap)
DATA_UNPACKER_SCALAR[DT_SYMBOL] = lambda x, y, nullMap: read_string(x, y)
DATA_UNPACKER_SCALAR[DT_STRING] = lambda x, y, nullMap: read_string(x, y)
DATA_UNPACKER_SCALAR[DT_ANY] = lambda x, y, nullMap: None
DATA_UNPACKER_SCALAR[DT_DICTIONARY] = lambda x, y, nullMap: None
DATA_UNPACKER_SCALAR[DT_OBJECT] = lambda x, y, nullMap: None
DATA_UNPACKER = dict()
DATA_UNPACKER[DT_VOID] = lambda x, y, z, nullMap: list(
map(lambda z: swap_fromxxdb(z, DT_BOOL, nullMap),
Struct(str(y) + 'b').unpack(recvall(x, DATA_SIZE[DT_BOOL] * y, z))))
DATA_UNPACKER[DT_BOOL] = lambda x, y, z, nullMap: Struct(str(y) + 'b').unpack(
recvall(x, DATA_SIZE[DT_BOOL] * y, z))
DATA_UNPACKER[DT_BYTE] = lambda x, y, z, nullMap: list(
map(lambda z: swap_fromxxdb(z, DT_BYTE, nullMap),
Struct(str(y) + 'b').unpack(recvall(x, DATA_SIZE[DT_BYTE] * y, z))))
DATA_UNPACKER[DT_SHORT] = lambda x, y, z, nullMap: list(
