openc3 5.11.3 → 5.12.0

data/lib/openc3/packets/limits.rb

@@ -73,21 +73,21 @@ module OpenC3
     # @param packet_name [String] The packet name. Must be a defined packet name and not 'LATEST'.
     # @param item_name [String] The item name
     def enabled?(target_name, packet_name, item_name)
-      get_packet(target_name, packet_name).get_item(item_name).limits.enabled
+      _get_packet(target_name, packet_name).get_item(item_name).limits.enabled
     end
 
     # Enables limit checking for the specified item
     #
     # @param (see #enabled?)
     def enable(target_name, packet_name, item_name)
-      get_packet(target_name, packet_name).enable_limits(item_name)
+      _get_packet(target_name, packet_name).enable_limits(item_name)
     end
 
     # Disables limit checking for the specified item
     #
     # @param (see #enabled?)
     def disable(target_name, packet_name, item_name)
-      get_packet(target_name, packet_name).disable_limits(item_name)
+      _get_packet(target_name, packet_name).disable_limits(item_name)
     end
 
     # Get the limits for a telemetry item
@@ -98,7 +98,7 @@ module OpenC3
     # @param limits_set [String or Symbol or nil] Desired Limits set.  nil = current limits set
     # @return [Array<limits_set, persistence, enabled, red_low, yellow_low, red_high, yellow_high, green_low (optional), green_high (optional)] Limits information
     def get(target_name, packet_name, item_name, limits_set = nil)
-      limits = get_packet(target_name, packet_name).get_item(item_name).limits
+      limits = _get_packet(target_name, packet_name).get_item(item_name).limits
       if limits.values
         if limits_set
           limits_set = limits_set.to_s.upcase.intern
@@ -132,7 +132,7 @@ module OpenC3
     # @param enabled [Boolean] If limits monitoring is enabled for this item
     # @return [Array<limits_set, persistence, enabled, red_low, yellow_low, red_high, yellow_high, green_low (optional), green_high (optional)] Limits information
     def set(target_name, packet_name, item_name, red_low, yellow_low, yellow_high, red_high, green_low = nil, green_high = nil, limits_set = :CUSTOM, persistence = nil, enabled = true)
-      packet = get_packet(target_name, packet_name)
+      packet = _get_packet(target_name, packet_name)
       item = packet.get_item(item_name)
       limits = item.limits
       if limits_set
@@ -172,7 +172,7 @@ module OpenC3
 
     protected
 
-    def get_packet(target_name, packet_name)
+    def _get_packet(target_name, packet_name)
       raise "LATEST packet not valid" if packet_name.upcase == LATEST_PACKET_NAME
 
       packets = @config.telemetry[target_name.to_s.upcase]
@@ -183,17 +183,5 @@ module OpenC3
 
       return packet
     end
-
-    def includes_item?(ignored_items, target_name, packet_name, item_name)
-      ignored_items.each do |array_target_name, array_packet_name, array_item_name|
-        if (array_target_name == target_name) &&
-           (array_packet_name == packet_name) &&
-           # If the item name is nil we're ignoring an entire packet
-           (array_item_name == item_name || array_item_name.nil?)
-          return true
-        end
-      end
-      return false
-    end
   end
 end

data/lib/openc3/packets/packet.rb

@@ -1061,6 +1061,7 @@ module OpenC3
       config['accessor'] = @accessor.class.to_s
       config['accessor_args'] = @accessor.args
       config['template'] = Base64.encode64(@template) if @template
+      config['config_name'] = self.config_name
 
       if @processors
         processors = []

data/lib/openc3/packets/parsers/format_string_parser.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.
 
 module OpenC3
@@ -25,9 +25,9 @@ module OpenC3
     # @param parser [ConfigParser] Configuration parser
     # @param item [Packet] The current item
     def self.parse(parser, item)
-      @parser = FormatStringParser.new(parser)
-      @parser.verify_parameters()
-      @parser.create_format_string(item)
+      parser = FormatStringParser.new(parser)
+      parser.verify_parameters()
+      parser.create_format_string(item)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/packets/parsers/limits_parser.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.
 
 module OpenC3
@@ -31,9 +31,9 @@ module OpenC3
     def self.parse(parser, packet, cmd_or_tlm, item, warnings)
       raise parser.error("Items with STATE can't define LIMITS") if item.states
 
-      @parser = LimitsParser.new(parser)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_limits(packet, item, warnings)
+      parser = LimitsParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_limits(packet, item, warnings)
     end
 
     def initialize(parser)

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

@@ -14,10 +14,10 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, 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.
 
 module OpenC3
@@ -26,9 +26,9 @@ module OpenC3
     # @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)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_limits_response(item)
+      parser = LimitsResponseParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_limits_response(item)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/packets/parsers/processor_parser.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.
 
 require 'openc3/processors'
@@ -28,9 +28,9 @@ module OpenC3
     # @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)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_processor(packet)
+      parser = ProcessorParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_processor(packet)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/packets/parsers/state_parser.rb

@@ -34,9 +34,9 @@ module OpenC3
       raise parser.error("Items with LIMITS can't define STATE") if item.limits.values
       raise parser.error("Items with UNITS can't define STATE") if item.units
 
-      @parser = StateParser.new(parser)
-      @parser.verify_parameters(cmd_or_tlm)
-      @parser.create_state(packet, cmd_or_tlm, item, warnings)
+      parser = StateParser.new(parser)
+      parser.verify_parameters(cmd_or_tlm)
+      parser.create_state(packet, cmd_or_tlm, item, warnings)
     end
 
     # @param parser [ConfigParser] Configuration parser

data/lib/openc3/script/api_shared.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2023, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -140,7 +140,7 @@ module OpenC3
     # Check to see if an expression is true without waiting.  If the expression
     # is not true, the script will pause.
     def check_expression(exp_to_eval, context = nil, scope: $openc3_scope, token: $openc3_token)
-      success = openc3_script_wait_implementation_expression(exp_to_eval, 0, DEFAULT_TLM_POLLING_RATE, context, scope: scope, token: token)
+      success = _openc3_script_wait_implementation_expression(exp_to_eval, 0, DEFAULT_TLM_POLLING_RATE, context, scope: scope, token: token)
       if success
         Logger.info "CHECK: #{exp_to_eval} is TRUE"
       else
@@ -238,7 +238,7 @@ module OpenC3
       if value.is_a?(Array)
         expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_tolerance')
 
-        success, value = openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time = Time.now.sys - start_time
 
         message = ""
@@ -259,7 +259,7 @@ module OpenC3
           Logger.warn message unless quiet
         end
       else
-        success, value = openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time = Time.now.sys - start_time
         range = (expected_value - tolerance)..(expected_value + tolerance)
         wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)}"
@@ -281,7 +281,7 @@ module OpenC3
     # Wait on a custom expression to be true
     def wait_expression(exp_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, context = nil, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
-      success = openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
+      success = _openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: scope, token: token)
       time_diff = Time.now.sys - start_time
       if success
         Logger.info "WAIT: #{exp_to_eval} is TRUE after waiting #{time_diff} seconds" unless quiet
@@ -303,10 +303,13 @@ module OpenC3
     def wait_check(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token, &block)
       target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args)
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
+      success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
       time_diff = Time.now.sys - start_time
-      check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
+      check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
+      if comparison_to_eval
+        check_str += " #{comparison_to_eval}"
+      end
       with_value_str = "with value == #{value} after waiting #{time_diff} seconds"
       if success
         Logger.info "#{check_str} success #{with_value_str}"
@@ -344,7 +347,7 @@ module OpenC3
       if value.is_a?(Array)
         expected_value, tolerance = _array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance')
 
-        success, value = openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
+        success, value = _openc3_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
         time_diff = Time.now.sys - start_time
 
         message = ""
@@ -369,7 +372,7 @@ module OpenC3
           end
         end
       else
-        success, value = openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
         time_diff = Time.now.sys - start_time
         range = (expected_value - tolerance)..(expected_value + tolerance)
         check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)}"
@@ -400,7 +403,7 @@ module OpenC3
                               context = nil,
                               scope: $openc3_scope, token: $openc3_token, &block)
       start_time = Time.now.sys
-      success = openc3_script_wait_implementation_expression(exp_to_eval,
+      success = _openc3_script_wait_implementation_expression(exp_to_eval,
                                                              timeout,
                                                              polling_rate,
                                                              context, scope: scope, token: token, &block)
@@ -545,6 +548,10 @@ module OpenC3
       case args.length
       when 1
         target_name, packet_name, item_name, comparison_to_eval = extract_fields_from_check_text(args[0])
+      when 3
+        target_name        = args[0]
+        packet_name        = args[1]
+        item_name          = args[2]
       when 4
         target_name        = args[0]
         packet_name        = args[1]
@@ -554,7 +561,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
-      raise "Invalid comparison to non-ascii value" unless comparison_to_eval.is_printable?
+      if comparison_to_eval and !comparison_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
+      end
       return [target_name, packet_name, item_name, comparison_to_eval]
     end
 
@@ -599,15 +608,15 @@ module OpenC3
       # If the packet has not been received the initial_count could be nil
       initial_count = 0 unless initial_count
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name,
-                                                         packet_name,
-                                                         'RECEIVED_COUNT',
-                                                         :CONVERTED,
-                                                         ">= #{initial_count + num_packets}",
-                                                         timeout,
-                                                         polling_rate,
-                                                         scope: scope,
-                                                         token: token)
+      success, value = _openc3_script_wait_implementation_comparison(target_name,
+                                                                     packet_name,
+                                                                     'RECEIVED_COUNT',
+                                                                     :CONVERTED,
+                                                                     ">= #{initial_count + num_packets}",
+                                                                     timeout,
+                                                                     polling_rate,
+                                                                     scope: scope,
+                                                                     token: token)
       # If the packet has not been received the value could be nil
       value = 0 unless value
       time_diff = Time.now.sys - start_time
@@ -630,7 +639,7 @@ module OpenC3
 
     def _execute_wait(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, quiet: false, scope: $openc3_scope, token: $openc3_token)
       start_time = Time.now.sys
-      success, value = openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
+      success, value = _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
       value = "'#{value}'" if value.is_a? String # Show user the check against a quoted string
       time_diff = Time.now.sys - start_time
       wait_str = "WAIT: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
@@ -732,8 +741,9 @@ module OpenC3
 
     def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $openc3_scope, token: $openc3_token, &block)
       end_time = Time.now.sys + timeout
-      raise "Invalid comparison to non-ascii value" unless exp_to_eval.is_printable?
-
+      if exp_to_eval and !exp_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
+      end
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
@@ -762,15 +772,23 @@ module OpenC3
 
         if canceled
           value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-          begin
-            if eval(exp_to_eval)
+          if not block.nil?
+            if block.call(value)
               return true, value
             else
               return false, value
             end
-          # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-          rescue NoMethodError
-            return false, value
+          else
+            begin
+              if eval(exp_to_eval)
+                return true, value
+              else
+                return false, value
+              end
+            # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
+            rescue NoMethodError
+              return false, value
+            end
           end
         end
       end
@@ -787,7 +805,7 @@ module OpenC3
     end
 
     # Wait for a converted telemetry item to pass a comparison
-    def openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       if comparison_to_eval
         exp_to_eval = "value " + comparison_to_eval
       else
@@ -796,12 +814,12 @@ module OpenC3
       _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
       _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
+    def _openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
       statements = []
       array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
       exp_to_eval = statements.join(" && ")
@@ -809,7 +827,7 @@ module OpenC3
     end
 
     # Wait on an expression to be true.
-    def openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: $openc3_scope, token: $openc3_token)
+    def _openc3_script_wait_implementation_expression(exp_to_eval, timeout, polling_rate, context, scope: $openc3_scope, token: $openc3_token)
       end_time = Time.now.sys + timeout
       raise "Invalid comparison to non-ascii value" unless exp_to_eval.is_printable?
 

data/lib/openc3/script/calendar.rb

@@ -0,0 +1,109 @@
+# encoding: ascii-8bit
+
+# Copyright 2023 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.
+
+require 'date'
+
+module OpenC3
+  module Script
+
+    private
+
+    def list_timelines(scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline", scope: scope)
+      return _handle_response(response, 'Failed to list timelines')
+    end
+
+    def create_timeline(name, color: nil, scope: $openc3_scope, token: $openc3_token)
+      data = {}
+      data['name'] = name
+      data['color'] = color if color
+      response = $api_server.request('post', "/openc3-api/timeline", data: data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to create timeline')
+    end
+
+    def get_timeline(name, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline/#{name}", scope: scope)
+      return _handle_response(response, 'Failed to get timeline')
+    end
+
+    def set_timeline_color(name, color, scope: $openc3_scope, token: $openc3_token)
+      post_data = {}
+      post_data['color'] = color
+      response = $api_server.request('post', "/openc3-api/timeline/#{name}/color", data: post_data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to set timeline color')
+    end
+
+    def delete_timeline(name, force: false, scope: $openc3_scope, token: $openc3_token)
+      url = "/openc3-api/timeline/#{name}"
+      if force
+        url += "?force=true"
+      end
+      response = $api_server.request('delete', url, scope: scope)
+      return _handle_response(response, 'Failed to delete timeline')
+    end
+
+    def get_timeline_activities(name, start: nil, stop: nil, scope: $openc3_scope, token: $openc3_token)
+      url = "/openc3-api/timeline/#{name}/activities"
+      if start and stop
+        url += "?start=#{start}&stop=#{stop}"
+      end
+      response = $api_server.request('get', url, scope: scope)
+      return _handle_response(response, 'Failed to get timeline activities')
+    end
+
+    def create_timeline_activity(name, kind:, start:, stop:, data: {}, scope: $openc3_scope, token: $openc3_token)
+      kind = kind.to_s.downcase()
+      kinds = %w(command script reserve)
+      unless kinds.include?(kind)
+        raise "Unknown kind: #{kind}. Must be one of #{kinds.join(', ')}."
+      end
+      post_data = {}
+      post_data['start'] = start.to_datetime.iso8601
+      post_data['stop'] = stop.to_datetime.iso8601
+      post_data['kind'] = kind
+      post_data['data'] = data
+      response = $api_server.request('post', "/openc3-api/timeline/#{name}/activities", data: post_data, json: true, scope: scope)
+      return _handle_response(response, 'Failed to create timeline activity')
+    end
+
+    def get_timeline_activity(name, start: nil, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('get', "/openc3-api/timeline/#{name}/activity/#{start}", scope: scope)
+      return _handle_response(response, 'Failed to get timeline activity')
+    end
+
+    def delete_timeline_activity(name, start, scope: $openc3_scope, token: $openc3_token)
+      response = $api_server.request('delete', "/openc3-api/timeline/#{name}/activity/#{start}", scope: scope)
+      return _handle_response(response, 'Failed to delete timeline activity')
+    end
+
+    # Helper method to handle the response
+    def _handle_response(response, error_message)
+      return nil if response.nil?
+      if response.status >= 400
+        result = JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+        raise "#{error_message} due to #{result['message']}"
+      end
+      # TODO: Not sure why the response body is empty (on delete) but check for that
+      if response.body.nil? or response.body.empty?
+        return nil
+      else
+        return JSON.parse(response.body, :allow_nan => true, :create_additions => true)
+      end
+    end
+  end
+end

data/lib/openc3/script/commands.rb

@@ -173,7 +173,7 @@ module OpenC3
     # Accepts two different calling styles:
     #   build_command("TGT CMD with PARAM1 val, PARAM2 val")
     #   build_command('TGT','CMD',{'PARAM1'=>val,'PARAM2'=>val})
-    def build_command(*args, **kwargs)
+    def build_command(*args, range_check: true, raw: false, scope: $openc3_scope, **kwargs)
       extract_string_kwargs_to_args(args, kwargs)
       $api_server.build_command(*args)
     end
@@ -188,13 +188,6 @@ module OpenC3
       $api_server.get_cmd_hazardous(*args)
     end
 
-    # Sends raw data through an interface from a file
-    def send_raw_file(interface_name, filename, scope: $openc3_scope)
-      data = nil
-      File.open(filename, 'rb') { |file| data = file.read }
-      $api_server.send_raw(interface_name, data, scope: scope)
-    end
-
     # Returns the time the most recent command was sent
     def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope)
       results = $api_server.get_cmd_time(target_name, command_name, scope: scope)

data/lib/openc3/script/{gems.rb → packages.rb}

@@ -22,10 +22,10 @@ module OpenC3
   module Script
     private
 
-    def gem_list(scope: $openc3_scope)
+    def package_list(scope: $openc3_scope)
       response_body = nil
       begin
-        endpoint = "/openc3-api/gems?scope=#{scope}"
+        endpoint = "/openc3-api/packages?scope=#{scope}"
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
 
@@ -41,20 +41,21 @@ module OpenC3
           end
         end
       rescue => error
-        raise "gem_list failed due to #{error.formatted}\nResponse:\n#{response_body}"
+        raise "package_list failed due to #{error.formatted}\nResponse:\n#{response_body}"
       end
     end
+    alias gem_list package_list
 
-    def gem_install(file_path, scope: $openc3_scope)
+    def package_install(file_path, scope: $openc3_scope)
       response_body = nil
       begin
-        endpoint = "/openc3-api/gems?scope=#{scope}"
+        endpoint = "/openc3-api/packages?scope=#{scope}"
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
 
         File.open(file_path, 'rb') do |file|
           request = Net::HTTP::Post.new(uri)
-          form_data = [["gem", file]]
+          form_data = [["package", file]]
           request.set_form(form_data, "multipart/form-data")
           request['User-Agent'] = JsonDRbObject::USER_AGENT
           request['Authorization'] = auth.token
@@ -67,14 +68,15 @@ module OpenC3
           end
         end
       rescue => error
-        raise "gem_install failed due to #{error.formatted}\nResponse:\n#{response_body}"
+        raise "package_install failed due to #{error.formatted}\nResponse:\n#{response_body}"
       end
     end
+    alias gem_install package_install
 
-    def gem_uninstall(gem_name, scope: $openc3_scope)
+    def package_uninstall(package_name, scope: $openc3_scope)
       response_body = nil
       begin
-        endpoint = "/openc3-api/gems/#{gem_name}?scope=#{scope}"
+        endpoint = "/openc3-api/packages/#{package_name}?scope=#{scope}"
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
         request = Net::HTTP::Delete.new(uri)
@@ -84,22 +86,24 @@ module OpenC3
           http.request(request) do |response|
             response_body = response.body
             response.value() # Raises an HTTP error if the response is not 2xx (success)
-            return true
+            return response_body.remove_quotes
           end
         end
       rescue => error
-        raise "gem_uninstall failed due to #{error.formatted}\nResponse:\n#{response_body}"
+        raise "package_uninstall failed due to #{error.formatted}\nResponse:\n#{response_body}"
       end
     end
+    alias package_uninstall package_uninstall
 
-    def gem_status(process_name, scope: $openc3_scope)
+    def package_status(process_name, scope: $openc3_scope)
       return plugin_status(process_name, scope: scope)
     end
+    alias gem_status package_status
 
-    def gem_download(gem_name, local_file_path, scope: $openc3_scope)
+    def package_download(package_name, local_file_path, scope: $openc3_scope)
       response_body = nil
       begin
-        endpoint = "/openc3-api/gems/#{gem_name}/download?scope=#{scope}"
+        endpoint = "/openc3-api/packages/#{package_name}/download?scope=#{scope}"
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
         request = Net::HTTP::Post.new(uri)
@@ -117,9 +121,9 @@ module OpenC3
           end
         end
       rescue => error
-        raise "gem_uninstall failed due to #{error.formatted}\nResponse:\n#{response_body}"
+        raise "package_download failed due to #{error.formatted}\nResponse:\n#{response_body}"
       end
     end
-
+    alias gem_download package_download
   end
 end