javonet-ruby-sdk 2.4.7 → 2.4.9

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/interpreter/Interpreter.py

@@ -3,30 +3,32 @@ from javonet.core.protocol.CommandDeserializer import CommandDeserializer
 from javonet.core.protocol.CommandSerializer import CommandSerializer
 from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.TcpConnectionData import TcpConnectionData
-
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class Interpreter:
-    response = None
 
-    def execute(self, command, connection_type, tcp_connection_data: TcpConnectionData):
+    def execute(self, command, connection_data: IConnectionData):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_type, tcp_connection_data)
-        if (command.runtime_name == RuntimeName.python) & (connection_type == ConnectionType.InMemory):
+        serialized_command = command_serializer.serialize(command, connection_data)
+        response = None
+        if connection_data.connection_type == ConnectionType.WebSocket:
+            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
+            response = WebSocketClient().send_message(connection_data, serialized_command)
+        elif (command.runtime_name == RuntimeName.python) & (connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver
             response = Receiver().SendCommand(serialized_command, len(serialized_command))
         else:
             from javonet.core.transmitter.Transmitter import Transmitter
             response = Transmitter.send_command(serialized_command)
-        command_deserializer = CommandDeserializer(response, len(response))
 
+        command_deserializer = CommandDeserializer(response, len(response))
         return command_deserializer.deserialize()
 
-    def process(self, byte_array, byte_array_len):
+    def process(self, byte_array, byte_array_len, connection_data: IConnectionData):
         command_deserializer = CommandDeserializer(byte_array, byte_array_len)
         received_command = command_deserializer.deserialize()
         python_handler = Handler()
         command_serializer = CommandSerializer()
         response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.serialize(response_command, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, connection_data)
         return encoded_response

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/CommandDeserializer.py

@@ -45,6 +45,7 @@ class CommandDeserializer:
             Type.JavonetDouble: self.read_double,
             Type.JavonetUnsignedLongLong: self.read_ullong,
             Type.JavonetUnsignedInteger: self.read_uint,
+            Type.JavonetNoneType: self.read_none
         }
         return switch.get(type_value, lambda: Exception("Type not supported"))()
 
@@ -136,4 +137,11 @@ class CommandDeserializer:
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
+
+    def read_none(self):
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
     

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/CommandSerializer.py

@@ -1,41 +1,29 @@
-import struct
 from collections import deque
 from typing import Deque
 
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
-from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.TcpConnectionData import TcpConnectionData
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 
 class CommandSerializer:
     byte_buffer = []
 
-    def serialize(self, root_command, connection_type, tcp_connection_data: TcpConnectionData, runtime_version=0):
+    def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
         queue: Deque[Command] = deque()
         queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
-        if connection_type == ConnectionType.Tcp:
-            self.insert_into_buffer([ConnectionType.Tcp.value])
-            self.insert_into_buffer(self.serialize_tcp(tcp_connection_data))
-        else:
-            self.insert_into_buffer([ConnectionType.InMemory.value])
-            self.insert_into_buffer([0, 0, 0, 0, 0, 0])
+        self.insert_into_buffer(connection_data.serialize_connection_data())
         self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
         return self.serialize_recursively(queue)
 
-    @staticmethod
-    def serialize_tcp(tcp_connection_data):
-        if tcp_connection_data is None:
-            raise Exception("tcp_connection_data is not provided")
-        return tcp_connection_data.get_address_bytes() + tcp_connection_data.get_pot_bytes()
-
     @staticmethod
     def serialize_primitive(payload_item):
+        if payload_item is None:
+            return TypeSerializer.serialize_none()
         if isinstance(payload_item, bool):
             return TypeSerializer.serialize_bool(payload_item)
-
         elif isinstance(payload_item, int):
             if payload_item in range(-2 ** 31, 2 ** 31):
                 return TypeSerializer.serialize_int(payload_item)
@@ -43,10 +31,8 @@ class CommandSerializer:
                 return TypeSerializer.serialize_longlong(payload_item)
             else:
                 return TypeSerializer.serialize_ullong(payload_item)
-
         elif isinstance(payload_item, float):
             return TypeSerializer.serialize_double(payload_item)
-
         elif isinstance(payload_item, str):
             return TypeSerializer.serialize_string(payload_item)
         else:

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/TypeDeserializer.py

@@ -58,3 +58,7 @@ class TypeDeserializer:
     @staticmethod
     def deserialize_uint(encoded_unsigned_int):
         return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
+
+    @staticmethod
+    def deserialize_none(encoded_none):
+        return None

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/protocol/TypeSerializer.py

@@ -70,3 +70,7 @@ class TypeSerializer:
         encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
         length = len(encoded_unsigned_int_list)
         return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list
+
+    @staticmethod
+    def serialize_none():
+        return [Type.JavonetNoneType.value, 1, 0]

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/receiver/Receiver.py

@@ -1,13 +1,15 @@
 from javonet.core.interpreter.Interpreter import Interpreter
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 
 
 class Receiver:
 
     def __init__(self):
         self.python_interpreter = Interpreter()
+        self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, messageByteArray, messageByteArrayLen):
-        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))
+        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray), self.connection_data))
 
     def HeartBeat(self, messageByteArray, messageByteArrayLen):
         response_byte_array = bytearray(2)

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/referenceCache/ReferencesCache.py

@@ -2,6 +2,7 @@ import uuid
 import threading
 from javonet.utils.CommandType import CommandType
 
+
 class ReferencesCache(object):
     _instance = None
     references_cache = dict()
@@ -35,4 +36,4 @@ class ReferencesCache(object):
                 del self.references_cache[reference_guid]
                 return 0
             except KeyError:
-                raise Exception("Object not found in references")
+                raise Exception("Object not found in references")

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/transmitter/Transmitter.py

@@ -8,20 +8,8 @@ class Transmitter:
         return TransmitterWrapper.send_command(message)
 
     @staticmethod
-    def __activate(license_key="", proxy_host="", proxy_user_name="", proxy_user_password=""):
-        return TransmitterWrapper.activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
-
-    @staticmethod
-    def activate_with_license_file():
-        return Transmitter.__activate()
-
-    @staticmethod
-    def activate_with_credentials(license_key):
-        return Transmitter.__activate(license_key)
-
-    @staticmethod
-    def activate_with_credentials_and_proxy(license_key, proxy_host, proxy_user_name, proxy_user_password):
-        return Transmitter.__activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
+    def activate(license_key=""):
+        return TransmitterWrapper.activate(license_key, "", "", "")
 
     @staticmethod
     def set_config_source(source_path):

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/core/webSocketClient/WebSocketClient.py

@@ -0,0 +1,32 @@
+import asyncio
+import struct
+from websockets.sync.client import connect
+
+from javonet.utils.connectionData.WsConnectionData import WsConnectionData
+
+
+class WebSocketClient:
+    _instance = None
+    clients = dict()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(WebSocketClient, cls).__new__(cls)
+        return cls._instance
+
+    def add_or_get_client(self, connection_data: WsConnectionData):
+        if connection_data.hostname in self.clients:
+            return self.clients[connection_data.hostname]
+        else:
+            self.clients[connection_data.hostname] = connect(connection_data.hostname)
+            return self.clients[connection_data.hostname]
+
+    def send_message(self, connection_data: WsConnectionData, serialized_command):
+        byte_array = struct.pack("B" * len(serialized_command), *serialized_command)
+        return self.send(connection_data, byte_array)
+
+    def send(self, connection_data: WsConnectionData, byte_array):
+        websocket = self.add_or_get_client(connection_data)
+        websocket.send(byte_array)
+        response = websocket.recv()
+        return response

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/CommandType.py

@@ -38,3 +38,4 @@ class CommandType(Enum):
     GetRefValue = 33
     EnableNamespace = 34
     EnableType = 35
+    CreateNull = 36

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/ConnectionType.py

@@ -4,3 +4,4 @@ from enum import Enum
 class ConnectionType(Enum):
     InMemory = 0
     Tcp = 1
+    WebSocket = 2

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/IConnectionData.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+from javonet.utils.ConnectionType import ConnectionType
+
+
+class IConnectionData(ABC):
+    @property
+    @abstractmethod
+    def connection_type(self):
+        pass
+
+    @property
+    @abstractmethod
+    def hostname(self):
+        pass
+
+    @abstractmethod
+    def serialize_connection_data(self):
+        pass

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/InMemoryConnectionData.py

@@ -0,0 +1,23 @@
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class InMemoryConnectionData(IConnectionData):
+    @property
+    def connection_type(self):
+        return ConnectionType.InMemory
+
+    @property
+    def hostname(self):
+        return ""
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, InMemoryConnectionData)
+
+    def __hash__(self):
+        hash_code = 593727026
+        hash_code = hash_code * -1521134295 + hash(self.connection_type)
+        return hash_code

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/TcpConnectionData.py

@@ -0,0 +1,67 @@
+import hashlib
+import socket
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class TcpConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str, port: int):
+        self._hostname = hostname
+        self._port = port
+        self._ip_address = ""
+        if self._hostname == "localhost":
+            self._ip_address = "127.0.0.1"
+        else:
+            try:
+                self._ip_address = socket.gethostbyname(self._hostname)
+            except socket.gaierror:
+                self._ip_address = ""
+
+    @property
+    def connection_type(self):
+        return ConnectionType.Tcp
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    @property
+    def ip_address(self):
+        return self._ip_address
+
+    @property
+    def port(self):
+        return self._port
+
+    def serialize_connection_data(self):
+        address_bytes = self.__get_address_bytes()
+        port_bytes = self.__get_pot_bytes()
+        return [self.connection_type.value] + address_bytes + port_bytes
+
+    def __get_address_bytes(self):
+        return [int(x) for x in self._ip_address.split(".")]
+
+    def __get_pot_bytes(self):
+        return [self._port & 0xFF, self._port >> 8]
+
+    def __eq__(self, other):
+        if isinstance(other, TcpConnectionData):
+            return self._ip_address == other.ip_address and self._port == other.port
+        return False
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self._ip_address}{self._port}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value
+
+    @port.setter
+    def port(self, value):
+        self._port = value
+
+    @ip_address.setter
+    def ip_address(self, value):
+        self._ip_address = value

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/connectionData/WsConnectionData.py

@@ -0,0 +1,30 @@
+import hashlib
+
+from javonet.utils.ConnectionType import ConnectionType
+from javonet.utils.connectionData.IConnectionData import IConnectionData
+
+
+class WsConnectionData(IConnectionData):
+
+    def __init__(self, hostname: str):
+        self._hostname = hostname
+    @property
+    def connection_type(self):
+        return ConnectionType.WebSocket
+
+    @property
+    def hostname(self):
+        return self._hostname
+
+    def serialize_connection_data(self):
+        return [self.connection_type.value, 0, 0, 0, 0, 0, 0]
+
+    def __eq__(self, other):
+        return isinstance(other, WsConnectionData) and self._hostname == other.hostname
+
+    def __hash__(self):
+        return int(hashlib.sha1(f"{self.hostname}".encode()).hexdigest(), 16)
+
+    @hostname.setter
+    def hostname(self, value):
+        self._hostname = value

data/lib/javonet-ruby-sdk/Binaries/Python/Linux/X64/javonet/utils/exception/ExceptionThrower.py

@@ -55,9 +55,23 @@ class ExceptionThrower:
 
     @staticmethod
     def get_local_stack_trace(stack_trace_classes, stack_trace_methods, stack_trace_lines, stack_trace_files):
-        stack_classes = re.split("\\|", stack_trace_classes)
-        stack_methods = re.split("\\|", stack_trace_methods)
-        stack_lines = re.split("\\|", stack_trace_lines)
-        stack_files = re.split("\\|", stack_trace_files)
+        try:
+            stack_classes = re.split("\\|", stack_trace_classes)
+        except Exception:
+            stack_classes = ""
 
+        try:
+            stack_methods = re.split("\\|", stack_trace_methods)
+        except Exception:
+            stack_methods = ""
+
+        try:
+            stack_lines = re.split("\\|", stack_trace_lines)
+        except Exception:
+            stack_lines = ""
+
+        try:
+            stack_files = re.split("\\|", stack_trace_files)
+        except Exception:
+            stack_files = ""
         return [stack_classes, stack_methods, stack_lines, stack_files]

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/handler/Handler.py

@@ -69,7 +69,7 @@ class Handler(AbstractHandler):
             return ExceptionSerializer.serialize_exception(e, command)
 
     def __parse_response(self, response, runtime_name):
-        if self.__is_response_simple_type(response):
+        if self.__is_response_simple_type(response) or self.__is_response_null(response):
             return Command.create_response(response, runtime_name)
         else:
             reference_cache = ReferencesCache()
@@ -80,6 +80,10 @@ class Handler(AbstractHandler):
     def __is_response_simple_type(response):
         return isinstance(response, (int, float, bool, str))
 
+    @staticmethod
+    def __is_response_null(response):
+        return response is None
+
     @staticmethod
     def __is_response_array(response):
         return isinstance(response, list);

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/interpreter/Interpreter.py

@@ -3,30 +3,32 @@ from javonet.core.protocol.CommandDeserializer import CommandDeserializer
 from javonet.core.protocol.CommandSerializer import CommandSerializer
 from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.TcpConnectionData import TcpConnectionData
-
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class Interpreter:
-    response = None
 
-    def execute(self, command, connection_type, tcp_connection_data: TcpConnectionData):
+    def execute(self, command, connection_data: IConnectionData):
         command_serializer = CommandSerializer()
-        serialized_command = command_serializer.serialize(command, connection_type, tcp_connection_data)
-        if (command.runtime_name == RuntimeName.python) & (connection_type == ConnectionType.InMemory):
+        serialized_command = command_serializer.serialize(command, connection_data)
+        response = None
+        if connection_data.connection_type == ConnectionType.WebSocket:
+            from javonet.core.webSocketClient.WebSocketClient import WebSocketClient
+            response = WebSocketClient().send_message(connection_data, serialized_command)
+        elif (command.runtime_name == RuntimeName.python) & (connection_data.connection_type == ConnectionType.InMemory):
             from javonet.core.receiver.Receiver import Receiver
             response = Receiver().SendCommand(serialized_command, len(serialized_command))
         else:
             from javonet.core.transmitter.Transmitter import Transmitter
             response = Transmitter.send_command(serialized_command)
-        command_deserializer = CommandDeserializer(response, len(response))
 
+        command_deserializer = CommandDeserializer(response, len(response))
         return command_deserializer.deserialize()
 
-    def process(self, byte_array, byte_array_len):
+    def process(self, byte_array, byte_array_len, connection_data: IConnectionData):
         command_deserializer = CommandDeserializer(byte_array, byte_array_len)
         received_command = command_deserializer.deserialize()
         python_handler = Handler()
         command_serializer = CommandSerializer()
         response_command = python_handler.handle_command(received_command)
-        encoded_response = command_serializer.serialize(response_command, 0, "0.0.0.0:0")
+        encoded_response = command_serializer.serialize(response_command, connection_data)
         return encoded_response

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/CommandDeserializer.py

@@ -45,6 +45,7 @@ class CommandDeserializer:
             Type.JavonetDouble: self.read_double,
             Type.JavonetUnsignedLongLong: self.read_ullong,
             Type.JavonetUnsignedInteger: self.read_uint,
+            Type.JavonetNoneType: self.read_none
         }
         return switch.get(type_value, lambda: Exception("Type not supported"))()
 
@@ -136,4 +137,11 @@ class CommandDeserializer:
         p = self.position
         self.position += size
         return TypeDeserializer.deserialize_uint(self.buffer[p:p + size])
+
+    def read_none(self):
+        size = 1
+        self.position += 2
+        p = self.position
+        self.position += size
+        return TypeDeserializer.deserialize_none(self.buffer[p:p + size])
     

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/CommandSerializer.py

@@ -1,41 +1,29 @@
-import struct
 from collections import deque
 from typing import Deque
 
 from javonet.core.protocol.TypeSerializer import TypeSerializer
 from javonet.utils.Command import Command
-from javonet.utils.ConnectionType import ConnectionType
 from javonet.utils.RuntimeName import RuntimeName
-from javonet.utils.TcpConnectionData import TcpConnectionData
+from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 
 class CommandSerializer:
     byte_buffer = []
 
-    def serialize(self, root_command, connection_type, tcp_connection_data: TcpConnectionData, runtime_version=0):
+    def serialize(self, root_command: Command, connection_data: IConnectionData, runtime_version=0):
         queue: Deque[Command] = deque()
         queue.append(root_command)
         self.insert_into_buffer([root_command.runtime_name.value, runtime_version])
-        if connection_type == ConnectionType.Tcp:
-            self.insert_into_buffer([ConnectionType.Tcp.value])
-            self.insert_into_buffer(self.serialize_tcp(tcp_connection_data))
-        else:
-            self.insert_into_buffer([ConnectionType.InMemory.value])
-            self.insert_into_buffer([0, 0, 0, 0, 0, 0])
+        self.insert_into_buffer(connection_data.serialize_connection_data())
         self.insert_into_buffer([RuntimeName.python.value, root_command.command_type.value])
         return self.serialize_recursively(queue)
 
-    @staticmethod
-    def serialize_tcp(tcp_connection_data):
-        if tcp_connection_data is None:
-            raise Exception("tcp_connection_data is not provided")
-        return tcp_connection_data.get_address_bytes() + tcp_connection_data.get_pot_bytes()
-
     @staticmethod
     def serialize_primitive(payload_item):
+        if payload_item is None:
+            return TypeSerializer.serialize_none()
         if isinstance(payload_item, bool):
             return TypeSerializer.serialize_bool(payload_item)
-
         elif isinstance(payload_item, int):
             if payload_item in range(-2 ** 31, 2 ** 31):
                 return TypeSerializer.serialize_int(payload_item)
@@ -43,10 +31,8 @@ class CommandSerializer:
                 return TypeSerializer.serialize_longlong(payload_item)
             else:
                 return TypeSerializer.serialize_ullong(payload_item)
-
         elif isinstance(payload_item, float):
             return TypeSerializer.serialize_double(payload_item)
-
         elif isinstance(payload_item, str):
             return TypeSerializer.serialize_string(payload_item)
         else:

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/TypeDeserializer.py

@@ -58,3 +58,7 @@ class TypeDeserializer:
     @staticmethod
     def deserialize_uint(encoded_unsigned_int):
         return struct.unpack("<I", bytearray(encoded_unsigned_int))[0]
+
+    @staticmethod
+    def deserialize_none(encoded_none):
+        return None

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/protocol/TypeSerializer.py

@@ -70,3 +70,7 @@ class TypeSerializer:
         encoded_unsigned_int_list = list(bytearray(struct.pack("<I", unsigned_int_value)))
         length = len(encoded_unsigned_int_list)
         return [Type.JavonetUnsignedInteger.value, length] + encoded_unsigned_int_list
+
+    @staticmethod
+    def serialize_none():
+        return [Type.JavonetNoneType.value, 1, 0]

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/receiver/Receiver.py

@@ -1,13 +1,15 @@
 from javonet.core.interpreter.Interpreter import Interpreter
+from javonet.utils.connectionData.InMemoryConnectionData import InMemoryConnectionData
 
 
 class Receiver:
 
     def __init__(self):
         self.python_interpreter = Interpreter()
+        self.connection_data = InMemoryConnectionData()
 
     def SendCommand(self, messageByteArray, messageByteArrayLen):
-        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray)))
+        return bytearray(self.python_interpreter.process(messageByteArray, len(messageByteArray), self.connection_data))
 
     def HeartBeat(self, messageByteArray, messageByteArrayLen):
         response_byte_array = bytearray(2)

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/referenceCache/ReferencesCache.py

@@ -2,6 +2,7 @@ import uuid
 import threading
 from javonet.utils.CommandType import CommandType
 
+
 class ReferencesCache(object):
     _instance = None
     references_cache = dict()
@@ -35,4 +36,4 @@ class ReferencesCache(object):
                 del self.references_cache[reference_guid]
                 return 0
             except KeyError:
-                raise Exception("Object not found in references")
+                raise Exception("Object not found in references")

data/lib/javonet-ruby-sdk/Binaries/Python/MacOs/X64/javonet/core/transmitter/Transmitter.py

@@ -8,20 +8,8 @@ class Transmitter:
         return TransmitterWrapper.send_command(message)
 
     @staticmethod
-    def __activate(license_key="", proxy_host="", proxy_user_name="", proxy_user_password=""):
-        return TransmitterWrapper.activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
-
-    @staticmethod
-    def activate_with_license_file():
-        return Transmitter.__activate()
-
-    @staticmethod
-    def activate_with_credentials(license_key):
-        return Transmitter.__activate(license_key)
-
-    @staticmethod
-    def activate_with_credentials_and_proxy(license_key, proxy_host, proxy_user_name, proxy_user_password):
-        return Transmitter.__activate(license_key, proxy_host, proxy_user_name, proxy_user_password)
+    def activate(license_key=""):
+        return TransmitterWrapper.activate(license_key, "", "", "")
 
     @staticmethod
     def set_config_source(source_path):