daytona 0.164.0 → 0.167.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce668bd56c2b7767f624eb0bbb347ed6144cc40782d8d27a857783a82448ae60
-  data.tar.gz: 6587e4186ff8ee24dbf55acb5be580d71c507b8bb1d76acf9badc891778e8630
+  metadata.gz: a9b70911a632518aefb458889b450d58d12b024ee796155bb39f980bafb4b576
+  data.tar.gz: 24f4791337a7418f2269e1560eaeba72ffec7899dcbf321d2367cc6ec3857886
 SHA512:
-  metadata.gz: 8f561638b39e7cf53f5d3488ba592a3ccbd93a395ba85e5622ee7c9b7ba909dd34235ccad5947ed5565d2c116c0c7d8fe78e51f7547936839705a2b9824a2474
-  data.tar.gz: dbf8ffab3facea88678ad36b8a8af77d8bd73087ed3c1fcf8cbe5aef11a3bd85924467227f7b0c58b90ac3540da82086dbb0cb3345be55b7677797b939cf2f85
+  metadata.gz: 596015b011c0efc5d1235e7b5a2a06e721d69d746541344043df8bf6ea049cfd7f584e7df63bc3b14e06e39d2c387b00334fe74c0bf5b2b351c12fe7985ab984
+  data.tar.gz: a016a6509ffe4436885290ea6174e8a37af602a53e454f2fe7c589921af8f95ee32de0879f831a509d81dc26c3eedcc38ab88fd283c9cdfd572b9e36fa318478

data/lib/daytona/common/charts.rb

@@ -1,298 +1,121 @@
 # frozen_string_literal: true
 
 module Daytona
-  module Charts
-    # @param data [Hash<Symbol, Object>]
-    # @return [Daytona::Charts::Chart]
-    def self.parse(data)
-      case data.fetch(:type, ChartType::UNKNOWN)
-      when ChartType::LINE then LineChart.new(data)
-      when ChartType::SCATTER then ScatterChart.new(data)
-      when ChartType::BAR then BarChart.new(data)
-      when ChartType::PIE then PieChart.new(data)
-      when ChartType::BOX_AND_WHISKER then BoxAndWhiskerChart.new(data)
-      when ChartType::COMPOSITE_CHART then CompositeChart.new(data)
-      else
-        Chart.new(data)
-      end
-    end
-
-    class Chart
-      # @return [String, Nil] The type of chart
-      attr_reader :type
-
-      # @return [String, Nil] The title of the chart
-      attr_reader :title
-
-      # @return [Array<Object>] The elements of the chart
-      attr_reader :elements
-
-      # @return [String, Nil] The PNG representation of the chart encoded in base64
-      attr_reader :png
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        @type = data.fetch(:type, nil)
-        @title = data.fetch(:title, nil)
-        @elements = data.fetch(:elements, [])
-        @png = data.fetch(:png, nil)
-      end
-
-      # @return [Hash<Symbol, Object>] original metadata
-      def to_h = { type:, title:, elements:, png: }
-    end
-
-    class Chart2D < Chart
-      # @return [String, Nil] The label of the x-axis
-      attr_reader :x_label
-
-      # @return [String, Nil] The label of the y-axis
-      attr_reader :y_label
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @x_label = data.fetch(:x_label, nil)
-        @y_label = data.fetch(:y_label, nil)
-      end
-
-      # @return [Hash<Symbol, Object>] original metadata
-      def to_h = super.merge(x_label:, y_label:)
-    end
-
-    class PointData
-      # @return [String] The label of the point series
-      attr_reader :label
-
-      # @return [Array<Array<Object>>] Array of [x, y] points
-      attr_reader :points
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        @label = data.fetch(:label)
-        @points = data.fetch(:points)
-      end
-
-      # @return [Hash<Symbol, Object>] original data representation
-      def to_h = { label:, points: }
-    end
-
-    class PointChart < Chart2D
-      # @return [Array<Object>] The ticks of the x-axis
-      attr_reader :x_ticks
-
-      # @return [Array<String>] The labels of the x-axis
-      attr_reader :x_tick_labels
-
-      # @return [String, Nil] The scale of the x-axis
-      attr_reader :x_scale
-
-      # @return [Array<Object>] The ticks of the y-axis
-      attr_reader :y_ticks
-
-      # @return [Array<String>] The labels of the y-axis
-      attr_reader :y_tick_labels
-
-      # @return [String, Nil] The scale of the y-axis
-      attr_reader :y_scale
-
-      # @return [Array<Daytona::Charts::PointData>] The points of the chart
-      attr_reader :elements
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @x_scale = data.fetch(:x_scale, nil)
-        @x_ticks = data.fetch(:x_ticks, nil)
-        @x_tick_labels = data.fetch(:x_tick_labels, nil)
-
-        @y_scale = data.fetch(:y_scale, nil)
-        @y_ticks = data.fetch(:y_ticks, nil)
-        @y_tick_labels = data.fetch(:y_tick_labels, nil)
-
-        @elements = data.fetch(:elements, []).map { |e| PointData.new(e) }
-      end
-
-      # @return [Hash<Symbol, Object>] original metadata
-      def to_h
-        super.merge(
-          x_scale:,
-          x_ticks:,
-          x_tick_labels:,
-          y_scale:,
-          y_ticks:,
-          y_tick_labels:,
-          elements: elements.map(&:to_h)
-        )
-      end
-    end
-
-    class LineChart < PointChart
-      def initialize(data)
-        super
-        @type = ChartType::LINE
-      end
-    end
-
-    class ScatterChart < PointChart
-      def initialize(data)
-        super
-        @type = ChartType::SCATTER
-      end
-    end
-
-    class BarData
-      # @return [String] The label of the bar
-      attr_reader :label
-
-      # @return [String] The value of the bar
-      attr_reader :value
-
-      # @return [String] The group of the bar
-      attr_reader :group
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        @label = data.fetch(:label)
-        @value = data.fetch(:value)
-        @group = data.fetch(:group)
-      end
-
-      # @return [Hash<Symbol, Object>]
-      def to_h = { label:, value:, group: }
-    end
-
-    class BarChart < Chart2D
-      # @return [Array<Daytona::Charts::BarData>] The bars of the chart
-      attr_reader :elements
+  ChartElement = DaytonaToolboxApiClient::ChartElement
+
+  module ChartType
+    LINE = 'line'
+    SCATTER = 'scatter'
+    BAR = 'bar'
+    PIE = 'pie'
+    BOX_AND_WHISKER = 'box_and_whisker'
+    COMPOSITE_CHART = 'composite_chart'
+    UNKNOWN = 'unknown'
+  end
 
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::BAR
-        @elements = data.fetch(:elements, []).map { |e| BarData.new(e) }
-      end
+  PointData = Struct.new(:label, :points, keyword_init: true)
+  BarData = Struct.new(:label, :value, :group, keyword_init: true)
+  PieData = Struct.new(:label, :angle, :radius, keyword_init: true)
+  BoxAndWhiskerData = Struct.new(:label, :min, :first_quartile, :median, :third_quartile, :max, :outliers,
+                                 keyword_init: true)
 
-      # @return [Hash<Symbol, Object>]
-      def to_h = super.merge(elements: elements.map(&:to_h))
+  Chart = Struct.new(:type, :title, :png, :elements, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [])
+      super
     end
+  end
 
-    class PieData
-      # @return [String] The label of the pie slice
-      attr_reader :label
-
-      # @return [Float] The angle of the pie slice
-      attr_reader :angle
-
-      # @return [Float] The radius of the pie slice
-      attr_reader :radius
-
-      # @return [Float] The autopct value of the pie slice
-      attr_reader :autopct
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        @label = data.fetch(:label)
-        @angle = data.fetch(:angle)
-        @radius = data.fetch(:radius)
-        @autopct = data.fetch(:autopct)
-      end
-
-      # @return [Hash<Symbol, Object>]
-      def to_h = { label:, angle:, radius:, autopct: }
+  Chart2D = Struct.new(:type, :title, :png, :elements, :x_label, :y_label, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil)
+      super
     end
+  end
 
-    class PieChart < Chart
-      # @return [Array<Daytona::Charts::PieData>] The pie slices of the chart
-      attr_reader :elements
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::PIE
-        @elements = data.fetch(:elements, []).map { |e| PieData.new(e) }
-      end
-
-      # @return [Hash<Symbol, Object>]
-      def to_h = super.merge(elements: elements.map(&:to_h))
+  PointChart = Struct.new(:type, :title, :png, :elements, :x_label, :y_label,
+                          :x_ticks, :y_ticks, :x_tick_labels, :y_tick_labels,
+                          :x_scale, :y_scale, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil,
+                   x_ticks: nil, y_ticks: nil, x_tick_labels: nil, y_tick_labels: nil,
+                   x_scale: nil, y_scale: nil)
+      super
     end
+  end
 
-    class BoxAndWhiskerData
-      # @return [String] The label of the box and whisker
-      attr_reader :label
-
-      # @return [Float] The minimum value of the box and whisker
-      attr_reader :min
-
-      # @return [Float] The first quartile of the box and whisker
-      attr_reader :first_quartile
-
-      # @return [Float] The median of the box and whisker
-      attr_reader :median
-
-      # @return [Float] The third quartile of the box and whisker
-      attr_reader :third_quartile
+  class LineChart < PointChart
+  end
 
-      # @return [Float] The maximum value of the box and whisker
-      attr_reader :max
+  class ScatterChart < PointChart
+  end
 
-      # @return [Array<Float>] The outliers of the box and whisker
-      attr_reader :outliers
+  class BarChart < Chart2D
+  end
 
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        @label = data.fetch(:label)
-        @min = data.fetch(:min)
-        @first_quartile = data.fetch(:first_quartile)
-        @median = data.fetch(:median)
-        @third_quartile = data.fetch(:third_quartile)
-        @max = data.fetch(:max)
-        @outliers = data.fetch(:outliers, [])
-      end
+  class PieChart < Chart
+  end
 
-      # @return [Hash<Symbol, Object>]
-      def to_h = { label:, min:, first_quartile:, median:, third_quartile:, max:, outliers: }
-    end
+  class BoxAndWhiskerChart < Chart2D
+  end
 
-    class BoxAndWhiskerChart < Chart2D
-      # @return [Array<Daytona::Charts::BoxAndWhiskerData>] The box and whiskers of the chart
-      attr_reader :elements
+  class CompositeChart < Chart
+  end
 
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::BOX_AND_WHISKER
-        @elements = data.fetch(:elements, []).map { |e| BoxAndWhiskerData.new(e) }
+  module Charts
+    Chart = Daytona::Chart
+    ChartElement = Daytona::ChartElement
+    ChartType = Daytona::ChartType
+    LineChart = Daytona::LineChart
+    ScatterChart = Daytona::ScatterChart
+    BarChart = Daytona::BarChart
+    PieChart = Daytona::PieChart
+    BoxAndWhiskerChart = Daytona::BoxAndWhiskerChart
+    CompositeChart = Daytona::CompositeChart
+    PointData = Daytona::PointData
+    BarData = Daytona::BarData
+    PieData = Daytona::PieData
+    BoxAndWhiskerData = Daytona::BoxAndWhiskerData
+
+    def self.parse_chart(chart)
+      type = chart.type || ChartType::UNKNOWN
+      elements = (chart.elements || []).map { |el| map_element(el, type) }
+      common = { type: chart.type, title: chart.title, png: chart.png, elements: elements }
+
+      case type
+      when ChartType::LINE
+        LineChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                      x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                      x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::SCATTER
+        ScatterChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                         x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                         x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::BAR
+        BarChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::PIE
+        PieChart.new(**common)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::COMPOSITE_CHART
+        CompositeChart.new(**common)
+      else
+        Chart.new(**common)
       end
-
-      # @return [Hash<Symbol, Object>]
-      def to_h = super.merge(elements: elements.map(&:to_h))
     end
 
-    class CompositeChart < Chart
-      # @return [Array<Daytona::Charts::Chart>] The charts of the composite chart
-      attr_reader :elements
-
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::COMPOSITE_CHART
-        @elements = data.fetch(:elements, []).map { |e| Charts.parse(e) }
+    def self.map_element(el, chart_type)
+      case chart_type
+      when ChartType::LINE, ChartType::SCATTER
+        PointData.new(label: el.label, points: el.points)
+      when ChartType::BAR
+        BarData.new(label: el.label, value: el.value, group: el.group)
+      when ChartType::PIE
+        PieData.new(label: el.label, angle: el.angle, radius: el.radius)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerData.new(label: el.label, min: el.min, first_quartile: el.first_quartile,
+                              median: el.median, third_quartile: el.third_quartile,
+                              max: el.max, outliers: el.outliers)
+      else
+        el
       end
-
-      def to_h = super.merge(elements: elements.map(&:to_h))
-    end
-
-    module ChartType
-      ALL = [
-        LINE = 'line',
-        SCATTER = 'scatter',
-        BAR = 'bar',
-        PIE = 'pie',
-        BOX_AND_WHISKER = 'box_and_whisker',
-        COMPOSITE_CHART = 'composite_chart',
-        UNKNOWN = 'unknown'
-      ].freeze
     end
   end
 end

data/lib/daytona/common/daytona.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Daytona
+  CODE_TOOLBOX_LANGUAGE_LABEL = 'code-toolbox-language'
+
   class CreateSandboxBaseParams
     # @return [Symbol, nil] Programming language for the Sandbox
     attr_accessor :language

data/lib/daytona/daytona.rb

@@ -66,6 +66,11 @@ module Daytona
         params.language = CodeLanguage::PYTHON
       end
 
+      unless CodeLanguage::ALL.include?(params.language.to_s.to_sym)
+        raise ArgumentError,
+              "Invalid #{CODE_TOOLBOX_LANGUAGE_LABEL}: #{params.language}. Supported languages: #{CodeLanguage::ALL.join(', ')}"
+      end
+
       _create(params, on_snapshot_create_logs:)
     end
 
@@ -81,7 +86,7 @@ module Daytona
     # @return [Daytona::Sandbox]
     def get(id)
       sandbox_dto = sandbox_api.get_sandbox(id)
-      to_sandbox(sandbox_dto:, code_toolbox: code_toolbox_from_labels(sandbox_dto.labels))
+      to_sandbox(sandbox_dto:)
     end
 
     # Lists Sandboxes filtered by labels.
@@ -102,10 +107,8 @@ module Daytona
         total: response.total,
         page: response.page,
         total_pages: response.total_pages,
-        items: response
-               .items
-               .map do |sandbox_dto|
-                 to_sandbox(sandbox_dto:, code_toolbox: code_toolbox_from_labels(sandbox_dto.labels))
+        items: response.items.map do |sandbox_dto|
+          to_sandbox(sandbox_dto:)
         end
       )
     end
@@ -150,7 +153,7 @@ module Daytona
       end
 
       labels = params.labels&.dup || {}
-      labels[LABEL_CODE_TOOLBOX_LANGUAGE] = params.language.to_s if params.language
+      labels[CODE_TOOLBOX_LANGUAGE_LABEL] = params.language.to_s if params.language
 
       create_sandbox = DaytonaApiClient::CreateSandbox.new(
         user: params.os_user,
@@ -204,7 +207,7 @@ module Daytona
         Util.stream_async(uri:, headers:, on_chunk: on_snapshot_create_logs)
       end
 
-      sandbox = to_sandbox(sandbox_dto: response, code_toolbox: code_toolbox_from_labels(response.labels))
+      sandbox = to_sandbox(sandbox_dto: response)
 
       if sandbox.state != DaytonaApiClient::SandboxState::STARTED
         sandbox.wait_for_sandbox_start([0.001, timeout - (Time.now - start_time)].max)
@@ -246,42 +249,16 @@ module Daytona
     end
 
     # @param sandbox_dto [DaytonaApiClient::Sandbox]
-    # @param code_toolbox [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
     # @return [Daytona::Sandbox]
-    def to_sandbox(sandbox_dto:, code_toolbox:)
+    def to_sandbox(sandbox_dto:)
       Sandbox.new(
         sandbox_dto:,
         config:,
         sandbox_api:,
-        code_toolbox:,
         otel_state: @otel_state
       )
     end
 
-    # Converts a language to a code toolbox
-    #
-    # @param language [Symbol]
-    # @return [Daytona::CodeToolbox]
-    # @raise [Daytona::Sdk::Error] If the language is not supported
-    def code_toolbox_from_language(language)
-      case language
-      when CodeLanguage::PYTHON, nil
-        SandboxPythonCodeToolbox.new
-      when SandboxTsCodeToolbox, CodeLanguage::TYPESCRIPT
-        SandboxTsCodeToolbox.new
-      when CodeLanguage::JAVASCRIPT
-        SandboxJsCodeToolbox.new
-      else
-        raise Sdk::Error, "Unsupported language: #{language}"
-      end
-    end
-
-    # Get code toolbox from Sandbox labels
-    #
-    # @param labels [Hash<String, String>]
-    # @return [Daytona::CodeToolbox]
-    def code_toolbox_from_labels(labels) = code_toolbox_from_language(labels[LABEL_CODE_TOOLBOX_LANGUAGE]&.to_sym)
-
     SOURCE_RUBY = 'sdk-ruby'
     private_constant :SOURCE_RUBY
 
@@ -293,8 +270,5 @@ module Daytona
 
     HEADER_ORGANIZATION_ID = 'X-Daytona-Organization-ID'
     private_constant :HEADER_ORGANIZATION_ID
-
-    LABEL_CODE_TOOLBOX_LANGUAGE = 'code-toolbox-language'
-    private_constant :LABEL_CODE_TOOLBOX_LANGUAGE
   end
 end