javonet-ruby-sdk 2.5.17 → 2.5.18

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/deps/lib/perl5/aliased.pm

@@ -0,0 +1,371 @@
+package aliased; # git description: v0.33-3-g0a61221
+# ABSTRACT: Use shorter versions of class names.
+$aliased::VERSION = '0.34';
+require Exporter;
+@EXPORT = qw(alias prefix);
+
+use strict;
+use warnings;
+
+sub _croak {
+    require Carp;
+    Carp::croak(@_);
+}
+
+sub import {
+    # Without args, just export @EXPORT
+    goto &Exporter::import if @_ <= 1;
+
+    my ( $class, $package, $alias, @import ) = @_;
+
+    my $callpack = caller(0);
+    _load_alias( $package, $callpack, @import );
+    _make_alias( $package, $callpack, $alias );
+}
+
+sub _get_alias {
+    my $package = shift;
+    $package =~ s/.*(?:::|')//;
+    return $package;
+}
+
+sub _make_alias {
+    my ( $package, $callpack, $alias ) = @_;
+
+    $alias ||= _get_alias($package);
+
+    my $destination = $alias =~ /::/
+      ? $alias
+      : "$callpack\::$alias";
+
+    # need a scalar not referenced elsewhere to make the sub inlinable
+    my $pack2 = $package;
+
+    no strict 'refs';
+    *{ $destination } = sub () { $pack2 };
+}
+
+sub _load_alias {
+    my ( $package, $callpack, @import ) = @_;
+
+    # We don't localize $SIG{__DIE__} here because we need to be careful about
+    # restoring its value if there is a failure.  Very, very tricky.
+    my $sigdie = $SIG{__DIE__};
+    {
+        my $code =
+          @import == 0
+          ? "package $callpack; use $package;"
+          : "package $callpack; use $package (\@import)";
+        eval $code;
+        if ( my $error = $@ ) {
+            $SIG{__DIE__} = $sigdie;
+            _croak($error);
+        }
+        $sigdie = $SIG{__DIE__}
+          if defined $SIG{__DIE__};
+    }
+
+    # Make sure a global $SIG{__DIE__} makes it out of the localization.
+    $SIG{__DIE__} = $sigdie if defined $sigdie;
+    return $package;
+}
+
+sub alias {
+    my ( $package, @import ) = @_;
+
+    my $callpack = scalar caller(0);
+    return _load_alias( $package, $callpack, @import );
+}
+
+sub prefix {
+    my ($class) = @_;
+    return sub {
+        my ($name) = @_;
+        my $callpack = caller(0);
+        if ( not @_ ) {
+            return _load_alias( $class, $callpack );
+        }
+        elsif ( @_ == 1 && defined $name ) {
+            return _load_alias( "${class}::$name", $callpack );
+        }
+        else {
+            _croak("Too many arguments to prefix('$class')");
+        }
+    };
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+aliased - Use shorter versions of class names.
+
+=head1 VERSION
+
+version 0.34
+
+=head1 SYNOPSIS
+
+  # Class name interface
+  use aliased 'My::Company::Namespace::Customer';
+  my $cust = Customer->new;
+
+  use aliased 'My::Company::Namespace::Preferred::Customer' => 'Preferred';
+  my $pref = Preferred->new;
+
+
+  # Variable interface
+  use aliased;
+  my $Customer  = alias "My::Other::Namespace::Customer";
+  my $cust      = $Customer->new;
+
+  my $Preferred = alias "My::Other::Namespace::Preferred::Customer";
+  my $pref      = $Preferred->new;
+
+=head1 DESCRIPTION
+
+C<aliased> is simple in concept but is a rather handy module.  It loads the
+class you specify and exports into your namespace a subroutine that returns
+the class name.  You can explicitly alias the class to another name or, if you
+prefer, you can do so implicitly.  In the latter case, the name of the
+subroutine is the last part of the class name.  Thus, it does something
+similar to the following:
+
+  #use aliased 'Some::Annoyingly::Long::Module::Name::Customer';
+
+  use Some::Annoyingly::Long::Module::Name::Customer;
+  sub Customer {
+    return 'Some::Annoyingly::Long::Module::Name::Customer';
+  }
+  my $cust = Customer->new;
+
+This module is useful if you prefer a shorter name for a class.  It's also
+handy if a class has been renamed.
+
+(Some may object to the term "aliasing" because we're not aliasing one
+namespace to another, but it's a handy term.  Just keep in mind that this is
+done with a subroutine and not with typeglobs and weird namespace munging.)
+
+Note that this is B<only> for C<use>ing OO modules.  You cannot use this to
+load procedural modules.  See the L<Why OO Only?> section.  Also, don't let
+the version number fool you.  This code is ridiculously simple and is just
+fine for most use.
+
+=head2 Implicit Aliasing
+
+The most common use of this module is:
+
+  use aliased 'Some::Module::name';
+
+C<aliased> will  allow you to reference the class by the last part of the
+class name.  Thus, C<Really::Long::Name> becomes C<Name>.  It does this by
+exporting a subroutine into your namespace with the same name as the aliased
+name.  This subroutine returns the original class name.
+
+For example:
+
+  use aliased "Acme::Company::Customer";
+  my $cust = Customer->find($id);
+
+Note that any class method can be called on the shorter version of the class
+name, not just the constructor.
+
+=head2 Explicit Aliasing
+
+Sometimes two class names can cause a conflict (they both end with C<Customer>
+for example), or you already have a subroutine with the same name as the
+aliased name.  In that case, you can make an explicit alias by stating the
+name you wish to alias to:
+
+  use aliased 'Original::Module::Name' => 'NewName';
+
+Here's how we use C<aliased> to avoid conflicts:
+
+  use aliased "Really::Long::Name";
+  use aliased "Another::Really::Long::Name" => "Aname";
+  my $name  = Name->new;
+  my $aname = Aname->new;
+
+You can even alias to a different package:
+
+  use aliased "Another::Really::Long::Name" => "Another::Name";
+  my $aname = Another::Name->new;
+
+Messing around with different namespaces is a really bad idea and you probably
+don't want to do this.  However, it might prove handy if the module you are
+using has been renamed.  If the interface has not changed, this allows you to
+use the new module by only changing one line of code.
+
+  use aliased "New::Module::Name" => "Old::Module::Name";
+  my $thing = Old::Module::Name->new;
+
+=head2 Import Lists
+
+Sometimes, even with an OO module, you need to specify extra arguments when
+using the module.  When this happens, simply use L<Explicit Aliasing> followed
+by the import list:
+
+Snippet 1:
+
+  use Some::Module::Name qw/foo bar/;
+  my $o = Some::Module::Name->some_class_method;
+
+Snippet 2 (equivalent to snippet 1):
+
+  use aliased 'Some::Module::Name' => 'Name', qw/foo bar/;
+  my $o = Name->some_class_method;
+
+B<Note>:  remember, you cannot use import lists with L<Implicit Aliasing>.  As
+a result, you may simply prefer to only use L<Explicit Aliasing> as a matter
+of style.
+
+=head2 alias()
+
+This function is only exported if you specify C<use aliased> with no import
+list.
+
+    use aliased;
+    my $alias = alias($class);
+    my $alias = alias($class, @imports);
+
+C<alias()> is an alternative to C<use aliased ...> which uses less magic and
+avoids some of the ambiguities.
+
+Like C<use aliased> it C<use>s the C<$class> (pass in C<@imports>, if given)
+but instead of providing an C<Alias> constant it simply returns a scalar set
+to the C<$class> name.
+
+    my $thing = alias("Some::Thing::With::A::Long::Name");
+
+    # Just like Some::Thing::With::A::Long::Name->method
+    $thing->method;
+
+The use of a scalar instead of a constant avoids any possible ambiguity
+when aliasing two similar names:
+
+    # No ambiguity despite the fact that they both end with "Name"
+    my $thing = alias("Some::Thing::With::A::Long::Name");
+    my $other = alias("Some::Other::Thing::With::A::Long::Name");
+
+and there is no magic constant exported into your namespace.
+
+The only caveat is loading of the $class happens at run time.  If C<$class>
+exports anything you might want to ensure it is loaded at compile time with:
+
+    my $thing;
+    BEGIN { $thing = alias("Some::Thing"); }
+
+However, since OO classes rarely export this should not be necessary.
+
+=head2 prefix() (experimental)
+
+This function is only exported if you specify C<use aliased> with no import
+list.
+
+    use aliased;
+
+Sometimes you find you have a ton of packages in the same top-level namespace
+and you want to alias them, but only use them on demand.  For example:
+
+    # instead of:
+    MailVerwaltung::Client::Exception::REST::Response->throw()
+
+    my $error = prefix('MailVerwaltung::Client::Exception');
+    $error->('REST::Response')->throw();   # same as above
+    $error->()->throw; # same as MailVerwaltung::Client::Exception->throw
+
+=head2 Why OO Only?
+
+Some people have asked why this code only support object-oriented modules
+(OO).  If I were to support normal subroutines, I would have to allow the
+following syntax:
+
+  use aliased 'Some::Really::Long::Module::Name';
+  my $data = Name::data();
+
+=for stopwords nilly
+
+That causes a serious problem.  The only (reasonable) way it can be done is to
+handle the aliasing via typeglobs.  Thus, instead of a subroutine that
+provides the class name, we alias one package to another (as the
+L<namespace|namespace> module does.)  However, we really don't want to simply
+alias one package to another and wipe out namespaces willy-nilly.  By merely
+exporting a single subroutine to a namespace, we minimize the issue.
+
+Fortunately, this doesn't seem to be that much of a problem.  Non-OO modules
+generally support exporting of the functions you need and this eliminates the
+need for a module such as this.
+
+=head1 EXPORT
+
+This modules exports a subroutine with the same name as the "aliased" name.
+
+=head1 SEE ALSO
+
+The L<namespace> module.
+
+=head1 THANKS
+
+=for stopwords Rentrak
+
+Many thanks to Rentrak, Inc. (http://www.rentrak.com/) for graciously allowing
+me to replicate the functionality of some of their internal code.
+
+=head1 AUTHOR
+
+Curtis "Ovid" Poe <ovid@cpan.org>
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is copyright (c) 2005 by Curtis "Ovid" Poe.
+
+This is free software; you can redistribute it and/or modify it under
+the same terms as the Perl 5 programming language system itself.
+
+=head1 CONTRIBUTORS
+
+=for stopwords Karen Etheridge Curtis Poe Ovid Florian Ragwitz Grzegorz Rożniecki Father Chrysostomos Belden Lyman Olivier Mengué
+
+=over 4
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Curtis Poe <ovid@cpan.org>
+
+=item *
+
+Ovid <curtis_ovid_poe@yahoo.com>
+
+=item *
+
+Florian Ragwitz <rafl@debian.org>
+
+=item *
+
+Grzegorz Rożniecki <xaerxess@gmail.com>
+
+=item *
+
+Father Chrysostomos <sprout@cpan.org>
+
+=item *
+
+Belden Lyman <belden@shutterstock.com>
+
+=item *
+
+Olivier Mengué <dolmen@cpan.org>
+
+=back
+
+=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Handler/PerlHandler.pm

@@ -29,8 +29,9 @@ use aliased 'Javonet::Sdk::Core::PerlCommandType' => 'PerlCommandType', qw(get_c
 use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
 use aliased 'Javonet::Core::Handler::ReferencesCache' => 'ReferencesCache';
 use aliased 'Javonet::Core::Handler::AbstractHandler' => 'AbstractHandler';
-use aliased 'Javonet::Sdk::Core::RuntimeLib' => 'RuntimeLib', qw(get_runtime);
-use aliased 'Javonet::Core::Handler::HandlerDictionary' => 'HandlerDictionary', qw(get_handler);
+use aliased 'Javonet::Sdk::Core::RuntimeLib' => 'RuntimeLib';
+use aliased 'Javonet::Core::Handler::HandlerDictionary' => 'HandlerDictionary';
+use aliased 'Javonet::Sdk::Core::TypesHandler' => 'TypesHandler';
 
 my $value_handler = ValueHandler->new();
 my $load_library_handler = LoadLibraryHandler->new();
@@ -130,21 +131,14 @@ sub handle_command {
     my ($self, $command) = @_;
     my $response = Javonet::Core::Handler::HandlerDictionary::get_handler($command->{command_type})->handle_command($command);
 
-    if (!defined $response) {
+    if (TypesHandler->is_primitive_or_none($response)) {
         return PerlCommand->new(
             runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
             payload      => [ $response ]
-        )
+        );
     }
 
-    if (ref $response eq '') {
-        return PerlCommand->new(
-            runtime      => Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl'),
-            command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
-            payload      => [ $response ]
-        )
-    }
     # elsif (ref $response eq 'ARRAY') {
     #     {
     #         my $reference_cache = ReferencesCache->new();

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Interpreter/Interpreter.pm

@@ -16,7 +16,7 @@ sub execute_ {
     my $command = shift;
     my $connection_type = shift;
     my $tcp_address = shift;
-    my @serialized_command = Javonet::Core::Protocol::CommandSerializer->encode($command, $connection_type, $tcp_address, 0);
+    my @serialized_command = Javonet::Core::Protocol::CommandSerializer->serialize($command, $connection_type, $tcp_address, 0);
     my $response_byte_array_ref;
     if ($command->{runtime} eq Javonet::Sdk::Core::RuntimeLib::get_runtime('Perl')) {
         require Javonet::Core::Receiver::Receiver;
@@ -37,7 +37,7 @@ sub process {
     my $command = $commandDeserializer->decode();
     my $response = $handler->handle_command($command);
     my $commandSerializer = CommandSerializer->new();
-    my @response_byte_array = $commandSerializer->encode($response, 0, 0, 0);
+    my @response_byte_array = $commandSerializer->serialize($response, 0, 0, 0);
     return @response_byte_array;
 }
 

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Core/Protocol/CommandSerializer.pm

@@ -8,16 +8,17 @@ use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
 use aliased 'Javonet::Sdk::Core::RuntimeLib' => 'RuntimeLib', qw(get_runtime);
 use aliased 'Javonet::Sdk::Core::Type' => 'Type', qw(get_type);
 use aliased 'Javonet::Core::Protocol::TypeSerializer' => 'TypeSerializer';
+use aliased 'Javonet::Sdk::Core::TypesHandler' => 'TypesHandler';
 use Javonet::Sdk::Internal::ConnectionType;
 use Thread::Queue;
 
 use Exporter qw(import);
-our @EXPORT = qw(encode serialize_tcp_address serialize_recursively insert_into_buffer);
+our @EXPORT = qw(serialize serialize_tcp_address serialize_recursively insert_into_buffer);
 
 my @byte_buffer = ();
 my $queue = Thread::Queue->new();
 
-sub encode {
+sub serialize {
     my ($self, $root_command, $connection_type, $tcp_address, $runtimeVersion) = @_;
     @byte_buffer = ();
     $queue = Thread::Queue->new();
@@ -32,10 +33,10 @@ sub encode {
 sub serialize_tcp_address {
     my ($connection_type, $tcp_address) = @_;
     my @tcp_byte_array;
-    if ( Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
+    if (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp') eq $connection_type) {
         my @tcp_array = split(':', $tcp_address);
         my @tcp_ip = split('\\.', $tcp_array[0]);
-        my @bytes_port =  unpack "C*", pack "v",  $tcp_array[1];
+        my @bytes_port = unpack "C*", pack "v", $tcp_array[1];
         @tcp_byte_array = (Javonet::Sdk::Internal::ConnectionType::get_connection_type('Tcp'), @tcp_ip, @bytes_port);
         return @tcp_byte_array;
     }
@@ -45,10 +46,9 @@ sub serialize_tcp_address {
     }
 }
 
-
-sub serialize_recursively{
+sub serialize_recursively {
     my $left = $queue->pending();
-    if ($left == 0){
+    if ($left == 0) {
         return @byte_buffer;
     }
     my $command = $queue->dequeue();
@@ -56,24 +56,25 @@ sub serialize_recursively{
     my $current_payload_ref = $command->{payload};
     my @cur_payload = @$current_payload_ref;
     my $payload_len = @cur_payload;
-    if ($payload_len > 0){
-        if (!defined $cur_payload[0]){
+    if ($payload_len > 0) {
+        if (!defined $cur_payload[0]) {
             insert_into_buffer(TypeSerializer->serializePrimitive(undef));
         }
+        elsif ($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")) {
+            my $inner_command = $cur_payload[0];
+            insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
+            $queue->insert(0, $inner_command);
+        }
+        elsif (TypesHandler->is_primitive_or_none($cur_payload[0])) {
+            my @result = TypeSerializer->serializePrimitive($cur_payload[0]);
+            insert_into_buffer(@result);
+        }
         else {
-            if ($cur_payload[0]->isa("Javonet::Sdk::Core::PerlCommand")) {
-                my $inner_command = $cur_payload[0];
-                insert_into_buffer(TypeSerializer->serializeCommand($inner_command));
-                $queue->insert(0, $inner_command);
-            }
-            else {
-                my @result = TypeSerializer->serializePrimitive($cur_payload[0]);
-                insert_into_buffer(@result);
-            }
+            die "Unsupported payload item type: " . ref($cur_payload[0]) . " for payload item: $cur_payload[0].";
         }
         return serialize_recursively();
     }
-    else{
+    else {
         $queue->dequeue();
     }
     return serialize_recursively();
@@ -85,4 +86,4 @@ sub insert_into_buffer {
 }
 
 no Moose;
-1;
+1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/Type.pm

@@ -18,6 +18,7 @@ my %my_type = (
     'JavonetUnsignedLongLong' => 9,
     'JavonetUnsignedInteger' => 10,
     'JavonetNull' => 11,
+    'JavonetVoid' => 12,
 );
 
 sub get_type {
@@ -27,4 +28,4 @@ sub get_type {
 
 no Moose;
 
-1;
+1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Core/TypesHandler.pm

@@ -0,0 +1,13 @@
+package Javonet::Sdk::Core::TypesHandler;
+use strict;
+use warnings FATAL => 'all';
+use Exporter qw(import);
+our @EXPORT = qw(is_primitive_or_none);
+
+sub is_primitive_or_none {
+    my ($self, $item) = @_;
+    return (!defined $item || $item =~ /^(?:-?\d+(?:\.\d+)?|true|false)$/ || !ref $item);
+}
+
+
+1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/InvocationContext.pm

@@ -7,6 +7,7 @@ use aliased 'Javonet::Sdk::Core::PerlCommand' => 'PerlCommand';
 use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(execute_);
 use aliased 'Javonet::Core::Exception::ExceptionThrower' => 'ExceptionThrower';
+use aliased 'Javonet::Sdk::Core::TypesHandler' => 'TypesHandler';
 
 extends 'Javonet::Sdk::Internal::Abstract::AbstractInstanceContext',
     'Javonet::Sdk::Internal::Abstract::AbstractMethodInvocationContext',
@@ -437,14 +438,17 @@ sub encapsulate_payload_item {
     elsif ($payload_item->isa('Javonet::Sdk::Internal::InvocationContext')) {
         return $payload_item->get_current_command();
     }
-    else {
+    elsif (TypesHandler->is_primitive_or_none($payload_item)) {
         return PerlCommand->new(
             runtime      => $self->{runtime_name},
             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
             payload      => [ $payload_item ]
         );
     }
+    else {
+        die "Unsupported payload item type: " . ref($payload_item) . " for payload item: $payload_item.";
+    }
 }
 
 no Moose;
-1;
+1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/lib/Javonet/Sdk/Internal/RuntimeContext.pm

@@ -8,6 +8,7 @@ use aliased 'Javonet::Sdk::Internal::InvocationContext' => 'InvocationContext';
 use aliased 'Javonet::Core::Handler::PerlHandler' => 'PerlHandler';
 use aliased 'Javonet::Core::Interpreter::Interpreter' => 'Interpreter', qw(execute_);
 use aliased 'Javonet::Core::Exception::ExceptionThrower' => 'ExceptionThrower';
+use aliased 'Javonet::Sdk::Core::TypesHandler' => 'TypesHandler';
 
 extends 'Javonet::Sdk::Internal::Abstract::AbstractRuntimeContext',
     'Javonet::Sdk::Internal::Abstract::AbstractTypeContext';
@@ -267,13 +268,16 @@ sub encapsulate_payload_item {
     elsif ($payload_item->isa('Javonet::Sdk::Internal::InvocationContext')) {
         return $payload_item->get_current_command();
     }
-    else {
+    elsif (TypesHandler->is_primitive_or_none($payload_item)) {
         return PerlCommand->new(
             runtime      => $self->{runtime_name},
             command_type => Javonet::Sdk::Core::PerlCommandType::get_command_type('Value'),
             payload      => [ $payload_item ]
         );
     }
+    else {
+        die "Unsupported payload item type: " . ref($payload_item) . " for payload item: $payload_item.";
+    }
 }
 
 sub health_check {
@@ -289,4 +293,4 @@ sub health_check {
 }
 
 no Moose;
-1;
+1;

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

@@ -31,6 +31,7 @@ from javonet.core.handler.InvokeGlobalFunctionHandler import InvokeGlobalFunctio
 
 from javonet.core.handler.HandlerDictionary import handler_dict
 from javonet.core.referenceCache.ReferencesCache import ReferencesCache
+from javonet.utils.TypesHandler import TypesHandler
 from javonet.utils.exception.ExceptionSerializer import ExceptionSerializer
 from javonet.utils.CommandType import CommandType
 from javonet.utils.Command import Command
@@ -79,22 +80,14 @@ class Handler(AbstractHandler):
         except Exception as e:
             return ExceptionSerializer.serialize_exception(e, command)
 
-    def __parse_response(self, response, runtime_name):
-        if self.__is_response_simple_type(response) or self.__is_response_null(response):
+    @staticmethod
+    def __parse_response(response, runtime_name):
+        if TypesHandler.is_primitive_or_none(response):
             return Command.create_response(response, runtime_name)
         else:
-            reference_cache = ReferencesCache()
-            guid = reference_cache.cache_reference(response)
+            guid = ReferencesCache().cache_reference(response)
             return Command.create_reference(guid, runtime_name)
 
-    @staticmethod
-    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);
+        return isinstance(response, list)

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

@@ -1,7 +1,10 @@
 import io
 from javonet.core.protocol.TypeSerializer import TypeSerializer
+from javonet.core.referenceCache.ReferencesCache import ReferencesCache
 from javonet.utils.Command import Command
+from javonet.utils.CommandType import CommandType
 from javonet.utils.RuntimeName import RuntimeName
+from javonet.utils.TypesHandler import TypesHandler
 from javonet.utils.connectionData.IConnectionData import IConnectionData
 
 class CommandSerializer:
@@ -25,5 +28,10 @@ class CommandSerializer:
             if isinstance(item, Command):
                 ms.write(bytes(TypeSerializer.serialize_command(item)))
                 self.serialize_recursively(item, ms)
+            elif TypesHandler.is_primitive_or_none(item):
+                ms.write(bytes(TypeSerializer.serialize_primitive(item)))
             else:
-                ms.write(bytes(TypeSerializer.serialize_primitive(item)))
+                cached_reference = ReferencesCache().cache_reference(item)
+                ref_command = Command(RuntimeName.python, CommandType.Reference, cached_reference)
+                ms.write(bytes(TypeSerializer.serialize_command(ref_command)))
+                self.serialize_recursively(ref_command, ms)

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

@@ -24,7 +24,7 @@ class TypeSerializer:
         elif isinstance(payload_item, str):
             return TypeSerializer.serialize_string(payload_item)
         else:
-            raise Exception("Python: Type serialization not supported for type: " + payload_item)
+            raise TypeError(f"Unsupported payload item type: {type(payload_item)} for payload item: {payload_item}.")
 
     @staticmethod
     def serialize_command(command):

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/Type.py

@@ -14,3 +14,4 @@ class Type(Enum):
     JavonetUnsignedLongLong = 9
     JavonetUnsignedInteger = 10
     JavonetNoneType = 11
+    JavonetVoidType = 12

data/lib/javonet-ruby-sdk/Binaries/Python/javonet/utils/TypesHandler.py

@@ -0,0 +1,5 @@
+class TypesHandler:
+
+    @staticmethod
+    def is_primitive_or_none(item):
+        return isinstance(item, (int, float, bool, str)) or item is None