RubyGems - charty - Versions diffs - 0.2.1 → 0.2.7 - Mend

charty 0.2.1 → 0.2.7

Files changed (76) hide show

checksums.yaml +4 -4
data/.github/workflows/ci.yml +56 -23
data/.github/workflows/nmatrix.yml +67 -0
data/.github/workflows/pycall.yml +86 -0
data/Dockerfile.dev +9 -1
data/Gemfile +18 -0
data/README.md +177 -9
data/Rakefile +4 -5
data/charty.gemspec +10 -5
data/examples/palette.rb +1 -1
data/examples/sample_images/hist_gruff.png +0 -0
data/images/penguins_body_mass_g_flipper_length_mm_scatter_plot.png +0 -0
data/images/penguins_body_mass_g_flipper_length_mm_species_scatter_plot.png +0 -0
data/images/penguins_body_mass_g_flipper_length_mm_species_sex_scatter_plot.png +0 -0
data/images/penguins_species_body_mass_g_bar_plot_h.png +0 -0
data/images/penguins_species_body_mass_g_bar_plot_v.png +0 -0
data/images/penguins_species_body_mass_g_box_plot_h.png +0 -0
data/images/penguins_species_body_mass_g_box_plot_v.png +0 -0
data/images/penguins_species_body_mass_g_sex_bar_plot_v.png +0 -0
data/images/penguins_species_body_mass_g_sex_box_plot_v.png +0 -0
data/lib/charty.rb +9 -2
data/lib/charty/backends.rb +1 -0
data/lib/charty/backends/bokeh.rb +2 -2
data/lib/charty/backends/google_charts.rb +1 -1
data/lib/charty/backends/gruff.rb +14 -3
data/lib/charty/backends/plotly.rb +731 -32
data/lib/charty/backends/plotly_helpers/html_renderer.rb +203 -0
data/lib/charty/backends/plotly_helpers/notebook_renderer.rb +86 -0
data/lib/charty/backends/plotly_helpers/plotly_renderer.rb +121 -0
data/lib/charty/backends/pyplot.rb +515 -67
data/lib/charty/backends/rubyplot.rb +1 -1
data/lib/charty/backends/unicode_plot.rb +79 -0
data/lib/charty/cache_dir.rb +27 -0
data/lib/charty/dash_pattern_generator.rb +57 -0
data/lib/charty/index.rb +213 -0
data/lib/charty/iruby_helper.rb +18 -0
data/lib/charty/linspace.rb +1 -1
data/lib/charty/plot_methods.rb +283 -8
data/lib/charty/plotter.rb +2 -2
data/lib/charty/plotters.rb +11 -0
data/lib/charty/plotters/abstract_plotter.rb +188 -18
data/lib/charty/plotters/bar_plotter.rb +189 -7
data/lib/charty/plotters/box_plotter.rb +64 -11
data/lib/charty/plotters/categorical_plotter.rb +272 -40
data/lib/charty/plotters/count_plotter.rb +7 -0
data/lib/charty/plotters/distribution_plotter.rb +143 -0
data/lib/charty/plotters/estimation_support.rb +84 -0
data/lib/charty/plotters/histogram_plotter.rb +182 -0
data/lib/charty/plotters/line_plotter.rb +300 -0
data/lib/charty/plotters/random_support.rb +25 -0
data/lib/charty/plotters/relational_plotter.rb +635 -0
data/lib/charty/plotters/scatter_plotter.rb +80 -0
data/lib/charty/plotters/vector_plotter.rb +6 -0
data/lib/charty/statistics.rb +96 -2
data/lib/charty/table.rb +160 -15
data/lib/charty/table_adapters.rb +2 -0
data/lib/charty/table_adapters/active_record_adapter.rb +17 -9
data/lib/charty/table_adapters/base_adapter.rb +166 -0
data/lib/charty/table_adapters/daru_adapter.rb +39 -3
data/lib/charty/table_adapters/datasets_adapter.rb +13 -2
data/lib/charty/table_adapters/hash_adapter.rb +141 -16
data/lib/charty/table_adapters/narray_adapter.rb +25 -6
data/lib/charty/table_adapters/nmatrix_adapter.rb +15 -5
data/lib/charty/table_adapters/pandas_adapter.rb +163 -0
data/lib/charty/util.rb +28 -0
data/lib/charty/vector.rb +69 -0
data/lib/charty/vector_adapters.rb +187 -0
data/lib/charty/vector_adapters/array_adapter.rb +101 -0
data/lib/charty/vector_adapters/daru_adapter.rb +163 -0
data/lib/charty/vector_adapters/narray_adapter.rb +182 -0
data/lib/charty/vector_adapters/nmatrix_adapter.rb +37 -0
data/lib/charty/vector_adapters/numpy_adapter.rb +168 -0
data/lib/charty/vector_adapters/pandas_adapter.rb +199 -0
data/lib/charty/version.rb +1 -1
metadata +105 -24
data/lib/charty/palette.rb +0 -235

data/lib/charty/backends/plotly_helpers/html_renderer.rb ADDED Viewed

@@ -0,0 +1,203 @@
+require "datasets/downloader"
+require "json"
+require "securerandom"
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class HtmlRenderer
+        def initialize(use_cdn: true,
+                       full_html: false,
+                       requirejs: true)
+          @use_cdn = use_cdn
+          @full_html = full_html
+          @requirejs = requirejs
+        end
+        PLOTLY_URL = "https://plot.ly".freeze
+        PLOTLY_LATEST_CDN_URL = "https://cdn.plot.ly/plotly-latest.min.js".freeze
+        MATHJAX_CDN_URL = ("https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js").freeze
+        DEFAULT_WIDTH = "100%".freeze
+        DEFAULT_HEIGHT = 525
+        def render(figure, element_id: nil, post_script: nil)
+          element_id = SecureRandom.uuid if element_id.nil?
+          plotly_html_div = build_plotly_html_div(figure, element_id, post_script)
+          if @full_html
+            <<~END_HTML % {div: plotly_html_div}
+              <!DOCTYPE html>
+              <html>
+              <head><meta charset="utf-8" /></head>
+              <body>
+                %{div}
+              </body>
+              </html>
+            END_HTML
+          else
+            plotly_html_div
+          end
+        end
+        private def build_plotly_html_div(figure, element_id, post_script)
+          layout = figure.fetch(:layout, {})
+          json_data = JSON.dump(figure.fetch(:data, []))
+          json_layout = JSON.dump(layout)
+          json_frames = JSON.dump(figure[:frames]) if figure.key?(:frames)
+          # TODO: config and responsive support
+          template = layout.fetch(:template, {}).fetch(:layout, {})
+          div_width = layout.fetch(:width, template.fetch(:width, DEFAULT_WIDTH))
+          div_height = layout.fetch(:height, template.fetch(:height, DEFAULT_HEIGHT))
+          div_width  = "#{div_width}px"  if Float(div_width, exception: false)
+          div_height = "#{div_height}px" if Float(div_height, exception: false)
+          # TODO: showLink and showSendToCloud support
+          base_url_line = "window.PLOTLYENV.BASE_URL = '%{url}';" % {url: PLOTLY_URL}
+          ## build script body
+          # TODO: post_script support
+          then_post_script = ""
+          if post_script
+            ary = Array.try_convert(post_script)
+            post_script = ary || [post_script]
+            post_script.each do |ps|
+              next if ps.nil?
+              then_post_script << '.then(function(){ %{post_script} })' % {
+                post_script: ps % {plot_id: element_id}
+              }
+            end
+          end
+          then_addframes = ""
+          then_animate = ""
+          if json_frames
+            then_addframes = <<~END_ADDFRAMES % {id: element_id, frames: json_frames}
+              .then(function(){
+                Plotly.addFrames('%{id}', {frames});
+              })
+            END_ADDFRAMES
+            # TODO: auto_play support
+          end
+          json_config = JSON.dump({}) # TODO: config support
+          script = <<~END_SCRIPT
+            if (document.getElementById("%{id}")) {
+              Plotly.newPlot("%{id}", %{data}, %{layout}, %{config})%{then_addframes}%{then_animate}%{then_post_script};
+            }
+          END_SCRIPT
+          script = script % {
+            id: element_id,
+            data: json_data,
+            layout: json_layout,
+            config: json_config,
+            then_addframes: then_addframes,
+            then_animate: then_animate,
+            then_post_script: then_post_script
+          }
+          ## Handle loading/initializing plotlyjs
+          case
+          when @requirejs
+            include_plotlyjs = :require
+            include_mathjax = false
+          when @use_cdn
+            include_plotlyjs = :cdn
+            include_mathjax = :cdn
+          else
+            include_plotlyjs = true
+            include_mathjax = :cdn
+          end
+          case include_plotlyjs
+          when :require
+            require_start = 'require(["plotly"], function (Plotly) {'
+            require_end   = '});'
+          when :cdn
+            load_plotlyjs = <<~END_LOAD_PLOTLYJS % {win_config: window_plotly_config, url: PLOTLY_LATEST_CDN_URL}
+              %{win_config}
+              <script src="%{url}"></script>
+            END_LOAD_PLOTLYJS
+          when true
+            load_plotlyjs = <<~END_LOAD_PLOTLYJS % {win_config: window_plotly_config, script: get_plotlyjs}
+              %{win_config}
+              <script type="text/javascript">%{script}</script>
+            END_LOAD_PLOTLYJS
+          end
+          ## Handle loading/initializing MathJax
+          mathjax_tmplate = %Q[<script src="%{url}?config=TeX-AMS-MML_SVG"></script>]
+          case include_mathjax
+          when :cdn
+            mathjax_script = mathjax_tmplate % {url: MATHJAX_CDN_URL}
+            mathjax_script << <<~END_SCRIPT % {mathjax_config: mathjax_config}
+              <script type="text/javascript">%{mathjax_config}</script>
+            END_SCRIPT
+          else
+            mathjax_script = ""
+          end
+          div_template = <<~END_DIV
+            <div>
+              %{mathjax_script}
+              %{load_plotlyjs}
+              <div id="%{id}" class="plotly-graph-div" style="height: %{height}; width: %{width};"></div>
+              <script type="text/javascript">
+                %{require_start}
+                  window.PLOTLYENV = window.PLOTLYENV || {};
+                  %{base_url_line}
+                  %{script}
+                %{require_end}
+              </script>
+            </div>
+          END_DIV
+          plotly_html_div = div_template % {
+            mathjax_script: mathjax_script,
+            load_plotlyjs: load_plotlyjs,
+            id: element_id,
+            height: div_height,
+            width: div_width,
+            require_start: require_start,
+            base_url_line: base_url_line,
+            script: script,
+            require_end: require_end
+          }
+          plotly_html_div.strip!
+          plotly_html_div
+        end
+        private def window_plotly_config
+          %Q(window.PlotlyConfig = {MathJaxConfig: 'local'};)
+        end
+        private def mathjax_config
+          %Q(if (window.MathJax) { MathJax.Hub.Config({SVG: {font: "STIX-Web"}}); })
+        end
+        private def get_plotlyjs
+          cache_path = CacheDir.path("plotly.min.js")
+          unless cache_path.exist?
+            download_plotlyjs(cache_path)
+          end
+          cache_path.read
+        end
+        private def download_plotlyjs(output_path)
+          downloader = Datasets::Downloader.new(PLOTLY_LATEST_CDN_URL)
+          downloader.download(output_path)
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/plotly_helpers/notebook_renderer.rb ADDED Viewed

@@ -0,0 +1,86 @@
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class NotebookRenderer < HtmlRenderer
+        def initialize(use_cdn: false)
+          super(use_cdn: use_cdn, full_html: false, requirejs: true)
+          @initialized = false
+        end
+        def activate()
+          return if @initialized
+          unless IRubyHelper.iruby_notebook?
+            raise "IRuby is unavailable"
+          end
+          if @use_cdn
+            script = <<~END_SCRIPT % {win_config: window_plotly_config, mathjax_config: mathjax_config}
+              <script type="text/javascript">
+                %{win_config}
+                %{mathjax_config}
+                if (typeof require !== 'undefined') {
+                  require.undef("plotly");
+                  requirejs.config({
+                    paths: {
+                      'plotly': ['https://cdn.plot.ly/plotly-latest.min']
+                    }
+                  });
+                  require(['plotly'], function (Plotly) {
+                    window._Plotly = Plotly;
+                  });
+                }
+              </script>
+            END_SCRIPT
+          else
+            script = <<~END_SCRIPT % {script: get_plotlyjs, win_config: window_plotly_config, mathjax_config: mathjax_config}
+              <script type="text/javascript">
+                %{win_config}
+                %{mathjax_config}
+                if (typeof require !== 'undefined') {
+                  require.undef("plotly");
+                  define('plotly', function (require, exports, module) {
+                    %{script}
+                  });
+                  require(['plotly'], function (Plotly) {
+                    window._Plotly = Plotly;
+                  });
+                }
+              </script>
+            END_SCRIPT
+          end
+        end
+        def render(figure, element_id: nil, post_script: nil)
+          ary = Array.try_convert(post_script)
+          post_script = ary || [post_script]
+          post_script.unshift(<<~END_POST_SCRIPT)
+            var gd = document.getElementById('%{plot_id}');
+            var x = new MutationObserver(function (mutations, observer) {
+              var display = window.getComputedStyle(gd).display;
+              if (!display || display === 'none') {
+                console.log([gd, 'removed']);
+                Plotly.purge(gd);
+                observer.disconnect();
+              }
+            });
+            // Listen for the removal of the full notebook cell
+            var notebookContainer = gd.closest('#notebook-container');
+            if (notebookContainer) {
+              x.observe(notebookContainer, {childList: true});
+            }
+            // Listen for the clearing of the current output cell
+            var outputEl = gd.closest('.output');
+            if (outputEl) {
+              x.observe(outputEl, {childList: true});
+            }
+          END_POST_SCRIPT
+          super(figure, element_id: element_id, post_script: post_script)
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/plotly_helpers/plotly_renderer.rb ADDED Viewed

@@ -0,0 +1,121 @@
+require "date"
+require "json"
+require "time"
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class PlotlyRenderer
+        def render(figure)
+          json = JSON.generate(figure, allow_nan: true)
+          case json
+          when /\b(?:Infinity|NaN)\b/
+            visit(figure)
+          else
+            JSON.load(json)
+          end
+        end
+        private def visit(obj)
+          case obj
+          when Integer, String, Symbol, true, false, nil
+            obj
+          when Numeric
+            visit_float(obj)
+          when Time
+            visit_time(obj)
+          when Date
+            visit_date(obj)
+          when DateTime
+            visit_datetime(obj)
+          when Array
+            visit_array(obj)
+          when Hash
+            visit_hash(obj)
+          when ->(x) { defined?(Numo::NArray) && obj.is_a?(Numo::NArray) }
+            visit_array(obj.to_a)
+          when ->(x) { defined?(NMatrix) && obj.is_a?(NMatrix) }
+            visit_array(obj.to_a)
+          when ->(x) { defined?(Numpy::NDArray) && obj.is_a?(Numpy::NDArray) }
+            visit_array(obj.to_a)
+          when ->(x) { defined?(PyCall::List) && obj.is_a?(PyCall::List) }
+            visit_array(obj.to_a)
+          when ->(x) { defined?(PyCall::Tuple) && obj.is_a?(PyCall::Tuple) }
+            visit_array(obj.to_a)
+          when ->(x) { defined?(PyCall::Dict) && obj.is_a?(PyCall::Dict) }
+            visit_hash(obj.to_h)
+          when ->(x) { defined?(Pandas::Series) && obj.is_a?(Pandas::Series) }
+            visit_array(obj.to_a)
+          else
+            str = String.try_convert(obj)
+            return str unless str.nil?
+            ary = Array.try_convert(obj)
+            return visit_array(ary) unless ary.nil?
+            hsh = Hash.try_convert(obj)
+            return visit_hash(hsh) unless hsh.nil?
+            type_error(obj)
+          end
+        end
+        private def visit_float(obj)
+          obj = obj.to_f
+        rescue RangeError
+          type_error(obj)
+        else
+          case
+          when obj.finite?
+            obj
+          else
+            nil
+          end
+        end
+        private def visit_time(obj)
+          obj.iso8601(6)
+        end
+        private def visit_date(obj)
+          obj.iso8601(6)
+        end
+        private def visit_datetime(obj)
+          obj.iso8601(6)
+        end
+        private def visit_array(obj)
+          obj.map {|x| visit(x) }
+        end
+        private def visit_hash(obj)
+          obj.map { |key, value|
+            [
+              key,
+              visit(value)
+            ]
+          }.to_h
+        end
+        private def type_error(obj)
+          raise TypeError, "Unable to convert to JSON: %p" % obj
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/pyplot.rb CHANGED Viewed

@@ -8,11 +8,14 @@ module Charty
       class << self
         def prepare
           require 'matplotlib/pyplot'
+          require 'numpy'
         end
       end
       def initialize
         @pyplot = ::Matplotlib::Pyplot
+        @default_line_width = ::Matplotlib.rcParams["lines.linewidth"]
+        @default_marker_size = ::Matplotlib.rcParams["lines.markersize"]
       end
       def self.activate_iruby_integration
@@ -38,7 +41,7 @@ module Charty
         @pyplot.show
       end
-      def render(context, filename)
+      def old_style_render(context, filename)
         plot(@pyplot, context)
         if filename
           FileUtils.mkdir_p(File.dirname(filename))
@@ -47,7 +50,7 @@ module Charty
         @pyplot.show
       end
-      def save(context, filename, finish: true)
+      def old_style_save(context, filename, finish: true)
         plot(context)
         if filename
           FileUtils.mkdir_p(File.dirname(filename))
@@ -73,7 +76,7 @@ module Charty
           ax.ylabel(context.ylabel) if context.ylabel
         end
-        palette = Charty::Palette.default
+        palette = Palette.default
         colors = palette.colors.map {|c| c.to_rgb.to_hex_string }.cycle
         case context.method
         when :bar
@@ -90,7 +93,16 @@ module Charty
           min_l = palette.colors.map {|c| c.to_rgb.to_hsl.l }.min
           lum = min_l*0.6
           gray = Colors::RGB.new(lum, lum, lum).to_hex_string
-          draw_box_plot(context, subplot, colors, gray)
+          Array(context.data).each_with_index do |group_data, i|
+            next if group_data.empty?
+            box_data = group_data.compact
+            next if box_data.empty?
+            color = colors.next
+            draw_box_plot(box_data, vert: "v", position: i, color: color,
+                          gray: gray, width: 0.8, whisker: 1.5, flier_size: 5)
+          end
         when :bubble
           context.series.each do |data|
             ax.scatter(data.xs.to_a, data.ys.to_a, s: data.zs.to_a, alpha: 0.5,
@@ -125,93 +137,485 @@ module Charty
         end
       end
-      private def draw_box_plot(context, subplot, colors, gray)
-        Array(context.data).each_with_index do |group_data, i|
-          next if group_data.empty?
-          box_data = group_data.compact
-          next if box_data.empty?
-          artist_dict = @pyplot.boxplot(box_data, vert: "v", patch_artist: true,
-                                        positions: [i], widths: 0.8)
-          color = colors.next
-          artist_dict["boxes"].each do |box|
-            box.update({facecolor: color, zorder: 0.9, edgecolor: gray}, {})
-          end
-          artist_dict["whiskers"].each do |whisker|
-            whisker.update({color: gray, linestyle: "-"}, {})
-          end
-          artist_dict["caps"].each do |cap|
-            cap.update({color: gray}, {})
-          end
-          artist_dict["medians"].each do |median|
-            median.update({color: gray}, {})
-          end
-          artist_dict["fliers"].each do |flier|
-            flier.update({
-              markerfacecolor: gray,
-              marker: "d",
-              markeredgecolor: gray,
-              markersize: 5
-            }, {})
-          end
-        end
-      end
       # ==== NEW PLOTTING API ====
       def begin_figure
-        # do nothing
+        @legend_keys = []
+        @legend_labels = []
       end
-      def bar(bar_pos, values, color: nil, width: 0.8r, align: :center, orient: :v)
+      def bar(bar_pos, _group_names, values, colors, orient, label: nil, width: 0.8r,
+              align: :center, conf_int: nil, error_colors: nil, error_width: nil, cap_size: nil)
         bar_pos = Array(bar_pos)
         values = Array(values)
-        color = Array(color).map(&:to_hex_string)
+        colors = Array(colors).map(&:to_hex_string)
         width = Float(width)
+        ax = @pyplot.gca
+        kw = {color: colors, align: align}
+        kw[:label] = label unless label.nil?
         if orient == :v
-          @pyplot.bar(bar_pos, values, width: width, color: color, align: align)
+          ax.bar(bar_pos, values, width, **kw)
         else
-          @pyplot.barh(bar_pos, values, width: width, color: color, align: align)
+          ax.barh(bar_pos, values, width, **kw)
+        end
+        if conf_int
+          error_colors = Array(error_colors).map(&:to_hex_string)
+          confidence_intervals(ax, bar_pos, conf_int, orient, error_colors, error_width, cap_size)
         end
       end
-      def box_plot(plot_data, positions, color:, gray:,
-                   width: 0.8r, flier_size: 5, whisker: 1.5, notch: false)
-        color = Array(color).map(&:to_hex_string)
+      private def confidence_intervals(ax, at_group, conf_int, orient, colors, error_width=nil, cap_size=nil, **options)
+        options[:lw] = error_width || @default_line_width * 1.8
+        at_group.each_index do |i|
+          at = at_group[i]
+          ci_low, ci_high = conf_int[i]
+          color = colors[i]
+          if orient == :v
+            ax.plot([at, at], [ci_low, ci_high], color: color, **options)
+            unless cap_size.nil?
+              ax.plot([at - cap_size / 2.0, at + cap_size / 2.0], [ci_low,  ci_low],  color: color, **options)
+              ax.plot([at - cap_size / 2.0, at + cap_size / 2.0], [ci_high, ci_high], color: color, **options)
+            end
+          else
+            ax.plot([ci_low, ci_high], [at, at], color: color, **options)
+            unless cap_size.nil?
+              ax.plot([ci_low,  ci_low],  [at - cap_size / 2.0, at + cap_size / 2.0], color: color, **options)
+              ax.plot([ci_high, ci_high], [at - cap_size / 2.0, at + cap_size / 2.0], color: color, **options)
+            end
+          end
+        end
+      end
+      def box_plot(plot_data, group_names,
+                   orient:, colors:, gray:, dodge:, width: 0.8r,
+                   flier_size: 5, whisker: 1.5, notch: false)
+        colors = Array(colors).map(&:to_hex_string)
         gray = gray.to_hex_string
         width = Float(width)
         flier_size = Float(flier_size)
         whisker = Float(whisker)
         plot_data.each_with_index do |group_data, i|
-          next if group_data.nil? || group_data.empty?
+          unless group_data.nil?
+            draw_box_plot(group_data,
+                          vert: (orient == :v),
+                          position: i,
+                          color: colors[i],
+                          gray: gray,
+                          width: width,
+                          whisker: whisker,
+                          flier_size: flier_size)
+          end
+        end
+      end
-          artist_dict = @pyplot.boxplot(group_data, vert: :v,
-                                        patch_artist: true,
-                                        positions: [i],
-                                        widths: width,
-                                        whis: whisker, )
+      def grouped_box_plot(plot_data, group_names, color_names,
+                           orient:, colors:, gray:, dodge:, width: 0.8r,
+                           flier_size: 5, whisker: 1.5, notch: false)
+        colors = Array(colors).map(&:to_hex_string)
+        gray = gray.to_hex_string
+        width = Float(width)
+        flier_size = Float(flier_size)
+        whisker = Float(whisker)
+        offsets = color_offsets(color_names, dodge, width)
+        orig_width = width
+        width = Float(nested_width(color_names, dodge, width))
+        color_names.each_with_index do |color_name, i|
+          add_box_plot_legend(gray, colors[i], color_names[i])
+          plot_data[i].each_with_index do |group_data, j|
+            next if group_data.empty?
-          artist_dict["boxes"].each do |box|
-            box.update({facecolor: color[i], zorder: 0.9, edgecolor: gray}, {})
+            position = j + offsets[i]
+            draw_box_plot(group_data,
+                          vert: (orient == :v),
+                          position: position,
+                          color: colors[i],
+                          gray: gray,
+                          width: width,
+                          whisker: whisker,
+                          flier_size: flier_size)
           end
-          artist_dict["whiskers"].each do |whisker|
-            whisker.update({color: gray, linestyle: "-"}, {})
+        end
+      end
+      private def add_box_plot_legend(gray, color, name)
+        patch = @pyplot.Rectangle.new([0, 0], 0, 0, edgecolor: gray, facecolor: color, label: name)
+        @pyplot.gca.add_patch(patch)
+      end
+      private def draw_box_plot(group_data, vert:, position:, color:, gray:, width:, whisker:, flier_size:)
+        # TODO: Do not convert to Array when group_data is Pandas::Series or Numpy::NDArray,
+        # and use MemoryView if available when group_data is Numo::NArray
+        artist_dict = @pyplot.boxplot(Array(group_data),
+                                      vert: vert,
+                                      patch_artist: true,
+                                      positions: [position],
+                                      widths: width,
+                                      whis: whisker)
+        artist_dict["boxes"].each do |box|
+          box.update({facecolor: color, zorder: 0.9, edgecolor: gray}, {})
+        end
+        artist_dict["whiskers"].each do |whisker|
+          whisker.update({color: gray, linestyle: "-"}, {})
+        end
+        artist_dict["caps"].each do |cap|
+          cap.update({color: gray}, {})
+        end
+        artist_dict["medians"].each do |median|
+          median.update({color: gray}, {})
+        end
+        artist_dict["fliers"].each do |flier|
+          flier.update({
+            markerfacecolor: gray,
+            marker: "d",
+            markeredgecolor: gray,
+            markersize: flier_size
+          }, {})
+        end
+      end
+      private def color_offsets(color_names, dodge, width)
+        n_names = color_names.length
+        if dodge
+          each_width = width / n_names
+          offsets = Charty::Linspace.new(0 .. (width - each_width), n_names).to_a
+          mean = Statistics.mean(offsets)
+          offsets.map {|x| x - mean }
+        else
+          Array.new(n_names, 0)
+        end
+      end
+      private def nested_width(color_names, dodge, width)
+        if dodge
+          width.to_r / color_names.length * 0.98r
+        else
+          width
+        end
+      end
+      def scatter(x, y, variables, color:, color_mapper:,
+                  style:, style_mapper:, size:, size_mapper:)
+        kwd = {}
+        kwd[:edgecolor] = "w"
+        ax = @pyplot.gca
+        points = ax.scatter(x.to_a, y.to_a, **kwd)
+        unless color.nil?
+          color = color_mapper[color].map(&:to_hex_string)
+          points.set_facecolors(color)
+        end
+        unless size.nil?
+          size = size_mapper[size].map {|x| scale_scatter_point_size(x).to_f }
+          points.set_sizes(size)
+        end
+        unless style.nil?
+          paths = style_mapper[style, :marker].map(&method(:marker_to_path))
+          points.set_paths(paths)
+        end
+        sizes = points.get_sizes
+        points.set_linewidths(0.08 * Numpy.sqrt(Numpy.percentile(sizes, 10)))
+      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
+      PYPLOT_MARKERS = {
+               circle: "o",
+                    x: "X",
+                cross: "P",
+          triangle_up: "^",
+        triangle_down: "v",
+               square: [4, 0, 45].freeze,
+              diamond: [4, 0, 0].freeze,
+                 star: [5, 1, 0].freeze,
+         star_diamond: [4, 1, 0].freeze,
+          star_square: [4, 1, 45].freeze,
+             pentagon: [5, 0, 0].freeze,
+              hexagon: [6, 0, 0].freeze,
+      }.freeze
+      private def marker_to_path(marker)
+        @path_cache ||= {}
+        if @path_cache.key?(marker)
+          @path_cache[marker]
+        elsif PYPLOT_MARKERS.key?(marker)
+          val = PYPLOT_MARKERS[marker]
+          ms = Matplotlib.markers.MarkerStyle.new(val)
+          @path_cache[marker] = ms.get_path().transformed(ms.get_transform())
+        else
+          raise ArgumentError, "Unknown marker name: %p" % marker
+        end
+      end
+      RELATIONAL_PLOT_LEGEND_BRIEF_TICKS = 6
+      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
+        legend_titles = Util.filter_map([:color, :size, :style]) {|v| variables[v] }
+        legend_title = legend_titles.pop if legend_titles.length == 1
+        legend_kwargs = {}
+        update_legend = ->(var_name, val_name, **kw) do
+          key = [var_name, val_name]
+          if legend_kwargs.key?(key)
+            legend_kwargs[key].update(kw)
+          else
+            legend_kwargs[key] = kw
           end
-          artist_dict["caps"].each do |cap|
-            cap.update({color: gray}, {})
+        end
+        title_kwargs = {visible: false, color: "w", s: 0, linewidth: 0, marker: "", dashes: ""}
+        # color legend
+        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_mapper.levels.minmax
+          color_levels, color_formatted_levels = locator_to_legend_entries(locator, limits)
+        when color_mapper.levels.nil?
+          color_levels = color_formatted_levels = []
+        else
+          color_levels = color_formatted_levels = color_mapper.levels
+        end
+        if legend_title.nil? && variables.key?(:color)
+          update_legend.([variables[:color], :title], variables[:color], **title_kwargs)
+        end
+        color_levels.length.times do |i|
+          next if color_levels[i].nil?
+          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 = (size_mapper.map_type == :numeric) && (
+                       verbosity == :brief ||
+                       (verbosity == :auto && size_mapper.levels.length > brief_ticks)
+                     )
+        case
+        when brief_size
+          # TODO: Also support LogLocator
+          # locator = Matplotlib.ticker.LogLocator(numticks: brief_ticks)
+          locator = Matplotlib.ticker.MaxNLocator.new(nbins: brief_ticks)
+          limits = size_mapper.levels.minmax
+          size_levels, size_formatted_levels = locator_to_legend_entries(locator, limits)
+        when size_mapper.levels.nil?
+          size_levels = size_formatted_levels = []
+        else
+          size_levels = size_formatted_levels = size_mapper.levels
+        end
+        if legend_title.nil? && variables.key?(:size)
+          update_legend.([variables[:size], :title], variables[:size], **title_kwargs)
+        end
+        size_levels.length.times do |i|
+          next if size_levels[i].nil?
+          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)
+          update_legend.([variables[:style], :title], variables[:style], **title_kwargs)
+        end
+        unless style_mapper.levels.nil?
+          style_mapper.levels.each do |level|
+            next if level.nil?
+            attrs = style_mapper[level]
+            marker = if attrs.key?(:marker)
+                       PYPLOT_MARKERS[attrs[:marker]]
+                     else
+                       ""
+                     end
+            dashes = if attrs.key?(:dashes)
+                       attrs[:dashes]
+                     else
+                       ""
+                     end
+            update_legend.(variables[:style], level, marker: marker, dashes: dashes)
           end
-          artist_dict["medians"].each do |median|
-            median.update({color: gray}, {})
+        end
+        legend_kwargs.each do |key, kw|
+          _, label = key
+          kw[:color] ||= ".2"
+          use_kw = Util.filter_map(legend_attributes) {|attr|
+            [attr, kw[attr]] if kw.key?(attr)
+          }.to_h
+          use_kw[:visible] = kw[:visible] if kw.key?(:visible)
+          func.(label, use_kw)
+        end
+        handles = ax.get_legend_handles_labels()[0].to_a
+        unless handles.empty?
+          legend = ax.legend(title: legend_title || "")
+          adjust_legend_subtitles(legend)
+        end
+      end
+      private def scale_scatter_point_size(x)
+        min = 0.5 * @default_marker_size**2
+        max = 2.0 * @default_marker_size**2
+        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
-          artist_dict["fliers"].each do |flier|
-            flier.update({
-              markerfacecolor: gray,
-              marker: "d",
-              markeredgecolor: gray,
-              markersize: flier_size
-            }, {})
+        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
+        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
+                    when Matplotlib.ticker.LogLocator
+                      Matplotlib.ticker.LogFormatter.new
+                    else
+                      Matplotlib.ticker.ScalarFormatter.new
+                    end
+        dummy_axis = Object.new
+        dummy_axis.define_singleton_method(:get_view_interval) { limits }
+        formatter.axis =  dummy_axis
+        formatter.set_locs(raw_levels)
+        formatted_levels = raw_levels.map {|x| formatter.(x) }
+        return raw_levels, formatted_levels
+      end
+      private def adjust_legend_subtitles(legend)
+        font_size = Matplotlib.rcParams.get("legend.title_fontsize", nil)
+        hpackers = legend.findobj(Matplotlib.offsetbox.VPacker)[0].get_children()
+        hpackers.each do |hpack|
+          draw_area, text_area = hpack.get_children()
+          handles = draw_area.get_children()
+          unless handles.all? {|a| a.get_visible() }
+            draw_area.set_width(0)
+            unless font_size.nil?
+              text_area.get_children().each do |text|
+                text.set_size(font_size)
+              end
+            end
           end
         end
       end
@@ -228,18 +632,62 @@ module Charty
         @pyplot.gca.set_xticks(Array(values))
       end
+      def set_yticks(values)
+        @pyplot.gca.set_yticks(Array(values))
+      end
       def set_xtick_labels(labels)
         @pyplot.gca.set_xticklabels(Array(labels).map(&method(:String)))
       end
+      def set_ytick_labels(labels)
+        @pyplot.gca.set_yticklabels(Array(labels).map(&method(:String)))
+      end
       def set_xlim(min, max)
         @pyplot.gca.set_xlim(Float(min), Float(max))
       end
+      def set_ylim(min, max)
+        @pyplot.gca.set_ylim(Float(min), Float(max))
+      end
       def disable_xaxis_grid
         @pyplot.gca.xaxis.grid(false)
       end
+      def disable_yaxis_grid
+        @pyplot.gca.xaxis.grid(false)
+      end
+      def invert_yaxis
+        @pyplot.gca.invert_yaxis
+      end
+      def legend(loc:, title:)
+        @pyplot.gca.legend(loc: loc, title: title)
+      end
+      def render(notebook: false)
+        show
+        nil
+      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