From f0999a4c7cfcfad534055b0d2040b4c52bd6c5f9 Mon Sep 17 00:00:00 2001 From: TinWoodman92 Date: Mon, 19 Jun 2023 22:14:59 -0500 Subject: updated dialogue handeling --- dialoguer/__init__.py | 44 +++++++++++++++++++++++-------------- dialoguer/context_script.r | 54 ++++++++++++++++++++++++++++++---------------- 2 files changed, 63 insertions(+), 35 deletions(-) (limited to 'dialoguer') 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 -- cgit v1.2.3