charty 0.2.6 → 0.2.10

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

@@ -0,0 +1,89 @@
+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")
+          @initialized = true
+          nil
+        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

@@ -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

@@ -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
@@ -575,6 +576,47 @@ module Charty
         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
         dtype = case vmin
@@ -620,6 +662,10 @@ module Charty
         end
       end
 
+      def set_title(title)
+        @pyplot.gca.set_title(String(title))
+      end
+
       def set_xlabel(label)
         @pyplot.gca.set_xlabel(String(label))
       end
@@ -652,6 +698,27 @@ module Charty
         @pyplot.gca.set_ylim(Float(min), Float(max))
       end
 
+      def set_xscale(scale)
+        scale = check_scale_type(scale, :xscale)
+        @pyplot.gca.set_xscale(scale)
+      end
+
+      def set_yscale(scale)
+        scale = check_scale_type(scale, :yscale)
+        @pyplot.gca.set_yscale(scale)
+      end
+
+      private def check_scale_type(val, name)
+        case
+        when :linear, :log
+          val
+        else
+          raise ArgumentError,
+                "Invalid #{name} type: %p" % val,
+                caller
+        end
+      end
+
       def disable_xaxis_grid
         @pyplot.gca.xaxis.grid(false)
       end
@@ -670,6 +737,12 @@ module Charty
 
       def render(notebook: false)
         show
+        nil
+      end
+
+      def render_mimebundle(include: [], exclude: [])
+        show
+        {}
       end
 
       SAVEFIG_OPTIONAL_PARAMS = [
@@ -685,6 +758,7 @@ module Charty
           params[key] = kwargs[key] if kwargs.key?(key)
         end
         @pyplot.savefig(filename, **params)
+        @pyplot.close
       end
 
       def show

data/lib/charty/backends/unicode_plot.rb

@@ -16,7 +16,7 @@ module Charty
         @layout = {}
       end
 
-      def bar(bar_pos, values, color: nil)
+      def bar(bar_pos, _group_names, values, colors, _orient, **kwargs)
         @figure = {
           type: :bar,
           bar_pos: bar_pos,
@@ -24,7 +24,7 @@ module Charty
         }
       end
 
-      def box_plot(plot_data, positions, color:, gray:)
+      def box_plot(plot_data, positions, **kwargs)
         @figure = { type: :box, data: plot_data }
       end
 
@@ -52,13 +52,13 @@ module Charty
         # do nothing
       end
 
-      def show
-        case @figure[:type]
-        when :bar
-          plot = ::UnicodePlot.barplot(@layout[:xtick_labels], @figure[:values], xlabel: @layout[:xlabel])
-        when :box
-          plot = ::UnicodePlot.boxplot(@layout[:xtick_labels], @figure[:data], xlabel: @layout[:xlabel])
-        end
+      def render(**kwargs)
+        plot = case @figure[:type]
+                when :bar
+                  ::UnicodePlot.barplot(@layout[:xtick_labels], @figure[:values], xlabel: @layout[:xlabel])
+                when :box
+                  ::UnicodePlot.boxplot(@layout[:xtick_labels], @figure[:data], xlabel: @layout[:xlabel])
+                end
         sio = StringIO.new
         class << sio
           def tty?; true; end

data/lib/charty/cache_dir.rb

@@ -0,0 +1,27 @@
+require "pathname"
+
+module Charty
+  module CacheDir
+    module_function
+
+    def cache_dir_path
+      platform_cache_dir_path + "charty"
+    end
+
+    def platform_cache_dir_path
+      base_dir = case RUBY_PLATFORM
+                 when /mswin/, /mingw/
+                   ENV.fetch("LOCALAPPDATA", "~/AppData/Local")
+                 when /darwin/
+                   "~/Library/Caches"
+                 else
+                   ENV.fetch("XDG_CACHE_HOME", "~/.cache")
+                 end
+      Pathname(base_dir).expand_path
+    end
+
+    def path(*path_components)
+      cache_dir_path.join(*path_components)
+    end
+  end
+end

data/lib/charty/iruby_helper.rb

@@ -0,0 +1,18 @@
+module Charty
+  module IRubyHelper
+    module_function
+
+    def iruby_notebook?
+      # TODO: This cannot distinguish notebook and console.
+      defined?(IRuby)
+    end
+
+    def vscode?
+      ENV.key?("VSCODE_PID")
+    end
+
+    def nteract?
+      ENV.key?("NTERACT_EXE")
+    end
+  end
+end

data/lib/charty/plot_methods.rb

@@ -23,19 +23,24 @@ module Charty
     # @param cap_size  Width of the caps on error bars.
     # @param dodge  [true,false]  If true, bar position is shifted along the
     #        categorical axis for avoid overlapping when the color-dimension is used.
+    # @param log  [true,false]  Set the value-axis (e.g. Y-axis if orient is :v) to be log scale.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def bar_plot(x: nil, y: nil, color: nil, data: nil,
                  order: nil, color_order: nil,
                  estimator: :mean, ci: 95, n_boot: 1000, units: nil, random: nil,
                  orient: nil, key_color: nil, palette: nil, saturation: 1r,
                  error_color: [0.26, 0.26, 0.26], error_width: nil, cap_size: nil,
-                 dodge: true, **options, &block)
+                 dodge: true, log: false, x_label: nil, y_label: nil, title: nil,
+                 **options, &block)
       Plotters::BarPlotter.new(
         data: data, variables: { x: x, y: y, color: color },
         order: order, orient: orient,
         estimator: estimator, ci: ci, n_boot: n_boot, units: units, random: random,
         color_order: color_order, key_color: key_color, palette: palette, saturation: saturation,
         error_color: error_color, error_width: error_width, cap_size: cap_size,
-        dodge: dodge,
+        dodge: dodge, log: log, x_label: x_label, y_label: y_label, title: title,
         **options, &block
       )
     end
@@ -43,7 +48,8 @@ module Charty
     def count_plot(x: nil, y: nil, color: nil, data: nil,
                    order: nil, color_order: nil,
                    orient: nil, key_color: nil, palette: nil, saturation: 1r,
-                   dodge: true, **options, &block)
+                   dodge: true, log: false, x_label: nil, y_label: nil, title: nil,
+                   **options, &block)
       case
       when x.nil? && !y.nil?
         x = y
@@ -70,6 +76,9 @@ module Charty
         palette: palette,
         saturation: saturation,
         dodge: dodge,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options
       ) do |plotter|
         plotter.value_label = "count"
@@ -106,11 +115,15 @@ module Charty
     # @param whisker  Propotion of the IQR past the low and high quartiles to
     #        extend the plot whiskers.  Points outside of this range will be
     #        treated as outliers.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def box_plot(x: nil, y: nil, color: nil, data: nil,
                  order: nil, color_order: nil,
                  orient: nil, key_color: nil, palette: nil, saturation: 1r,
                  width: 0.8r, dodge: true, flier_size: 5, line_width: nil,
-                 whisker: 1.5, **options, &block)
+                 whisker: 1.5, x_label: nil, y_label: nil, title: nil,
+                 **options, &block)
       Plotters::BoxPlotter.new(
         data: data,
         variables: { x: x, y: y, color: color },
@@ -125,6 +138,9 @@ module Charty
         flier_size: flier_size,
         line_width: line_width,
         whisker: whisker,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
@@ -164,13 +180,18 @@ module Charty
     #        :full, every group will get an entry in the legend.  If :auto,
     #        choose between brief or full representation based on number of
     #        levels.  If false, no legend data is added and no legend is drawn.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def line_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                   data: nil, key_color: nil, palette: nil, color_order: nil,
                   color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
                   markers: nil, dashes: true, style_order: nil,
                   units: nil, estimator: :mean, n_boot: 1000, random: nil,
                   sort: true, err_style: :band, err_params: nil, error_bar: [:ci, 95],
-                  x_scale: :linear, y_scale: :linear, legend: :auto, **options, &block)
+                  x_scale: :linear, y_scale: :linear, legend: :auto,
+                  x_label: nil, y_label: nil, title: nil,
+                  **options, &block)
       Plotters::LinePlotter.new(
         data: data,
         variables: { x: x, y: y, color: color, style: style, size: size },
@@ -195,6 +216,9 @@ module Charty
         x_scale: x_scale,
         y_scale: y_scale,
         legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
@@ -225,11 +249,14 @@ module Charty
     #        :full, every group will get an entry in the legend.  If :auto,
     #        choose between brief or full representation based on number of
     #        levels.  If false, no legend data is added and no legend is drawn.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def scatter_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                      data: nil, key_color: nil, palette: nil, color_order: nil,
                      color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
                      markers: true, style_order: nil, alpha: nil, legend: :auto,
-                     **options, &block)
+                     x_label: nil, y_label: nil, title: nil, **options, &block)
       Plotters::ScatterPlotter.new(
         data: data,
         variables: { x: x, y: y, color: color, style: style, size: size },
@@ -244,10 +271,59 @@ module Charty
         style_order: style_order,
         alpha: alpha,
         legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
     end
+
+    def hist_plot(data: nil, x: nil, y: nil, color: nil, weights: nil,
+                  stat: :count, bins: :auto,
+                  bin_range: nil, common_bins: true,
+                  key_color: nil, palette: nil, color_order: nil, color_norm: nil,
+                  legend: true, x_label: nil, y_label: nil, title: nil,
+                  **options, &block)
+      # TODO: support following arguments
+      # - wiehgts
+      # - binwidth
+      # - discrete
+      # - cumulative
+      # - common_norm
+      # - multiple
+      # - element
+      # - fill
+      # - shrink
+      # - kde
+      # - kde_params
+      # - line_params
+      # - thresh
+      # - pthresh
+      # - pmax
+      # - cbar
+      # - cbar_params
+      # - x_log_scale
+      # - y_log_scale
+      Plotters::HistogramPlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color },
+        weights: weights,
+        stat: stat,
+        bins: bins,
+        bin_range: bin_range,
+        common_bins: common_bins,
+        key_color: key_color,
+        palette: palette,
+        color_order: color_order,
+        color_norm: color_norm,
+        legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
+        **options,
+        &block)
+    end
   end
 
   extend PlotMethods