Updated to pass vectors

2 files changed, 163 insertions, 41 deletions

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):
diff --git a/dialoguer/dialoguer.r b/dialoguer/dialoguer.r
index dbfa8e0..461358f 100644
--- a/dialoguer/dialoguer.r
+++ b/dialoguer/dialoguer.r
@@ -23,37 +23,84 @@ dialoguer.display_msg <- function(...) {
     )
 }
 
+dialoguer.sub_send <- function(conn, data) {
+	writeBin(data, conn)
+}
+
 # may not need to pass connection if it will only be 1 per dialogue
-dialoguer.send <- function(conn, data, send_data_type = FALSE) {
+dialoguer.send <- function(conn, data, send_data_type = FALSE, send_length = FALSE, send_element_names = FALSE) {
 	if (send_data_type) {
 		data_type_name <- typeof(data)
-		writeBin(data_type_name, conn)
-		recv_chk <- dialoguer.recv(conn, set_data_type = 'logical')
+		dialoguer.sub_send(conn, data_type_name)
+		recv_chk <- dialoguer.sub_recv(conn, 'logical')
 	}
-	writeBin(data, conn)
+	if (send_length) {
+		data_length <- length(data)
+		dialoguer.sub_send(conn, data_length)
+		recv_chk <- dialoguer.sub_recv(conn, 'logical')
+	}
+	if (send_element_names) {
+		data_names_length <- length(names(data))
+		dialoguer.sub_send(conn, data_names_length)
+		recv_chk <- dialoguer.sub_recv(conn, 'logical')
+		if (data_names_length) {
+			for (elem_name in names(data)) {
+				dialoguer.sub_send(conn, elem_name)
+				recv_chk <- dialoguer.sub_recv(conn, 'logical')
+			}
+		}
+	}
+	for (elem in data) {
+		dialoguer.sub_send(conn, elem)
+		recv_chk <- dialoguer.sub_recv(conn, 'logical')
+	}
+}
+
+dialoguer.sub_recv <- function(conn, data_type = "character") {
+	suppressWarnings(data <- readBin(conn, "raw", dialoguer.HEADER))
+	while (length(data) == 0) {
+		suppressWarnings(data <- readBin(conn, "raw", dialoguer.HEADER))
+	}
+	data <- readBin(data, data_type)
+	return(data)
 }
 
 # may not need to pass connection if it will only be 1 per dialogue
 # I still want to consolidate the recv_data_type and set_data_type args
-dialoguer.recv <- function(conn, recv_data_type = FALSE, set_data_type = "character") {
+dialoguer.recv <- function(conn, recv_data_type = FALSE, set_data_type = "character", recv_length = FALSE, recv_element_names = FALSE) {
 	if (recv_data_type) {
-		suppressWarnings(data_type <- readBin(conn, "raw", dialoguer.HEADER))
-		while (length(data_type) == 0) {
-			suppressWarnings(data_type <- readBin(conn, "raw", dialoguer.HEADER))
-		}
-		data_type <- readBin(data_type, "character")
+		data_type <- dialoguer.sub_recv(conn)
+		dialoguer.sub_send(conn, TRUE)
 		data_type <- dialoguer.data_type_vect[data_type]
-		dialoguer.send(conn, TRUE)
 	} else {
 		data_type <- set_data_type
 	}
 
-	suppressWarnings(data <- readBin(conn, "raw", dialoguer.HEADER))
-	while (length(data) == 0) {
-		suppressWarnings(data <- readBin(conn, "raw", dialoguer.HEADER))
+	if (recv_length) {
+		data_length <- dialoguer.sub_recv(conn, "integer")
+		dialoguer.sub_send(conn, TRUE)
+	} else {
+		data_length <- 1
 	}
 
-	data <- readBin(data, data_type)
+	data <- c()
+	for (i in 1:data_length) {
+		elem <- dialoguer.sub_recv(conn, data_type)
+		dialoguer.sub_send(conn, TRUE)
+		data <- c(data, elem)
+	}
+
+	if (recv_element_names) {
+		data_names_length <- dialoguer.sub_recv(conn, "integer")
+		dialoguer.sub_send(conn, TRUE)
+		elem_names <- c()
+		for (i in 1:data_names_length) {
+			elem_name <- dialoguer.sub_recv(conn)
+			dialoguer.sub_send(conn, TRUE)
+			elem_names <- c(elem_names, elem_name)
+		}
+		names(data) <- elem_names
+	}
 
 	return(data)
 }
@@ -69,6 +116,7 @@ dialoguer.find_connection <- function() {
 		)
 
 		dialoguer.send(conn, dialoguer.UUID)
+		dialoguer.sub_send(conn, TRUE)
 		uuid_chk <- dialoguer.recv(conn)
 		connected <- (dialoguer.UUID == uuid_chk)
 		if (!connected) {
@@ -81,7 +129,7 @@ dialoguer.find_connection <- function() {
 dialoguer.import_variable <- function() {
 	var_name <- dialoguer.recv(dialoguer.con, FALSE, "character")
 	var_val <- get(var_name)
-	dialoguer.send(dialoguer.con, var_val, TRUE)
+	dialoguer.send(dialoguer.con, var_val, TRUE, TRUE, TRUE)
 }
 
 dialoguer.assign_variable <- function() {