RubyGems - charty - Versions diffs - 0.2.4 → 0.2.9 - Mend

charty 0.2.4 → 0.2.9

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 (45) hide show

checksums.yaml +4 -4
data/README.md +64 -15
data/charty.gemspec +10 -3
data/lib/charty.rb +5 -2
data/lib/charty/backends/bokeh.rb +2 -2
data/lib/charty/backends/google_charts.rb +1 -1
data/lib/charty/backends/gruff.rb +1 -1
data/lib/charty/backends/plotly.rb +434 -32
data/lib/charty/backends/plotly_helpers/html_renderer.rb +203 -0
data/lib/charty/backends/plotly_helpers/notebook_renderer.rb +87 -0
data/lib/charty/backends/plotly_helpers/plotly_renderer.rb +121 -0
data/lib/charty/backends/pyplot.rb +187 -48
data/lib/charty/backends/rubyplot.rb +1 -1
data/lib/charty/cache_dir.rb +27 -0
data/lib/charty/dash_pattern_generator.rb +57 -0
data/lib/charty/index.rb +1 -1
data/lib/charty/iruby_helper.rb +18 -0
data/lib/charty/plot_methods.rb +115 -3
data/lib/charty/plotter.rb +2 -2
data/lib/charty/plotters.rb +4 -0
data/lib/charty/plotters/abstract_plotter.rb +106 -11
data/lib/charty/plotters/bar_plotter.rb +1 -16
data/lib/charty/plotters/box_plotter.rb +1 -16
data/lib/charty/plotters/distribution_plotter.rb +150 -0
data/lib/charty/plotters/histogram_plotter.rb +242 -0
data/lib/charty/plotters/line_plotter.rb +300 -0
data/lib/charty/plotters/relational_plotter.rb +213 -96
data/lib/charty/plotters/scatter_plotter.rb +8 -43
data/lib/charty/statistics.rb +11 -2
data/lib/charty/table.rb +124 -14
data/lib/charty/table_adapters/base_adapter.rb +97 -0
data/lib/charty/table_adapters/daru_adapter.rb +2 -0
data/lib/charty/table_adapters/datasets_adapter.rb +7 -0
data/lib/charty/table_adapters/hash_adapter.rb +19 -3
data/lib/charty/table_adapters/pandas_adapter.rb +82 -0
data/lib/charty/util.rb +28 -0
data/lib/charty/vector_adapters.rb +5 -1
data/lib/charty/vector_adapters/array_adapter.rb +2 -10
data/lib/charty/vector_adapters/daru_adapter.rb +3 -11
data/lib/charty/vector_adapters/narray_adapter.rb +1 -6
data/lib/charty/vector_adapters/numpy_adapter.rb +1 -1
data/lib/charty/vector_adapters/pandas_adapter.rb +0 -1
data/lib/charty/version.rb +1 -1
metadata +104 -11
data/lib/charty/missing_value_support.rb +0 -14

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,87 @@
+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
+          IRuby.display(script, mime: "text/html")
+        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

@@ -14,6 +14,7 @@ module Charty
       def initialize
         @pyplot = ::Matplotlib::Pyplot
+        @default_edgecolor = Colors["white"].to_rgb
         @default_line_width = ::Matplotlib.rcParams["lines.linewidth"]
         @default_marker_size = ::Matplotlib.rcParams["lines.markersize"]
       end
@@ -41,7 +42,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))
@@ -50,7 +51,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))
@@ -303,7 +304,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 +318,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 +329,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,12 +371,12 @@ 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
-        legend_titles = [:color, :size, :style].filter_map {|v| variables[v] }
+        legend_titles = Util.filter_map([:color, :size, :style]) {|v| variables[v] }
         legend_title = legend_titles.pop if legend_titles.length == 1
         legend_kwargs = {}
@@ -391,24 +393,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 +417,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 +444,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,17 +462,19 @@ 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
         legend_kwargs.each do |key, kw|
           _, label = key
           kw[:color] ||= ".2"
-          use_kw = legend_attributes.filter_map {|attr|
+          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)
@@ -505,9 +495,137 @@ 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
+      def univariate_histogram(hist, name, variable_name, stat,
+                               alpha, color, key_color, color_mapper,
+                               multiple, element, fill, shrink)
+        mid_points = hist.edges.each_cons(2).map {|a, b| a + (b - a) / 2 }
+        orient = variable_name == :x ? :v : :h
+        width = shrink * (hist.edges[1] - hist.edges[0])
+        kw = {align: :edge}
+        color = if color.nil?
+                  key_color.to_rgb
+                else
+                  color_mapper[color].to_rgb
+                end
+        alpha = 1r unless fill
+        if fill
+          kw[:facecolor] = color.to_rgba(alpha: alpha).to_hex_string
+          if multiple == :stack || multiple == :fill || element == :bars
+            kw[:edgecolor] = @default_edgecolor.to_hex_string
+          else
+            kw[:edgecolor] = color.to_hex_string
+          end
+        elsif element == :bars
+          kw.delete(:facecolor)
+          kw[:edgecolor] = color.to_rgba(alpha: alpha).to_hex_string
+        else
+          kw[:color] = color.to_rgba(alpha: alpha).to_hex_string
+        end
+        kw[:label] = name unless name.nil?
+        ax = @pyplot.gca
+        if orient == :v
+          ax.bar(mid_points, hist.weights, width, **kw)
+        else
+          ax.barh(mid_points, hist.weights, width, **kw)
+        end
+      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
@@ -592,6 +710,27 @@ module Charty
         @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)
+        @pyplot.close
+      end
       def show
         @pyplot.show
       end