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

charty 0.2.1 → 0.2.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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