From e60c8bd3f722dfb7d51d67413ddcd423f14a8c0c Mon Sep 17 00:00:00 2001 From: TinWoodman92 Date: Tue, 22 Aug 2023 17:16:44 -0500 Subject: Updated to pass vectors --- dialoguer/__init__.py | 124 ++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 99 insertions(+), 25 deletions(-) (limited to 'dialoguer/__init__.py') diff --git a/dialoguer/__init__.py b/dialoguer/__init__.py index 93773fd..977a797 100644 --- a/dialoguer/__init__.py +++ b/dialoguer/__init__.py @@ -18,7 +18,7 @@ server.bind(ADDR) # could there be a defined sub-class that has all the sockets connection functions? # then the dialogue class launches and connects and loops class Dialogue: - def __init__(self, file_name, wait = True): + def __init__(self, file_name, wait = False, clean_elements = True): self.file_name = os.path.basename(file_name) if bool(os.path.dirname(file_name)): self.file_path = file_name @@ -30,7 +30,9 @@ class Dialogue: self.addr = None self.connected = False self.active = False - if wait: + # This attribute will be for + self.clean_elements = clean_elements + if not wait: self.open() def execute_context_script(self): @@ -46,7 +48,8 @@ class Dialogue: while not self.connected: server.listen() self.conn, self.addr = server.accept() - uuid_chk = self.recv() + uuid_chk = self.recv()[0] + recv_chk = self.sub_recv(data_type=bool) self.connected = self.uuid == uuid_chk self.send(self.uuid) if not self.connected: @@ -56,47 +59,118 @@ class Dialogue: self._connect = threading.Thread(target=self.establish_connection) self._launch = threading.Thread(target=self.execute_context_script) - self._connect.start() self._launch.start() + self._connect.start() self._connect.join() - data = self.recv(set_data_type=bool) + data = self.recv(set_data_type=bool)[0] self.active = (data == True) - - def send(self, data, send_data_type = False): - if send_data_type: - data_type_name = type(data) - data_type_name = data_type_name.__name__ - data_type_name = bin_conv(data_type_name) - self.conn.send(data_type_name) - recv_chk = self.recv(set_data_type=bool) + + def sub_send(self, data): bin_data = bin_conv(data) self.conn.send(bin_data) + #need to send as vector or single element + def send(self, data, send_data_type = False, send_length = False, send_element_names = False): + + if send_data_type: + + # we only have 1 data typer per data + if type(data) == list: + if all(type(elem)==type(data[0]) for elem in data): + data_type = type(data[0]) + elif type(data) == dict: + values = list(data.values()) + if all(type(elem)==type(values[0]) for elem in values): + data_type = type(values[0]) + else: + data_type = type(data) + + data_type_name = data_type.__name__ + self.sub_send(data_type_name) + recv_chk = self.sub_recv(data_type=bool) + + if send_length: + if type(data) == list or type(data) == dict: + data_length = len(data) + else: + data_length = 1 + self.sub_send(data_length) + recv_chk = self.sub_recv(data_type=bool) + + # data must be type dict + if send_element_names: + keys = data.keys() + data_names_length = len(keys) + self.sub_send(data_names_length) + recv_chk = self.sub_recv(data_type=bool) + for elem_name in keys: + bin_elem_name = bin_conv(elem_name) + self.conn.send(bin_elem_name) + recv_chk = self.sub_recv(data_type=bool) + + if type(data) == list: + for elem in data: + self.sub_send(elem) + recv_chk = self.sub_recv(data_type=bool) + elif type(data) == dict: + values = list(data.values()) + for elem in values: + self.sub_send(elem) + recv_chk = self.sub_recv(data_type=bool) + else: + self.sub_send(data) + recv_chk = self.sub_recv(data_type=bool) + + def sub_recv(self, data_type = str): + data = self.conn.recv(HEADER) + while data == b'\x00': + data = self.conn.recv(HEADER) + data = bin_conv(data, data_type) + return(data) + # I still want to consolidate the recv_data_type and set_data_type args - def recv(self, recv_data_type = False, set_data_type = str): + def recv(self, recv_data_type = False, set_data_type = str, recv_length = False, recv_element_names = False): + data= [] + data_names = [] if recv_data_type: - data_type_name = self.conn.recv(HEADER) - while data_type_name == b'\x00': - data_type_name = self.conn.recv(HEADER) - data_type_name = bin_conv(data_type_name, str) + data_type_name = self.sub_recv() + self.sub_send(True) data_type = data_type_dict[data_type_name] - self.send(True) else: data_type = set_data_type - data = self.conn.recv(HEADER) - while data == b'\x00': - data = self.conn.recv(HEADER) - data = bin_conv(data, data_type) + if recv_length: + data_length = self.sub_recv(int) + self.sub_send(True) + else: + data_length = 1 + + if recv_element_names: + data_names_length = self.sub_recv(int) + self.sub_send(True) + for _ in range(data_names_length): + elem_name = self.sub_recv() + self.sub_send(True) + data_names.append(elem_name) + else: + data_names_length = 0 + + for _ in range(data_length): + elem = self.sub_recv(data_type) + self.sub_send(True) + data.append(elem) + + if data_length and data_names_length: + data = dict(zip(data_names, data)) return data def import_variable(self, var_name): self.send(1) - recv_chk = self.recv(set_data_type=bool) + recv_chk = self.recv(set_data_type=bool)[0] self.send(var_name, False) - val = self.recv(True) + val = self.recv(True, recv_length=True, recv_element_names=True) return val def assign_variable(self, var_name, var_val): -- cgit v1.2.3