charty 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cf18b5e31bf29099d3d9386b8b022e38013bba339c129a0292af39983e2bccb
-  data.tar.gz: 4eb934400a4fc7c60354bf7f7f31e33d4be8cdbdeafb1d47762264d94c8c5a2a
+  metadata.gz: 63e13663e8213e077993e52b906b630c35a1f7f9a224abb99fd206bb700659c2
+  data.tar.gz: d7fd53056c32c18bf5af6b1e1a4b2a29bfe652a427b338087d3cab538a0797ba
 SHA512:
-  metadata.gz: 33f5c4ea51ea77a66538e62e43222aaa4f77942b526461ef881cd0ff092eb17a16830937eab032995361a1e7b9e0063e79f682b75fa1c0011644410f02c23b11
-  data.tar.gz: cd0c31ae974c4efc6192dc0fa74c93db41cdacac6e5a82cfded9ca1b4285e706c925641df483020d620f22e3aed5fae7263d2364ac0cfb5df35bbf4fc72ad034
+  metadata.gz: cc4da146432f688eb52dd382ea516e02ab84ef7143453c80fa5bc14fef55851728550ee58fe98c1c3a5e9a1eac0f33dcfb702356bc7c0f344ceaf85f87400435
+  data.tar.gz: f519610073317c3fafd42b97ad5e96d124265f6a7d79a54023995cf82d1fe84624d4f914c26e3eef644ad280110400fe1cdac275ec5e32145d7e4b652ef47891

data/README.md

@@ -100,7 +100,8 @@ Charty::Backends.use(:plotly)  # select plotly backend
 plot.save("scatter.html")      # save the plot as  an HTML file
 ```
 
-If you want to save the plotter into a PNG file, you can do it by specifying a output filename with `.png` extension.
+When you already have prepared [playwright-ruby-client](https://github.com/YusukeIwaki/playwright-ruby-client),
+you can render a plot into a PNG file by plotly backend by specifying a filename with `.png` extension.
 
 ```ruby
 plot.save("scatter.png")

data/charty.gemspec

@@ -26,17 +26,20 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "red-colors"
-  spec.add_dependency "red-palette", ">= 0.2.0"
+  spec.add_dependency "red-colors", ">= 0.3.0"
+  spec.add_dependency "red-palette", ">= 0.5.0"
+
+  spec.add_dependency "matplotlib", ">= 1.2.0"
+  spec.add_dependency "pandas", ">= 0.3.5"
+  spec.add_dependency "playwright-ruby-client"
 
   spec.add_development_dependency "bundler", ">= 1.16"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "test-unit"
-  spec.add_development_dependency "red-datasets", ">= 0.0.9"
+  spec.add_development_dependency "red-datasets", ">= 0.1.2"
   spec.add_development_dependency "daru"
   spec.add_development_dependency "matrix" # need for daru on Ruby > 3.0
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "playwright-ruby-client"
-  spec.add_development_dependency "iruby"
+  spec.add_development_dependency "iruby", ">= 0.7.0"
 end

data/lib/charty.rb

@@ -4,17 +4,17 @@ require "colors"
 require "palette"
 
 require_relative "charty/util"
+require_relative "charty/dash_pattern_generator"
 require_relative "charty/backends"
 require_relative "charty/backend_methods"
 require_relative "charty/plotter"
 require_relative "charty/index"
 require_relative "charty/layout"
 require_relative "charty/linspace"
-require_relative "charty/missing_value_support"
 require_relative "charty/plotters"
 require_relative "charty/plot_methods"
-require_relative "charty/table_adapters"
 require_relative "charty/table"
+require_relative "charty/table_adapters"
 require_relative "charty/statistics"
 require_relative "charty/vector_adapters"
 require_relative "charty/vector"

data/lib/charty/backends/plotly.rb

@@ -248,12 +248,8 @@ module Charty
         @traces.concat(traces)
       end
 
-      def scatter(x, y, variables, legend:, color:, color_mapper:,
+      def scatter(x, y, variables, color:, color_mapper:,
                   style:, style_mapper:, size:, size_mapper:)
-        if legend == :full
-          warn("Plotly backend does not support full verbosity legend")
-        end
-
         orig_x, orig_y = x, y
 
         x = case x
@@ -277,7 +273,7 @@ module Charty
         end
 
         unless color.nil? && style.nil?
-          grouped_scatter(x, y, variables, legend: legend,
+          grouped_scatter(x, y, variables,
                           color: color, color_mapper: color_mapper,
                           style: style, style_mapper: style_mapper,
                           size: size, size_mapper: size_mapper)
@@ -305,7 +301,7 @@ module Charty
         @traces << trace
       end
 
-      private def grouped_scatter(x, y, variables, legend:, color:, color_mapper:,
+      private def grouped_scatter(x, y, variables, color:, color_mapper:,
                                   style:, style_mapper:, size:, size_mapper:)
         @layout[:showlegend] = true
 
@@ -333,7 +329,9 @@ module Charty
 
           unless size.nil?
             vals = size.values_at(*indices)
-            trace[:marker][:size] = size_mapper[vals].map(&method(:scale_scatter_point_size))
+            trace[:marker][:size] = size_mapper[vals].map do |x|
+              scale_scatter_point_size(x).to_f
+            end
           end
 
           name = []
@@ -362,6 +360,12 @@ module Charty
         end
       end
 
+      def add_scatter_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        if legend == :full
+          warn("Plotly backend does not support full verbosity legend")
+        end
+      end
+
       private def scale_scatter_point_size(x)
         min = 6
         max = 12
@@ -369,6 +373,191 @@ module Charty
         min + x * (max - min)
       end
 
+      def line(x, y, variables, color:, color_mapper:, size:, size_mapper:, style:, style_mapper:, ci_params:)
+        x = case x
+            when Charty::Vector
+              x.to_a
+            else
+              orig_x, x = x, Array.try_convert(x)
+              if x.nil?
+                raise ArgumentError, "Invalid value for x: %p" % orig_x
+              end
+            end
+
+        y = case y
+            when Charty::Vector
+              y.to_a
+            else
+              orig_y, y = y, Array.try_convert(y)
+              if y.nil?
+                raise ArgumentError, "Invalid value for y: %p" % orig_y
+              end
+            end
+
+        name = []
+        legend_title = []
+
+        if color.nil?
+          # TODO: do not hard code this
+          line_color = Colors["#1f77b4"] # the first color of D3's category10 palette
+        else
+          line_color = color_mapper[color].to_rgb
+          name << color
+          legend_title << variables[:color]
+        end
+
+        unless style.nil?
+          marker, dashes = style_mapper[style].values_at(:marker, :dashes)
+          name << style
+          legend_title << variables[:style]
+        end
+
+        trace = {
+          type: :scatter,
+          mode: marker.nil? ? "lines" : "lines+markers",
+          x: x,
+          y: y,
+          line: {
+            shape: :linear,
+            color: line_color.to_hex_string
+          }
+        }
+
+        default_line_width = 2.0
+        unless size.nil?
+          line_width = default_line_width + 2.0 * size_mapper[size]
+          trace[:line][:width] = line_width
+        end
+
+        unless dashes.nil?
+          trace[:line][:dash] = convert_dash_pattern(dashes, line_width || default_line_width)
+        end
+
+        unless marker.nil?
+          trace[:marker] = {
+            line: {
+              width: 1,
+              color: "#fff"
+            },
+            symbol: marker,
+            size: 10
+          }
+        end
+
+        unless ci_params.nil?
+          case ci_params[:style]
+          when :band
+            y_min = ci_params[:y_min].to_a
+            y_max = ci_params[:y_max].to_a
+            @traces << {
+              type: :scatter,
+              x: x,
+              y: y_max,
+              mode: :lines,
+              line: { shape: :linear, width: 0 },
+              showlegend: false
+            }
+            @traces << {
+              type: :scatter,
+              x: x,
+              y: y_min,
+              mode: :lines,
+              line: { shape: :linear, width: 0 },
+              fill: :tonexty,
+              fillcolor: line_color.to_rgba(alpha: 0.2).to_hex_string,
+              showlegend: false
+            }
+          when :bars
+            y_min = ci_params[:y_min].map.with_index {|v, i| y[i] - v }
+            y_max = ci_params[:y_max].map.with_index {|v, i| v - y[i] }
+            trace[:error_y] = {
+              visible: true,
+              type: :data,
+              array: y_max,
+              arrayminus: y_min
+            }
+            unless line_color.nil?
+              trace[:error_y][:color] = line_color
+            end
+            unless line_width.nil?
+              trace[:error_y][:thickness] = line_width
+            end
+          end
+        end
+
+        trace[:name] = name.uniq.join(", ") unless name.empty?
+
+        @traces << trace
+
+        unless legend_title.empty?
+          @layout[:showlegend] = true
+          @layout[:legend] ||= {}
+          @layout[:legend][:title] = {text: legend_title.uniq.join(", ")}
+        end
+      end
+
+      def add_line_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        if legend == :full
+          warn("Plotly backend does not support full verbosity legend")
+        end
+
+        legend_order = if variables.key?(:color)
+                         if variables.key?(:style)
+                           # both color and style
+                           color_mapper.levels.product(style_mapper.levels)
+                         else
+                           # only color
+                           color_mapper.levels
+                         end
+                       elsif variables.key?(:style)
+                         # only style
+                         style_mapper.levels
+                       else
+                         # no legend entries
+                         nil
+                       end
+
+        if legend_order
+          # sort traces
+          legend_index = legend_order.map.with_index { |name, i|
+            [Array(name).uniq.join(", "), i]
+          }.to_h
+          @traces = @traces.each_with_index.sort_by { |trace, trace_index|
+            index = legend_index.fetch(trace[:name], legend_order.length)
+            [index, trace_index]
+          }.map(&:first)
+
+          # remove duplicated legend entries
+          names = {}
+          @traces.each do |trace|
+            if trace[:showlegend] != false
+              name = trace[:name]
+              if name
+                if names.key?(name)
+                  # Hide duplications
+                  trace[:showlegend] = false
+                else
+                  trace[:showlegend] = true
+                  names[name] = true
+                end
+              else
+                # Hide no name trace in legend
+                trace[:showlegend] = false
+              end
+            end
+          end
+        end
+      end
+
+      private def convert_dash_pattern(pattern, line_width)
+        case pattern
+        when ""
+          :solid
+        else
+          pattern.map {|d| "#{line_width * d}px" }.join(",")
+        end
+      end
+
       def set_xlabel(label)
         @layout[:xaxis] ||= {}
         @layout[:xaxis][:title] = label

data/lib/charty/backends/pyplot.rb

@@ -303,7 +303,7 @@ module Charty
         end
       end
 
-      def scatter(x, y, variables, legend:, color:, color_mapper:,
+      def scatter(x, y, variables, color:, color_mapper:,
                   style:, style_mapper:, size:, size_mapper:)
         kwd = {}
         kwd[:edgecolor] = "w"
@@ -317,7 +317,7 @@ module Charty
         end
 
         unless size.nil?
-          size = size_mapper[size].map(&method(:scale_scatter_point_size))
+          size = size_mapper[size].map {|x| scale_scatter_point_size(x).to_f }
           points.set_sizes(size)
         end
 
@@ -328,14 +328,15 @@ module Charty
 
         sizes = points.get_sizes
         points.set_linewidths(0.08 * Numpy.sqrt(Numpy.percentile(sizes, 10)))
+      end
 
-        if legend
-          add_relational_plot_legend(
-            ax, legend, variables, color_mapper, size_mapper, style_mapper,
-            [:color, :s, :marker]
-          ) do |label, kwargs|
-            ax.scatter([], [], label: label, **kwargs)
-          end
+      def add_scatter_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        ax = @pyplot.gca
+        add_relational_plot_legend(
+          ax, variables, color_mapper, size_mapper, style_mapper,
+          legend, [:color, :s, :marker]
+        ) do |label, kwargs|
+          ax.scatter([], [], label: label, **kwargs)
         end
       end
 
@@ -369,8 +370,8 @@ module Charty
 
       RELATIONAL_PLOT_LEGEND_BRIEF_TICKS = 6
 
-      private def add_relational_plot_legend(ax, verbosity, variables, color_mapper, size_mapper, style_mapper,
-                                             legend_attributes, &func)
+      private def add_relational_plot_legend(ax, variables, color_mapper, size_mapper, style_mapper,
+                                             verbosity, legend_attributes, &func)
         brief_ticks = RELATIONAL_PLOT_LEGEND_BRIEF_TICKS
         verbosity = :auto if verbosity == true
 
@@ -391,24 +392,17 @@ module Charty
 
         # color legend
 
-        brief_color = case verbosity
-                      when :brief
-                        color_mapper.map_type == :numeric
-                      when :auto
-                        if color_mapper.levels.nil?
-                          false
-                        else
-                          color_mapper.levels.length > brief_ticks
-                        end
-                      else
-                        false
-                      end
+        brief_color = (color_mapper.map_type == :numeric) && (
+                        (verbosity == :brief) || (
+                          verbosity == :auto && color_mapper.levels.length > brief_ticks
+                        )
+                      )
         case
         when brief_color
           # TODO: Also support LogLocator
           # locator = Matplotlib.ticker.LogLocator.new(numticks: brief_ticks)
           locator = Matplotlib.ticker.MaxNLocator.new(nbins: brief_ticks)
-          limits = color_map.levels.minmax
+          limits = color_mapper.levels.minmax
           color_levels, color_formatted_levels = locator_to_legend_entries(locator, limits)
         when color_mapper.levels.nil?
           color_levels = color_formatted_levels = []
@@ -422,22 +416,14 @@ module Charty
 
         color_levels.length.times do |i|
           next if color_levels[i].nil?
-          color_value = color_mapper[color_levels[i]].to_hex_string
+          color_value = color_mapper[color_levels[i]].to_rgb.to_hex_string
           update_legend.(variables[:color], color_formatted_levels[i], color: color_value)
         end
 
-        brief_size = case verbosity
-                     when :brief
-                       size_mapper.map_type == :numeric
-                     when :auto
-                       if size_mapper.levels.nil?
-                         false
-                       else
-                         size_mapper.levels.length > brief_ticks
-                       end
-                     else
-                       false
-                     end
+        brief_size = (size_mapper.map_type == :numeric) && (
+                       verbosity == :brief ||
+                       (verbosity == :auto && size_mapper.levels.length > brief_ticks)
+                     )
         case
         when brief_size
           # TODO: Also support LogLocator
@@ -457,8 +443,9 @@ module Charty
 
         size_levels.length.times do |i|
           next if size_levels[i].nil?
-          size_value = scale_scatter_point_size(size_mapper[size_levels[i]])
-          update_legend.(variables[:size], size_formatted_levels[i], linewidth: size_value, s: size_value)
+          line_width = scale_line_width(size_mapper[size_levels[i]])
+          point_size = scale_scatter_point_size(size_mapper[size_levels[i]])
+          update_legend.(variables[:size], size_formatted_levels[i], linewidth: line_width, s: point_size)
         end
 
         if legend_title.nil? && variables.key?(:style)
@@ -474,10 +461,12 @@ module Charty
                      else
                        ""
                      end
-            # TODO: support dashes
-            update_legend.(variables[:style], level,
-                           marker: marker,
-                           dashes: attrs.fetch(:dashes, ""))
+            dashes = if attrs.key?(:dashes)
+                       attrs[:dashes]
+                     else
+                       ""
+                     end
+            update_legend.(variables[:style], level, marker: marker, dashes: dashes)
           end
         end
 
@@ -505,9 +494,96 @@ module Charty
         min + x * (max - min)
       end
 
+      def line(x, y, variables, color:, color_mapper:, size:, size_mapper:, style:, style_mapper:, ci_params:)
+        kws = {
+          markeredgewidth: 0.75,
+          markeredgecolor: "w",
+        }
+        ax = @pyplot.gca
+
+        x = x.to_a
+        y = y.to_a
+        lines = ax.plot(x, y, **kws)
+
+        lines.each do |line|
+          unless color.nil?
+            line.set_color(color_mapper[color].to_rgb.to_hex_string)
+          end
+
+          unless size.nil?
+            scaled_size = scale_line_width(size_mapper[size])
+            line.set_linewidth(scaled_size.to_f)
+          end
+
+          unless style.nil?
+            attributes = style_mapper[style]
+            if attributes.key?(:dashes)
+              line.set_dashes(attributes[:dashes])
+            end
+            if attributes.key?(:marker)
+              line.set_marker(PYPLOT_MARKERS[attributes[:marker]])
+            end
+          end
+        end
+
+        # TODO: support color, size, and style
+
+        line = lines[0]
+        line_color = line.get_color
+        line_alpha = line.get_alpha
+        line_capstyle = line.get_solid_capstyle
+
+        unless ci_params.nil?
+          y_min = ci_params[:y_min].to_a
+          y_max = ci_params[:y_max].to_a
+          case ci_params[:style]
+          when :band
+            # TODO: support to supply `alpha` via `err_kws`
+            ax.fill_between(x, y_min, y_max, color: line_color, alpha: 0.2)
+          when :bars
+            error_deltas = [
+              y.zip(y_min).map {|v, v_min| v - v_min },
+              y.zip(y_max).map {|v, v_max| v_max - v }
+            ]
+            ebars = ax.errorbar(x, y, error_deltas,
+                                linestyle: "", color: line_color, alpha: line_alpha)
+            ebars.get_children.each do |bar|
+              case bar
+              when Matplotlib.collections.LineCollection
+                bar.set_capstyle(line_capstyle)
+              end
+            end
+          end
+        end
+      end
+
+      def add_line_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        ax = @pyplot.gca
+        add_relational_plot_legend(
+          ax, variables, color_mapper, size_mapper, style_mapper,
+          legend, [:color, :linewidth, :marker, :dashes]
+        ) do |label, kwargs|
+          ax.plot([], [], label: label, **kwargs)
+        end
+      end
+
+
+      private def scale_line_width(x)
+        min = 0.5 * @default_line_width
+        max = 2.0 * @default_line_width
+
+        min + x * (max - min)
+      end
+
       private def locator_to_legend_entries(locator, limits)
         vmin, vmax = limits
-        raw_levels = locator.tick_values(vmin, vmax).to_a
+        dtype = case vmin
+                when Numeric
+                  :float64
+                else
+                  :object
+                end
+        raw_levels = locator.tick_values(vmin, vmax).astype(dtype).to_a
         raw_levels.reject! {|v| v < limits[0] || limits[1] < v }
 
         formatter = case locator
@@ -596,6 +672,21 @@ module Charty
         show
       end
 
+      SAVEFIG_OPTIONAL_PARAMS = [
+        :dpi, :quality, :optimize, :progressive, :facecolor, :edgecolor,
+        :orientation, :papertype, :transparent, :bbox_inches, :pad_inches,
+        :bbox_extra_artists, :backend, :metadata, :pil_kwargs
+      ].freeze
+
+      def save(filename, format: nil, title: nil, width: 700, height: 500, **kwargs)
+        params = {}
+        params[:format] = format unless format.nil?
+        SAVEFIG_OPTIONAL_PARAMS.each do |key|
+          params[key] = kwargs[key] if kwargs.key?(key)
+        end
+        @pyplot.savefig(filename, **params)
+      end
+
       def show
         @pyplot.show
       end