openc3 7.0.0.pre.rc3 → 7.0.0

data/lib/openc3/models/cvt_model.rb

@@ -15,11 +15,10 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'set'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/utilities/questdb_client'
-require 'openc3/models/target_model'
+# require 'openc3/models/target_model' # Circular require
 
 module OpenC3
   class CvtModel
@@ -126,251 +125,7 @@ module OpenC3
     end
 
     def self.tsdb_lookup(items, start_time:, end_time: nil, scope: $openc3_scope)
-      tables = {}
-      names = []
-      nil_count = 0
-      # Cache packet definitions to avoid repeated lookups
-      packet_cache = {}
-      # Map column names to item type info for decoding
-      item_types = {}
-      # Track calculated timestamp items: { position => { source:, format:, table_index: } }
-      calculated_items = {}
-      # Track which timestamp columns we need per table
-      needed_timestamps = {} # { table_index => Set of column names }
-      current_position = 0
-
-      # Stored timestamp items that need conversion from timestamp_ns to float seconds
-      stored_timestamp_items = Set.new(['PACKET_TIMESECONDS', 'RECEIVED_TIMESECONDS'])
-      # Track stored timestamp items: { position => { column:, table_index: } }
-      stored_timestamp_positions = {}
-
-      items.each do |item|
-        target_name, packet_name, orig_item_name, value_type, limits = item
-        # They will all be nil when item is a nil value
-        # A nil value indicates a value that does not exist as returned by get_tlm_available
-        if orig_item_name.nil?
-          # We know PACKET_TIMESECONDS always exists so we can use it to fill in the nil value
-          names << "PACKET_TIMESECONDS as __nil#{nil_count}"
-          nil_count += 1
-          current_position += 1
-          next
-        end
-        table_name = QuestDBClient.sanitize_table_name(target_name, packet_name, scope: scope)
-        tables[table_name] = 1
-        index = tables.find_index {|k,v| k == table_name }
-
-        # Check if this is a stored timestamp item (PACKET_TIMESECONDS or RECEIVED_TIMESECONDS)
-        # These are stored as timestamp_ns columns and need conversion to float seconds on read
-        if stored_timestamp_items.include?(orig_item_name)
-          col_name = "T#{index}.#{orig_item_name}"
-          names << "\"#{col_name}\""
-          stored_timestamp_positions[current_position] = { column: col_name, table_index: index }
-          current_position += 1
-          next
-        end
-
-        # Check if this is a calculated timestamp item (PACKET_TIMEFORMATTED or RECEIVED_TIMEFORMATTED)
-        if QuestDBClient::TIMESTAMP_ITEMS.key?(orig_item_name)
-          ts_info = QuestDBClient::TIMESTAMP_ITEMS[orig_item_name]
-          calculated_items[current_position] = {
-            source: ts_info[:source],
-            format: ts_info[:format],
-            table_index: index
-          }
-          # Track that we need this timestamp column for this table
-          needed_timestamps[index] ||= Set.new
-          needed_timestamps[index] << ts_info[:source]
-          current_position += 1
-          next
-        end
-
-        safe_item_name = QuestDBClient.sanitize_column_name(orig_item_name)
-
-        # Look up item type info from packet definition
-        cache_key = [target_name, packet_name]
-        unless packet_cache.key?(cache_key)
-          begin
-            packet_cache[cache_key] = TargetModel.packet(target_name, packet_name, scope: scope)
-          rescue RuntimeError
-            packet_cache[cache_key] = nil
-          end
-        end
-
-        packet_def = packet_cache[cache_key]
-        item_def = nil
-        if packet_def
-          packet_def['items']&.each do |pkt_item|
-            if pkt_item['name'] == orig_item_name
-              item_def = pkt_item
-              break
-            end
-          end
-        end
-
-        case value_type
-        when 'FORMATTED', 'WITH_UNITS'
-          col_name = "T#{index}.#{safe_item_name}__F"
-          names << "\"#{col_name}\""
-          # Formatted values are always strings, no special decoding needed
-          item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-        when 'CONVERTED'
-          col_name = "T#{index}.#{safe_item_name}__C"
-          names << "\"#{col_name}\""
-          # Converted values may have different types based on read_conversion
-          if item_def
-            rc = item_def['read_conversion']
-            if rc && rc['converted_type']
-              item_types[col_name] = { 'data_type' => rc['converted_type'], 'array_size' => item_def['array_size'] }
-            elsif item_def['states']
-              # State values are strings
-              item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-            else
-              item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-            end
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        else
-          col_name = "T#{index}.#{safe_item_name}"
-          names << "\"#{col_name}\""
-          if item_def
-            item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        end
-        current_position += 1
-        if limits
-          names << "\"T#{index}.#{safe_item_name}__L\""
-        end
-      end
-
-      # Add needed timestamp columns to the SELECT
-      # Track which column alias maps to which timestamp source for result processing
-      # Note: We use underscores in the alias name to avoid needing quotes, which QuestDB includes in returned field names
-      timestamp_columns = {} # { "T0___ts_timestamp" => { table_index: 0, source: 'timestamp' } }
-      needed_timestamps.each do |table_index, ts_columns|
-        ts_columns.each do |ts_col|
-          alias_name = "T#{table_index}___ts_#{ts_col}"
-          names << "T#{table_index}.#{ts_col} as #{alias_name}"
-          timestamp_columns[alias_name] = { table_index: table_index, source: ts_col }
-        end
-      end
-
-      # Build the SQL query
-      query = "SELECT #{names.join(", ")} FROM "
-      tables.each_with_index do |(table_name, _), index|
-        if index == 0
-          query += "#{table_name} as T#{index} "
-        else
-          query += "ASOF JOIN #{table_name} as T#{index} "
-        end
-      end
-      query_params = []
-      if start_time && !end_time
-        query += "WHERE T0.PACKET_TIMESECONDS < $1 LIMIT -1"
-        query_params << start_time
-      elsif start_time && end_time
-        query += "WHERE T0.PACKET_TIMESECONDS >= $1 AND T0.PACKET_TIMESECONDS < $2"
-        query_params << start_time
-        query_params << end_time
-      end
-
-      retry_count = 0
-      begin
-        conn = QuestDBClient.connection
-        result = conn.exec_params(query, query_params)
-        if result.nil? or result.ntuples == 0
-          return {}
-        else
-          data = []
-          # Build up a results set that is an array of arrays
-          # Each nested array is a set of 2 items: [value, limits state]
-          # If the item does not have limits the limits state is nil
-          result.each_with_index do |tuples, row_num|
-            data[row_num] ||= []
-            row_index = 0
-            # Store timestamp values for this row: { "T0.PACKET_TIMESECONDS" => Time, ... }
-            row_timestamps = {}
-            tuples.each do |tuple|
-              col_name = tuple[0]
-              col_value = tuple[1]
-              if col_name.include?("__L")
-                data[row_num][row_index - 1][1] = col_value
-              elsif col_name =~ /^__nil/
-                data[row_num][row_index] = [nil, nil]
-                row_index += 1
-              elsif col_name =~ /^T(\d+)___ts_(.+)$/
-                # This is a timestamp column for calculated items (TIMEFORMATTED)
-                table_idx = $1.to_i
-                ts_source = $2
-                row_timestamps["T#{table_idx}.#{ts_source}"] = col_value
-              elsif col_name.end_with?('.PACKET_TIMESECONDS', '.RECEIVED_TIMESECONDS') || col_name == 'PACKET_TIMESECONDS' || col_name == 'RECEIVED_TIMESECONDS'
-                # Stored timestamp column - convert from datetime to float seconds
-                ts_utc = QuestDBClient.pg_timestamp_to_utc(col_value)
-                seconds_value = QuestDBClient.format_timestamp(ts_utc, :seconds)
-                data[row_num][row_index] = [seconds_value, nil]
-                row_index += 1
-                # Also store for calculated items (TIMEFORMATTED) that may need this
-                # Normalize key to T{index}.{col} format for consistency
-                if col_name.include?('.')
-                  row_timestamps[col_name] = col_value
-                else
-                  row_timestamps["T0.#{col_name}"] = col_value
-                end
-              else
-                # Decode value using item type info
-                # QuestDB may return column names without table alias prefix
-                # Try both the raw column name and prefixed versions
-                type_info = item_types[col_name]
-                unless type_info
-                  tables.length.times do |i|
-                    prefixed_name = "T#{i}.#{col_name}"
-                    type_info = item_types[prefixed_name]
-                    break if type_info
-                  end
-                  type_info ||= {}
-                end
-                decoded_value = QuestDBClient.decode_value(
-                  col_value,
-                  data_type: type_info['data_type'],
-                  array_size: type_info['array_size']
-                )
-                data[row_num][row_index] = [decoded_value, nil]
-                row_index += 1
-              end
-            end
-
-            # Insert calculated timestamp items at their positions
-            # Insert in ascending order so positions remain valid after each insert
-            calculated_items.keys.sort.each do |position|
-              calc_info = calculated_items[position]
-              ts_key = "T#{calc_info[:table_index]}.#{calc_info[:source]}"
-              ts_value = row_timestamps[ts_key]
-              ts_utc = QuestDBClient.pg_timestamp_to_utc(ts_value)
-              calculated_value = QuestDBClient.format_timestamp(ts_utc, calc_info[:format])
-              data[row_num].insert(position, [calculated_value, nil])
-            end
-          end
-          # If we only have one row then we return a single array
-          if result.ntuples == 1
-            data = data[0]
-          end
-          return data
-        end
-      rescue IOError, PG::Error => e
-        # Retry the query because various errors can occur that are recoverable
-        retry_count += 1
-        if retry_count > 4
-          # After the 5th retry just raise the error
-          raise "Error querying TSDB: #{e.message}"
-        end
-        Logger.warn("TSDB: Retrying due to error: #{e.message}")
-        Logger.warn("TSDB: Last query: #{query}") # Log the last query for debugging
-        QuestDBClient.disconnect
-        sleep 0.1
-        retry
-      end
+      QuestDBClient.tsdb_lookup(items, start_time: start_time, end_time: end_time, scope: scope)
     end
 
     # Return all item values and limit state from the CVT

data/lib/openc3/models/plugin_store_model.rb

@@ -18,7 +18,7 @@ module OpenC3
   class PluginStoreModel < Model
     PRIMARY_KEY = 'openc3_plugin_store'
     DEFAULT_STORE_URL = 'https://store.openc3.com'
-    JSON_ENDPOINT = '/api/v1.1/cosmos_plugins'
+    JSON_ENDPOINT = '/api/v1.2/cosmos_plugins'
 
     def self.set(plugin_store_data)
       Store.set(PRIMARY_KEY, plugin_store_data)

data/lib/openc3/models/script_engine_model.rb

@@ -13,7 +13,7 @@
 
 require 'openc3/top_level'
 require 'openc3/models/model'
-require 'openc3/models/scope_model'
+# require 'openc3/models/scope_model' # Circular require
 require 'openc3/utilities/bucket'
 require 'openc3/utilities/bucket_utilities'
 

data/lib/openc3/models/target_model.rb

@@ -164,36 +164,41 @@ module OpenC3
       if target_name.include?('..') || target_name.include?('/') || target_name.include?('\\')
         raise ArgumentError, "Invalid target_name: #{target_name.inspect}"
       end
-      tmp_dir = Dir.mktmpdir
-      zip_filename = File.join(tmp_dir, "#{target_name}.zip")
-      Zip.continue_on_exists_proc = true
-      zip = Zip::File.open(zip_filename, create: true)
+      temp_dir = Dir.mktmpdir
+      begin
+        zip_filename = OpenC3.sanitize_path(File.join(temp_dir, "#{target_name}.zip"))
+        Zip.continue_on_exists_proc = true
+        zip = Zip::File.open(zip_filename, create: true)
 
-      if ENV['OPENC3_LOCAL_MODE']
-        OpenC3::LocalMode.zip_target(target_name, zip, scope: scope)
-      else
-        bucket = Bucket.getClient()
-        # The trailing slash is important!
-        prefix = "#{scope}/targets_modified/#{target_name}/"
-        resp = bucket.list_objects(
-          bucket: ENV['OPENC3_CONFIG_BUCKET'],
-          prefix: prefix,
-        )
-        resp.each do |item|
-          # item.key looks like DEFAULT/targets_modified/INST/screens/blah.txt
-          base_path = item.key.sub(prefix, '') # remove prefix
-          local_path = File.join(tmp_dir, base_path)
-          # Ensure dir structure exists, get_object fails if not
-          FileUtils.mkdir_p(File.dirname(local_path))
-          bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: item.key, path: local_path)
-          zip.add(base_path, local_path)
+        if ENV['OPENC3_LOCAL_MODE']
+          OpenC3::LocalMode.zip_target(target_name, zip, scope: scope)
+        else
+          bucket = Bucket.getClient()
+          # The trailing slash is important!
+          prefix = "#{scope}/targets_modified/#{target_name}/"
+          resp = bucket.list_objects(
+            bucket: ENV['OPENC3_CONFIG_BUCKET'],
+            prefix: prefix,
+          )
+          resp.each do |item|
+            # item.key looks like DEFAULT/targets_modified/INST/screens/blah.txt
+            base_path = item.key.sub(prefix, '') # remove prefix
+            local_path = File.join(temp_dir, base_path)
+            # Ensure dir structure exists, get_object fails if not
+            FileUtils.mkdir_p(File.dirname(local_path))
+            bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: item.key, path: local_path)
+            zip.add(base_path, local_path)
+          end
         end
+        zip.close
+
+        result = OpenStruct.new
+        result.filename = File.basename(zip_filename)
+        result.contents = File.read(zip_filename, mode: 'rb')
+      ensure
+        FileUtils.remove_entry_secure(temp_dir, true)
       end
-      zip.close
 
-      result = OpenStruct.new
-      result.filename = File.basename(zip_filename)
-      result.contents = File.read(zip_filename, mode: 'rb')
       return result
     end
 
@@ -393,14 +398,7 @@ module OpenC3
       shard: 0,
       scope:
     )
-      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at,
-        cmd_buffer_depth: cmd_buffer_depth, cmd_log_cycle_time: cmd_log_cycle_time, cmd_log_cycle_size: cmd_log_cycle_size,
-        cmd_log_retain_time: cmd_log_retain_time,
-        tlm_buffer_depth: tlm_buffer_depth, tlm_log_cycle_time: tlm_log_cycle_time, tlm_log_cycle_size: tlm_log_cycle_size,
-        tlm_log_retain_time: tlm_log_retain_time,
-        cmd_decom_retain_time: cmd_decom_retain_time, tlm_decom_retain_time: tlm_decom_retain_time,
-        cleanup_poll_time: cleanup_poll_time, needs_dependencies: needs_dependencies, target_microservices: target_microservices,
-        scope: scope)
+      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
       @folder_name = folder_name
       @requires = requires
       @ignored_parameters = ignored_parameters

data/lib/openc3/models/tool_model.rb

@@ -16,7 +16,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/model'
-require 'openc3/models/scope_model'
+# require 'openc3/models/scope_model' # Circular require
 require 'openc3/utilities/bucket'
 require 'openc3/utilities/bucket_utilities'
 require 'rack'
@@ -179,7 +179,7 @@ module OpenC3
         end
       end
 
-      if @url and !@url.start_with?('/') and @url !~ URI::regexp
+      if @url and !@url.start_with?('/') and @url !~ URI::RFC2396_PARSER.make_regexp
         raise "URL must be a full URL (http://domain.com/path) or a relative path (/path)"
       end
 
@@ -250,9 +250,22 @@ module OpenC3
 
       variables["tool_name"] = @name
       start_path = "/tools/#{@folder_name}/"
-      Dir.glob(gem_path + start_path + "**/*") do |filename|
-        next if filename == '.' or filename == '..' or File.directory?(filename)
-
+      # Sort files so dependencies are uploaded before dependents:
+      # fonts first, then CSS, then index.html last (it triggers all other loads)
+      filenames = Dir.glob(gem_path + start_path + "**/*")
+      filenames.reject! { |f| f == '.' or f == '..' or File.directory?(f) }
+      filenames.sort_by! do |filename|
+        if filename.include?('/fonts/')
+          [0, filename]
+        elsif filename.include?('/css/')
+          [1, filename]
+        elsif File.basename(filename) == 'index.html'
+          [3, filename]
+        else
+          [2, filename]
+        end
+      end
+      filenames.each do |filename|
         key = filename.split(gem_path + '/tools/')[-1]
         extension = filename.split('.')[-1]
         content_type = Rack::Mime.mime_type(".#{extension}")

data/lib/openc3/models/trigger_model.rb

@@ -19,7 +19,7 @@ require 'openc3/models/model'
 require 'openc3/models/microservice_model'
 require 'openc3/models/target_model'
 require 'openc3/models/trigger_group_model'
-require 'openc3/models/reaction_model'
+# require 'openc3/models/reaction_model' # Remove circular require
 require 'openc3/topics/autonomic_topic'
 
 module OpenC3

data/lib/openc3/models/widget_model.rb

@@ -15,9 +15,8 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'openc3/top_level'
 require 'openc3/models/model'
-require 'openc3/models/scope_model'
+# require 'openc3/models/scope_model' # Circular require
 require 'openc3/utilities/bucket'
 require 'openc3/utilities/bucket_utilities'
 

data/lib/openc3/operators/operator.rb

@@ -54,8 +54,10 @@ module OpenC3
     end
 
     def finalize
-      extract()
-      close()
+      unless closed?
+        extract()
+        close()
+      end
       unlink()
 
       output = ''
@@ -174,7 +176,7 @@ module OpenC3
         end
         @process.stop
       end
-      FileUtils.remove_entry_secure(@temp_dir, true)
+      FileUtils.remove_entry_secure(@temp_dir, true) if @temp_dir
       @process = nil
     end
 
@@ -300,6 +302,7 @@ module OpenC3
             # Respawn process
             output = p.extract_output
             Logger.error("Unexpected process died... respawning! #{p.cmd_line}\n#{output}\n", scope: p.scope)
+            p.hard_stop
             p.start
           end
         end
@@ -308,6 +311,7 @@ module OpenC3
 
     def shutdown_processes(processes)
       # Make a copy so we don't mutate original
+      hard_stop_processes = processes.dup
       processes = processes.dup
 
       Logger.info("Commanding soft stops...")
@@ -331,10 +335,8 @@ module OpenC3
         end
         sleep(0.1)
       end
-      if processes.length > 0
-        Logger.debug("Commanding hard stops...")
-        processes.each { |_name, p| p.hard_stop }
-      end
+      Logger.debug("Commanding hard stops...")
+      hard_stop_processes.each { |_name, p| p.output_increment; p.extract_output; p.hard_stop }
     end
 
     def shutdown

data/lib/openc3/packets/json_packet.rb

@@ -189,6 +189,8 @@ module OpenC3
           postfix = 'C'
         when :FORMATTED, :WITH_UNITS
           postfix = 'F'
+        else
+          raise "Unsupported value type: #{value_type}"
         end
         case reduced_type
         when :MIN

data/lib/openc3/packets/packet.rb

@@ -16,6 +16,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'digest'
+require 'active_support/core_ext/object/deep_dup'
 require 'openc3/packets/structure'
 require 'openc3/packets/packet_item'
 require 'openc3/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']

data/lib/openc3/packets/packet_config.rb

@@ -252,7 +252,7 @@ module OpenC3
           #######################################################################
           when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION', 'POLY_READ_CONVERSION',\
               'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',\
-              'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED',\
+              'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'CONVERTED_DATA', 'REQUIRED',\
               'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',\
               'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP', 'KEY', 'VARIABLE_BIT_SIZE',\
               'OBFUSCATE'
@@ -675,11 +675,6 @@ module OpenC3
             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)
@@ -719,8 +714,9 @@ module OpenC3
       # All config.lines following this config.line are considered part
       # of the conversion until an end of conversion marker is found
       when 'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START'
-        usage = "#{keyword} <Converted Type (optional)> <Converted Bit Size (optional)>"
-        parser.verify_num_parameters(0, 2, usage)
+        # As of COSMOS 7 the converted type and bit size are deprecated
+        # but we're still allowing them to be defined as parameters for backward compatibility
+        parser.verify_num_parameters(0, 2, keyword)
         @proc_text = ''
         @building_generic_conversion = true
         parser.set_preserve_lines(true)
@@ -731,10 +727,30 @@ module OpenC3
           raise parser.error("Invalid converted_type: #{@converted_type}.") unless CONVERTED_DATA_TYPES.include? @converted_type
         end
         @converted_bit_size = Integer(params[1]) if params[1]
-        if @converted_type.nil? or @converted_bit_size.nil?
-          msg = "Generic Conversion on item #{@current_item.name} does not specify converted type or bit size"
-          @warnings << msg
-          Logger.instance.warn @warnings[-1]
+
+      # Define the converted data type, bit size, and optional array size
+      # for items with read conversions (especially DERIVED items)
+      when 'CONVERTED_DATA'
+        usage = "CONVERTED_DATA <Converted Bit Size> <Converted Type> <Converted Array Size (optional)>"
+        parser.verify_num_parameters(2, 3, usage)
+        raise parser.error("#{keyword} requires a current item") unless @current_item
+        raise parser.error("#{keyword} requires a current item with a conversion") unless @current_item.read_conversion or @current_item.write_conversion
+        converted_bit_size = Integer(params[0])
+        converted_type = params[1].upcase.intern
+        raise parser.error("Invalid converted_type: #{converted_type}.") unless CONVERTED_DATA_TYPES.include? converted_type
+        if @current_item.read_conversion
+          @current_item.read_conversion.converted_type = converted_type
+          @current_item.read_conversion.converted_bit_size = converted_bit_size
+          if params[2]
+            @current_item.read_conversion.converted_array_size = Integer(params[2])
+          end
+        end
+        if @current_item.write_conversion
+          @current_item.write_conversion.converted_type = converted_type
+          @current_item.write_conversion.converted_bit_size = converted_bit_size
+          if params[2]
+            @current_item.write_conversion.converted_array_size = Integer(params[2])
+          end
         end
 
       # Define a set of limits for the current telemetry item

data/lib/openc3/script/calendar.rb

@@ -52,6 +52,14 @@ module OpenC3
       return _cal_handle_response(response, 'Failed to delete timeline')
     end
 
+    # Creates an activity for the specified timeline.
+    #
+    # @param name [String] The name of the timeline.
+    # @param kind [String] The kind of activity. Must be one of "COMMAND", "SCRIPT", or "RESERVE".
+    # @param start [DateTime] The start time of the activity.
+    # @param stop [DateTime] The stop time of the activity.
+    # @param data [Hash, optional] Additional data to associate with the activity. Defaults to {}. Any activity can provide "username", "notes", and "customTitle". "command", "script", and "reserve" keys are reserves for the corresponding activity kind, with "environment" also available for script activities.
+    # @param scope [String, optional] The scope of the activity. Defaults to OPENC3_SCOPE, must correspond to the timeline.
     def create_timeline_activity(name, kind:, start:, stop:, data: {}, scope: $openc3_scope)
       kind = kind.to_s.downcase()
       kinds = %w(command script reserve)

data/lib/openc3/script/script.rb

@@ -47,6 +47,9 @@ $disconnect = false
 $openc3_scope = ENV['OPENC3_SCOPE'] || 'DEFAULT'
 $openc3_in_cluster = false
 
+saved_verbose = $VERBOSE
+$VERBOSE = false
+
 module OpenC3
   module Script
     private
@@ -177,6 +180,10 @@ module OpenC3
       message_box(string, *items, **options)
     end
 
+    def check_box(string, *items, **options)
+      message_box(string, *items, **options)
+    end
+
     def _file_dialog(title, message, filter:)
       answer = ''
       path = "./*"
@@ -199,6 +206,16 @@ module OpenC3
       _file_dialog(title, message, filter)
     end
 
+    def open_bucket_dialog(title, message = "Open Bucket File")
+      answer = ''
+      while answer.empty?
+        print "#{title}\n#{message}\n<Type bucket file path (e.g. BUCKET/path/to/file)>:"
+        answer = gets
+        answer.chomp!
+      end
+      return answer
+    end
+
     def prompt(string, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string}: "
       print "Details: #{details}\n" if details
@@ -363,3 +380,5 @@ module OpenC3
     end
   end
 end
+
+$VERBOSE = saved_verbose