updated dialogue handeling

2 files changed, 63 insertions, 35 deletions

diff --git a/dialoguer/__init__.py b/dialoguer/__init__.py
index 6ef61c9..bb8e102 100644
--- a/dialoguer/__init__.py
+++ b/dialoguer/__init__.py
@@ -2,7 +2,11 @@ import os
 import subprocess
 import threading
 import socket
+
+# I want to consolidate the binary_conversion module
+# from .binary_conversion import bin_conv
 from . import binary_conversion
+from .data_type_ref import data_type_dict
 
 HEADER = 2048
 PORT = 6011
@@ -47,8 +51,7 @@ class Dialogue:
 		self._connect.join()
 
 		self.send(self.file_path)
-		data = self.recv()
-		data = binary_conversion.convert_from_binary(data, type('s'))
+		data = self.recv(True)
 		self.active = (data == 'TRUE')
 	
 	def open(self, wait = True):
@@ -56,27 +59,36 @@ class Dialogue:
 		if wait: self._open.run()
 		else: self._open.start()
 
-	# Could I add an optional data_type argument that sends the data type as string?
-	# Would be used for steps for when data_type is expected by R.
-	def send(self, data):
-		# I should probably put this reversal in the convert_to_binary method.
-		bin_data = reversed(data)
-		bin_data = "".join(bin_data)
-		bin_data = binary_conversion.convert_to_binary(bin_data)
+	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 = binary_conversion.convert_to_binary(data_type_name)
+			self.conn.send(data_type_name)
+		bin_data = binary_conversion.convert_to_binary(data)
 		self.conn.send(bin_data)
 
-	# Could add an optional boolean expect_data_type argument that receives data type as string.
-	# should there be an expected data type arg that specifies a known data type?
-	def recv(self):
+	def recv(self, recv_data_type = False, set_data_type = str):
+		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 = binary_conversion.convert_from_binary(data_type_name, str)
+			data_type = data_type_dict[data_type_name]
+		else:
+			data_type = set_data_type
+
 		data = self.conn.recv(HEADER)
 		while data == b'\x00':
-			data = self.conn.recv(HEADER)			
+			data = self.conn.recv(HEADER)
+		
+		data = binary_conversion.convert_from_binary(data, data_type)
+
 		return data
 
 	def import_variable(self, var_name):
-		self.send(var_name)
-		val = self.recv()
-		val = binary_conversion.convert_from_binary(val, type('s'))
+		self.send(var_name, False)
+		val = self.recv(True)
 		return val
 
 	def evaluate_expression(self, expr):
diff --git a/dialoguer/context_script.r b/dialoguer/context_script.r
index 7c2f78a..786fb4a 100644
--- a/dialoguer/context_script.r
+++ b/dialoguer/context_script.r
@@ -11,6 +11,15 @@ con <- socketConnection(
 	open = "a+b"
 )
 
+data_type_vect <- c(
+	character = 'character',
+	str = 'character',
+	integer = 'integer',
+	int = 'integer',
+	logical = 'logical',
+	bool = 'logical'
+)
+
 display_msg <- function(msg) {
     cat(
         '\033[94m',
@@ -54,32 +63,42 @@ convert_to_binary <- function(data) {
 	return(bin_data)
 }
 
-# Add optional data_type argument that sends data_type as string
-send <- function(conn, data) {
-	writeBin(data, conn)
+send <- function(conn, data, send_data_type = FALSE) {
+	if (send_data_type) {
+		data_type_name <- typeof(data)
+		data_type_name <- convert_to_binary(data_type_name)
+		writeBin(data_type_name, conn)
+	}
+	bin_data <- convert_to_binary(data)
+	writeBin(bin_data, conn)
 }
 
 # Add optional expect_data_type argument that will receive and convert data type as string
 # should there be an expected data type arg that specifies a known data type?
-recv <- function(conn, silent = TRUE) {
-	if (silent) {
-		suppressWarnings(data <- readBin(conn, "raw", HEADER))
-		while (length(data) == 0) {
-			suppressWarnings(data <- readBin(conn, "raw", HEADER))
+recv <- function(conn, recv_data_type = FALSE, set_data_type = "character") {
+	if (recv_data_type) {
+		suppressWarnings(data_type_name <- readBin(conn, "raw", HEADER))
+		while (length(data_type_name) == 0) {
+			suppressWarnings(data_type_name <- readBin(conn, "raw", HEADER))
 		}
+		data_type_name <- convert_from_binary(data_type_name, "character")
+		data_type_name <- data_type_vect[data_type_name]
 	} else {
-		data <- readBin(conn, "raw", HEADER)
-		while (length(data) == 0) {
-			cat('ALERT\n')
-			data <- readBin(conn, "raw", HEADER)
-		}
+		data_type_name <- set_data_type
 	}
+
+	suppressWarnings(data <- readBin(conn, "raw", HEADER))
+	while (length(data) == 0) {
+		suppressWarnings(data <- readBin(conn, "raw", HEADER))
+	}
+
+	data <- convert_from_binary(data, data_type_name)
+
 	return(data)
 }
 
 #receive target file path
 file_path <- recv(con)
-file_path <- convert_from_binary(file_path, "character")
 
 #load target file
 # need to learn how to receive path as system argument.
@@ -94,11 +113,8 @@ while (msg != '!DISCONNECT') {
 		# evaluating expressions
 	display_msg(msg)
 	val <- get(msg)
-	val <- as.character(val)
-	val <- convert_to_binary(val)
-	send(con, val)
-	msg <- recv(con)
-	msg <- convert_from_binary(msg, "character")
+	send(con, val, TRUE)
+	msg <- recv(con, FALSE, "character")
 }
 
 close(con)
\ No newline at end of file