Merge pull request #1080 from OpenC3/handle_custom_python_classes

Handle custom python classes

Author: jmthomas

openc3/lib/openc3/packets/limits_response.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 # This file implements a class to handle responses to limits state changes.

openc3/lib/openc3/packets/packet_config.rb

@@ -31,6 +31,7 @@
 require 'openc3/packets/parsers/processor_parser'
 require 'openc3/packets/parsers/xtce_parser'
 require 'openc3/packets/parsers/xtce_converter'
+require 'openc3/utilities/python_proxy'
 require 'openc3/conversions'
 require 'openc3/processors'
 require 'nokogiri'
@@ -82,6 +83,9 @@ class PacketConfig
     # defined by that identification.  Telemetry version
     attr_reader :tlm_id_value_hash
 
+    # @return [String] Language of current target (ruby or python)
+    attr_reader :language
+
     COMMAND = "Command"
     TELEMETRY = "Telemetry"
 
@@ -117,7 +121,7 @@ def initialize
     # @param filename [String] The name of the configuration file
     # @param process_target_name [String] The target name. Pass nil when parsing
     #   an xtce file to automatically determine the target name.
-    def process_file(filename, process_target_name)
+    def process_file(filename, process_target_name, language = 'ruby')
       # Handle .xtce files
       extension = File.extname(filename).to_s.downcase
       if extension == ".xtce" or extension == ".xml"
@@ -128,6 +132,7 @@ def process_file(filename, process_target_name)
       # Partial files are included into another file and thus aren't directly processed
       return if File.basename(filename)[0] == '_' # Partials start with underscore
 
+      @language = language
       @converted_type = nil
       @converted_bit_size = nil
       @proc_text = ''
@@ -424,7 +429,7 @@ def process_current_packet(parser, keyword, params)
 
       # Define a processor class that will be called once when a packet is received
       when 'PROCESSOR'
-        ProcessorParser.parse(parser, @current_packet, @current_cmd_or_tlm)
+        ProcessorParser.parse(parser, @current_packet, @current_cmd_or_tlm, @language)
 
       when 'DISABLE_MESSAGES'
         usage = "#{keyword}"
@@ -467,11 +472,19 @@ def process_current_packet(parser, keyword, params)
         usage = "#{keyword} <Accessor class name>"
         parser.verify_num_parameters(1, nil, usage)
         begin
-          klass = OpenC3.require_class(params[0])
-          if params.length > 1
-            @current_packet.accessor = klass.new(@current_packet, *params[1..-1])
+          if @language == 'ruby'
+            klass = OpenC3.require_class(params[0])
+            if params.length > 1
+              @current_packet.accessor = klass.new(@current_packet, *params[1..-1])
+            else
+              @current_packet.accessor = klass.new(@current_packet)
+            end
           else
-            @current_packet.accessor = klass.new(@current_packet)
+            if params.length > 1
+              @current_packet.accessor = PythonProxy.new('Accessor', params[0], @current_packet, *params[1..-1])
+            else
+              @current_packet.accessor = PythonProxy.new('Accessor', params[0], @current_packet)
+            end
           end
         rescue Exception => err
           raise parser.error(err)
@@ -530,13 +543,18 @@ def process_current_item(parser, keyword, params)
         usage = "#{keyword} <conversion class filename> <custom parameters> ..."
         parser.verify_num_parameters(1, nil, usage)
         begin
-          klass = OpenC3.require_class(params[0])
-          conversion = klass.new(*params[1..(params.length - 1)])
-          @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
-          if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
-            msg = "Read Conversion #{params[0]} on item #{@current_item.name} does not specify converted type or bit size"
-            @warnings << msg
-            Logger.instance.warn @warnings[-1]
+          if @language == 'ruby'
+            klass = OpenC3.require_class(params[0])
+            conversion = klass.new(*params[1..(params.length - 1)])
+            @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
+            if klass != ProcessorConversion and (conversion.converted_type.nil? or conversion.converted_bit_size.nil?)
+              msg = "Read Conversion #{params[0]} on item #{@current_item.name} does not specify converted type or bit size"
+              @warnings << msg
+              Logger.instance.warn @warnings[-1]
+            end
+          else
+            conversion = PythonProxy.new('Conversion', params[0], *params[1..(params.length - 1)])
+            @current_item.public_send("#{keyword.downcase}=".to_sym, conversion)
           end
         rescue Exception => err
           raise parser.error(err)
@@ -600,7 +618,7 @@ def process_current_item(parser, keyword, params)
       # Define a response class that will be called when the limits state of the
       # current item changes.
       when 'LIMITS_RESPONSE'
-        LimitsResponseParser.parse(parser, @current_item, @current_cmd_or_tlm)
+        LimitsResponseParser.parse(parser, @current_item, @current_cmd_or_tlm, @language)
 
       # Define a printf style formatting string for the current telemetry item
       when 'FORMAT_STRING'

openc3/lib/openc3/packets/packet_item.rb

@@ -23,6 +23,7 @@
 require 'openc3/packets/structure_item'
 require 'openc3/packets/packet_item_limits'
 require 'openc3/conversions/conversion'
+require 'openc3/utilities/python_proxy'
 require 'openc3/io/json_rpc' # Includes needed as_json code
 
 module OpenC3
@@ -129,7 +130,7 @@ def format_string=(format_string)
 
     def read_conversion=(read_conversion)
       if read_conversion
-        raise ArgumentError, "#{@name}: read_conversion must be a OpenC3::Conversion but is a #{read_conversion.class}" unless OpenC3::Conversion === read_conversion
+        raise ArgumentError, "#{@name}: read_conversion must be a OpenC3::Conversion but is a #{read_conversion.class}" unless OpenC3::Conversion === read_conversion or OpenC3::PythonProxy === read_conversion
 
         @read_conversion = read_conversion.clone
       else
@@ -139,7 +140,7 @@ def read_conversion=(read_conversion)
 
     def write_conversion=(write_conversion)
       if write_conversion
-        raise ArgumentError, "#{@name}: write_conversion must be a OpenC3::Conversion but is a #{write_conversion.class}" unless OpenC3::Conversion === write_conversion
+        raise ArgumentError, "#{@name}: write_conversion must be a OpenC3::Conversion but is a #{write_conversion.class}" unless OpenC3::Conversion === write_conversion or OpenC3::PythonProxy === write_conversion
 
         @write_conversion = write_conversion.clone
       else

openc3/lib/openc3/packets/packet_item_limits.rb

@@ -21,6 +21,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/packets/limits_response'
+require 'openc3/utilities/python_proxy'
 
 module OpenC3
   # Maintains knowledge of limits for a PacketItem
@@ -96,7 +97,7 @@ def state=(state)
 
     def response=(response)
       if response
-        raise ArgumentError, "response must be a OpenC3::LimitsResponse but is a #{response.class}" unless OpenC3::LimitsResponse === response
+        raise ArgumentError, "response must be a OpenC3::LimitsResponse but is a #{response.class}" unless OpenC3::LimitsResponse === response or OpenC3::PythonProxy === response
 
         @response = response.clone
       else

openc3/lib/openc3/packets/parsers/limits_response_parser.rb

@@ -20,20 +20,23 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'openc3/utilities/python_proxy'
+
 module OpenC3
   class LimitsResponseParser
     # @param parser [ConfigParser] Configuration parser
     # @param item [Packet] The current item
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
-    def self.parse(parser, item, cmd_or_tlm)
-      parser = LimitsResponseParser.new(parser)
+    def self.parse(parser, item, cmd_or_tlm, language = 'ruby')
+      parser = LimitsResponseParser.new(parser, language)
       parser.verify_parameters(cmd_or_tlm)
       parser.create_limits_response(item)
     end
 
     # @param parser [ConfigParser] Configuration parser
-    def initialize(parser)
+    def initialize(parser, language = 'ruby')
       @parser = parser
+      @language = language
     end
 
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
@@ -48,12 +51,20 @@ def verify_parameters(cmd_or_tlm)
 
     # @param item [PacketItem] The item the limits response should be added to
     def create_limits_response(item)
-      klass = OpenC3.require_class(@parser.parameters[0])
+      if @language == 'ruby'
+        klass = OpenC3.require_class(@parser.parameters[0])
 
-      if @parser.parameters[1]
-        item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+        if @parser.parameters[1]
+          item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+        else
+          item.limits.response = klass.new
+        end
       else
-        item.limits.response = klass.new
+        if @parser.parameters[1]
+          item.limits.response = PythonProxy.new('LimitsResponse', @parser.parameters[0], *@parser.parameters[1..(@parser.parameters.length - 1)])
+        else
+          item.limits.response = PythonProxy.new('LimitsResponse', @parser.parameters[0], [])
+        end
       end
     rescue Exception => err
       raise @parser.error(err, @usage)

openc3/lib/openc3/packets/parsers/processor_parser.rb

@@ -21,21 +21,23 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/processors'
+require 'openc3/utilities/python_proxy'
 
 module OpenC3
   class ProcessorParser
     # @param parser [ConfigParser] Configuration parser
     # @param packet [Packet] The current packet
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
-    def self.parse(parser, packet, cmd_or_tlm)
-      parser = ProcessorParser.new(parser)
+    def self.parse(parser, packet, cmd_or_tlm, language = 'ruby')
+      parser = ProcessorParser.new(parser, language)
       parser.verify_parameters(cmd_or_tlm)
       parser.create_processor(packet)
     end
 
     # @param parser [ConfigParser] Configuration parser
-    def initialize(parser)
+    def initialize(parser, language = 'ruby')
       @parser = parser
+      @language = language
     end
 
     # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
@@ -50,16 +52,23 @@ def verify_parameters(cmd_or_tlm)
 
     # @param packet [Packet] The packet the processor should be added to
     def create_processor(packet)
-      # require should be performed in target.txt
-      klass = OpenC3.require_class(@parser.parameters[1])
+      if @language == 'ruby'
+        # require should be performed in target.txt
+        klass = OpenC3.require_class(@parser.parameters[1])
 
-      if @parser.parameters[2]
-        processor = klass.new(*@parser.parameters[2..(@parser.parameters.length - 1)])
+        if @parser.parameters[2]
+          processor = klass.new(*@parser.parameters[2..(@parser.parameters.length - 1)])
+        else
+          processor = klass.new
+        end
+        raise ArgumentError, "processor must be a OpenC3::Processor but is a #{processor.class}" unless OpenC3::Processor === processor
       else
-        processor = klass.new
+        if @parser.parameters[2]
+          processor = PythonProxy.new('Processor', @parser.parameters[1], *@parser.parameters[2..(@parser.parameters.length - 1)])
+        else
+          processor = PythonProxy.new('Processor', @parser.parameters[1], [])
+        end
       end
-      raise ArgumentError, "processor must be a OpenC3::Processor but is a #{processor.class}" unless OpenC3::Processor === processor
-
       processor.name = get_processor_name()
       packet.processors[processor.name] = processor
     rescue Exception => err

openc3/lib/openc3/system/system.rb

@@ -179,7 +179,7 @@ def add_target(target_name, target_config_dir)
       @targets[target.name] = target
       errors = [] # Store all errors processing the cmd_tlm files
       target.cmd_tlm_files.each do |cmd_tlm_file|
-        @packet_config.process_file(cmd_tlm_file, target.name)
+        @packet_config.process_file(cmd_tlm_file, target.name, target.language)
       rescue Exception => error
         errors << "Error processing #{cmd_tlm_file}:\n#{error.message}"
       end

openc3/lib/openc3/utilities/python_proxy.rb

@@ -0,0 +1,52 @@
+# encoding: ascii-8bit
+
+# Copyright 2024 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+# TODO: Delegate to actual Python to verify that classes exist
+# and to get proper data from them like converted_type
+
+module OpenC3
+  class PythonProxy
+    attr_accessor :name
+    attr_accessor :args
+
+    def initialize(type, class_name, *params)
+      @type = type
+      @class_name = class_name
+      @params = params
+      @args = params
+      @name = nil
+    end
+
+    def class
+      return @class_name
+    end
+
+    def as_json(*args, **kw_args)
+      case @type
+      when "Processor"
+        return { 'name' => @name, 'class' => @class_name, 'params' => @params }
+      when "Conversion"
+        return { 'class' => @class_name, 'params' => @params }
+      when "LimitsResponse"
+        return { "class" => @class_name, 'params' => @params }
+      else
+        raise "Unknown PythonProxy type: #{@type}"
+      end
+    end
+  end
+end