polars-df 0.10.0-x86_64-linux-musl

data/lib/polars/config.rb

@@ -0,0 +1,530 @@
+module Polars
+  # Configure polars; offers options for table formatting and more.
+  class Config
+    POLARS_CFG_ENV_VARS = [
+      "POLARS_ACTIVATE_DECIMAL",
+      "POLARS_AUTO_STRUCTIFY",
+      "POLARS_FMT_MAX_COLS",
+      "POLARS_FMT_MAX_ROWS",
+      "POLARS_FMT_STR_LEN",
+      "POLARS_FMT_TABLE_CELL_ALIGNMENT",
+      "POLARS_FMT_TABLE_DATAFRAME_SHAPE_BELOW",
+      "POLARS_FMT_TABLE_FORMATTING",
+      "POLARS_FMT_TABLE_HIDE_COLUMN_DATA_TYPES",
+      "POLARS_FMT_TABLE_HIDE_COLUMN_NAMES",
+      "POLARS_FMT_TABLE_HIDE_COLUMN_SEPARATOR",
+      "POLARS_FMT_TABLE_HIDE_DATAFRAME_SHAPE_INFORMATION",
+      "POLARS_FMT_TABLE_INLINE_COLUMN_DATA_TYPE",
+      "POLARS_FMT_TABLE_ROUNDED_CORNERS",
+      "POLARS_STREAMING_CHUNK_SIZE",
+      "POLARS_TABLE_WIDTH",
+      "POLARS_VERBOSE"
+    ]
+
+    POLARS_CFG_DIRECT_VARS = {"set_fmt_float" => Plr.method(:get_float_fmt)}
+
+    # Initialize a Config object instance for context manager usage.
+    def initialize(restore_defaults: false, **options)
+      @original_state = self.class.save
+
+      if restore_defaults
+        self.class.restore_defaults
+      end
+
+      options.each do |opt, value|
+        opt = "set_#{opt}" unless opt.to_s.start_with?("set_")
+        if !self.class.respond_to?(opt)
+          raise ArgumentError, "Config has no #{opt} option"
+        end
+        self.class.public_send(opt, value)
+      end
+
+      yield self.class
+
+      self.class.restore_defaults.load(@original_state)
+      @original_state = ""
+    end
+
+    # Load and set previously saved (or shared) Config options from json/file.
+    #
+    # @return [Config]
+    def self.load(cfg)
+      options = JSON.parse(cfg)
+      ENV.merge!(options["environment"])
+      options.fetch("fetch", {}).each do |cfg_methodname, value|
+        if POLARS_CFG_DIRECT_VARS.key?(cfg_methodname)
+          public_send(cfg_methodname, value)
+        end
+      end
+      self
+    end
+
+    # Reset all polars Config settings to their default state.
+    #
+    # @return [Config]
+    def self.restore_defaults
+      POLARS_CFG_ENV_VARS.each do |var|
+        ENV.delete(var)
+      end
+      set_fmt_float
+      self
+    end
+
+    # Save the current set of Config options as a json string or file.
+    #
+    # @return [Config]
+    def self.save
+      environment_vars = POLARS_CFG_ENV_VARS.sort.select { |k| ENV.key?(k) }.to_h { |k| [k, ENV[k]] }
+      direct_vars = POLARS_CFG_DIRECT_VARS.to_h { |cfg_methodname, get_value| [cfg_methodname, get_value.call] }
+      options = JSON.generate({environment: environment_vars, direct: direct_vars})
+      options
+    end
+
+    # Show the current state of all Config variables as a dict.
+    #
+    # @param if_set [Boolean]
+    #   by default this will show the state of all `Config` environment variables.
+    #   change this to `true` to restrict the returned dictionary to include only
+    #   those that have been set to a specific value.
+    # @param env_only [Boolean]
+    #   include only Config environment variables in the output; some options (such
+    #   as "set_fmt_float") are set directly, not via an environment variable.
+    #
+    # @return [Object]
+    def self.state(if_set: false, env_only: false)
+      config_state = POLARS_CFG_ENV_VARS.sort
+        .select { |var| !if_set || !ENV[var].nil? }
+        .to_h { |var| [var, ENV[var]] }
+      if !env_only
+        POLARS_CFG_DIRECT_VARS.each do |cfg_methodname, get_value|
+          config_state[cfg_methodname] = get_value.call
+        end
+      end
+
+      config_state
+    end
+
+    # Activate `Decimal` data types.
+    #
+    # This is a temporary setting that will be removed later once the
+    # `Decimal` type stabilize. This will happens without it being
+    # considered a breaking change.
+    #
+    # Currently, `Decimal` types are in an alpha state.
+    #
+    # @return [Config]
+    def self.activate_decimals(active = true)
+      if !active
+        ENV.delete("POLARS_ACTIVATE_DECIMAL")
+      else
+        ENV["POLARS_ACTIVATE_DECIMAL"] = "1"
+      end
+      self
+    end
+
+    # Use ASCII characters to display table outlines (set False to revert to UTF8).
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(ascii_tables: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # +-----+-------+
+    #   # | abc | xyz   |
+    #   # | --- | ---   |
+    #   # | f64 | bool  |
+    #   # +=============+
+    #   # | 1.0 | true  |
+    #   # | 2.5 | false |
+    #   # | 5.0 | true  |
+    #   # +-----+-------+
+    def self.set_ascii_tables(active = true)
+      fmt = active ? "ASCII_FULL_CONDENSED" : "UTF8_FULL_CONDENSED"
+      ENV["POLARS_FMT_TABLE_FORMATTING"] = fmt
+      self
+    end
+
+    # Allow multi-output expressions to be automatically turned into Structs.
+    #
+    # @return [Config]
+    def self.set_auto_structify(active = true)
+      ENV["POLARS_AUTO_STRUCTIFY"] = active ? "1" : "0"
+      self
+    end
+
+    # Control how floating  point values are displayed.
+    #
+    # @param fmt ["mixed", "full"]
+    #   How to format floating point numbers
+    #
+    # @return [Config]
+    def self.set_fmt_float(fmt = "mixed")
+      Plr.set_float_fmt(fmt)
+      self
+    end
+
+    # Set the number of characters used to display string values.
+    #
+    # @param n [Integer]
+    #   number of characters to display
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "txt" => [
+    #         "Play it, Sam. Play 'As Time Goes By'.",
+    #         "This is the beginning of a beautiful friendship.",
+    #       ]
+    #     }
+    #   )
+    #   Polars::Config.new(fmt_str_lengths: 50) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌──────────────────────────────────────────────────┐
+    #   # │ txt                                              │
+    #   # │ ---                                              │
+    #   # │ str                                              │
+    #   # ╞══════════════════════════════════════════════════╡
+    #   # │ Play it, Sam. Play 'As Time Goes By'.            │
+    #   # │ This is the beginning of a beautiful friendship. │
+    #   # └──────────────────────────────────────────────────┘
+    def self.set_fmt_str_lengths(n)
+      if n <= 0
+        raise ArgumentError, "number of characters must be > 0"
+      end
+
+      ENV["POLARS_FMT_STR_LEN"] = n.to_s
+      self
+    end
+
+    # Overwrite chunk size used in `streaming` engine.
+    #
+    # By default, the chunk size is determined by the schema
+    # and size of the thread pool. For some datasets (esp.
+    # when you have large string elements) this can be too
+    # optimistic and lead to Out of Memory errors.
+    #
+    # @param size [Integer]
+    #   Number of rows per chunk. Every thread will process chunks
+    #   of this size.
+    #
+    # @return [Config]
+    def self.set_streaming_chunk_size(size)
+      if size < 1
+        raise ArgumentError, "number of rows per chunk must be >= 1"
+      end
+
+      ENV["POLARS_STREAMING_CHUNK_SIZE"] = size.to_s
+      self
+    end
+
+    # Set table cell alignment.
+    #
+    # @param format [String]
+    #   * "LEFT": left aligned
+    #   * "CENTER": center aligned
+    #   * "RIGHT": right aligned
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"column_abc" => [1.0, 2.5, 5.0], "column_xyz" => [true, false, true]}
+    #   )
+    #   Polars::Config.new(tbl_cell_alignment: "RIGHT") do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌────────────┬────────────┐
+    #   # │ column_abc ┆ column_xyz │
+    #   # │        --- ┆        --- │
+    #   # │        f64 ┆       bool │
+    #   # ╞════════════╪════════════╡
+    #   # │        1.0 ┆       true │
+    #   # │        2.5 ┆      false │
+    #   # │        5.0 ┆       true │
+    #   # └────────────┴────────────┘
+    def self.set_tbl_cell_alignment(format)
+      ENV["POLARS_FMT_TABLE_CELL_ALIGNMENT"] = format
+      self
+    end
+
+    # Set the number of columns that are visible when displaying tables.
+    #
+    # @param n [Integer]
+    #   number of columns to display; if `n < 0` (eg: -1), display all columns.
+    #
+    # @return [Config]
+    #
+    # @example Set number of displayed columns to a low value:
+    #   Polars::Config.new do |cfg|
+    #     cfg.set_tbl_cols(5)
+    #     df = Polars::DataFrame.new(100.times.to_h { |i| [i.to_s, [i]] })
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (1, 100)
+    #   # ┌─────┬─────┬─────┬───┬─────┬─────┐
+    #   # │ 0   ┆ 1   ┆ 2   ┆ … ┆ 98  ┆ 99  │
+    #   # │ --- ┆ --- ┆ --- ┆   ┆ --- ┆ --- │
+    #   # │ i64 ┆ i64 ┆ i64 ┆   ┆ i64 ┆ i64 │
+    #   # ╞═════╪═════╪═════╪═══╪═════╪═════╡
+    #   # │ 0   ┆ 1   ┆ 2   ┆ … ┆ 98  ┆ 99  │
+    #   # └─────┴─────┴─────┴───┴─────┴─────┘
+    def self.set_tbl_cols(n)
+      ENV["POLARS_FMT_MAX_COLS"] = n.to_s
+      self
+    end
+
+    # Moves the data type inline with the column name (to the right, in parentheses).
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_column_data_type_inline: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌───────────┬────────────┐
+    #   # │ abc (f64) ┆ xyz (bool) │
+    #   # ╞═══════════╪════════════╡
+    #   # │ 1.0       ┆ true       │
+    #   # │ 2.5       ┆ false      │
+    #   # │ 5.0       ┆ true       │
+    #   # └───────────┴────────────┘
+    def self.set_tbl_column_data_type_inline(active = true)
+      ENV["POLARS_FMT_TABLE_INLINE_COLUMN_DATA_TYPE"] = active ? "1" : "0"
+      self
+    end
+
+    # Print the dataframe shape below the dataframe when displaying tables.
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_dataframe_shape_below: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # ┌─────┬───────┐
+    #   # │ abc ┆ xyz   │
+    #   # │ --- ┆ ---   │
+    #   # │ f64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ 2.5 ┆ false │
+    #   # │ 5.0 ┆ true  │
+    #   # └─────┴───────┘
+    #   # shape: (3, 2)
+    def self.set_tbl_dataframe_shape_below(active = true)
+      ENV["POLARS_FMT_TABLE_DATAFRAME_SHAPE_BELOW"] = active ? "1" : "0"
+      self
+    end
+
+    # Set table formatting style.
+    #
+    # @param format [String]
+    #   * "ASCII_FULL": ASCII, with all borders and lines, including row dividers.
+    #   * "ASCII_FULL_CONDENSED": Same as ASCII_FULL, but with dense row spacing.
+    #   * "ASCII_NO_BORDERS": ASCII, no borders.
+    #   * "ASCII_BORDERS_ONLY": ASCII, borders only.
+    #   * "ASCII_BORDERS_ONLY_CONDENSED": ASCII, borders only, dense row spacing.
+    #   * "ASCII_HORIZONTAL_ONLY": ASCII, horizontal lines only.
+    #   * "ASCII_MARKDOWN": ASCII, Markdown compatible.
+    #   * "UTF8_FULL": UTF8, with all borders and lines, including row dividers.
+    #   * "UTF8_FULL_CONDENSED": Same as UTF8_FULL, but with dense row spacing.
+    #   * "UTF8_NO_BORDERS": UTF8, no borders.
+    #   * "UTF8_BORDERS_ONLY": UTF8, borders only.
+    #   * "UTF8_HORIZONTAL_ONLY": UTF8, horizontal lines only.
+    #   * "NOTHING": No borders or other lines.
+    # @param rounded_corners [Boolean]
+    #   apply rounded corners to UTF8-styled tables (no-op for ASCII formats).
+    #
+    # @note
+    #   The UTF8 styles all use one or more of the semigraphic box-drawing characters
+    #   found in the Unicode Box Drawing block, which are not ASCII compatible:
+    #   https://en.wikipedia.org/wiki/Box-drawing_character#Box_Drawing
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"abc" => [-2.5, 5.0], "mno" => ["hello", "world"], "xyz" => [true, false]}
+    #   )
+    #   Polars::Config.new(
+    #     tbl_formatting: "ASCII_MARKDOWN",
+    #     tbl_hide_column_data_types: true,
+    #     tbl_hide_dataframe_shape: true
+    #   ) do
+    #     p df
+    #   end
+    #   # =>
+    #   # | abc  | mno   | xyz   |
+    #   # |------|-------|-------|
+    #   # | -2.5 | hello | true  |
+    #   # | 5.0  | world | false |
+    def self.set_tbl_formatting(format = nil, rounded_corners: false)
+      if format
+        ENV["POLARS_FMT_TABLE_FORMATTING"] = format
+      end
+      ENV["POLARS_FMT_TABLE_ROUNDED_CORNERS"] = rounded_corners ? "1" : "0"
+      self
+    end
+
+    # Hide table column data types (i64, f64, str etc.).
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_hide_column_data_types: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬───────┐
+    #   # │ abc ┆ xyz   │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ 2.5 ┆ false │
+    #   # │ 5.0 ┆ true  │
+    #   # └─────┴───────┘
+    def self.set_tbl_hide_column_data_types(active = true)
+      ENV["POLARS_FMT_TABLE_HIDE_COLUMN_DATA_TYPES"] = active ? "1" : "0"
+      self
+    end
+
+    # Hide table column names.
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_hide_column_names: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬───────┐
+    #   # │ f64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ 2.5 ┆ false │
+    #   # │ 5.0 ┆ true  │
+    #   # └─────┴───────┘
+    def self.set_tbl_hide_column_names(active = true)
+      ENV["POLARS_FMT_TABLE_HIDE_COLUMN_NAMES"] = active ? "1" : "0"
+      self
+    end
+
+    # Hide the '---' separator between the column names and column types.
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_hide_dtype_separator: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬───────┐
+    #   # │ abc ┆ xyz   │
+    #   # │ f64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ 2.5 ┆ false │
+    #   # │ 5.0 ┆ true  │
+    #   # └─────┴───────┘
+    def self.set_tbl_hide_dtype_separator(active = true)
+      ENV["POLARS_FMT_TABLE_HIDE_COLUMN_SEPARATOR"] = active ? "1" : "0"
+      self
+    end
+
+    # Hide the shape information of the dataframe when displaying tables.
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"abc" => [1.0, 2.5, 5.0], "xyz" => [true, false, true]})
+    #   Polars::Config.new(tbl_hide_dataframe_shape: true) do
+    #     p df
+    #   end
+    #   # =>
+    #   # ┌─────┬───────┐
+    #   # │ abc ┆ xyz   │
+    #   # │ --- ┆ ---   │
+    #   # │ f64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ 2.5 ┆ false │
+    #   # │ 5.0 ┆ true  │
+    #   # └─────┴───────┘
+    def self.set_tbl_hide_dataframe_shape(active = true)
+      ENV["POLARS_FMT_TABLE_HIDE_DATAFRAME_SHAPE_INFORMATION"] = active ? "1" : "0"
+      self
+    end
+
+    # Set the max number of rows used to draw the table (both Dataframe and Series).
+    #
+    # @param n [Integer]
+    #   number of rows to display; if `n < 0` (eg: -1), display all
+    #   rows (DataFrame) and all elements (Series).
+    #
+    # @return [Config]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"abc" => [1.0, 2.5, 3.5, 5.0], "xyz" => [true, false, true, false]}
+    #   )
+    #   Polars::Config.new(tbl_rows: 2) do
+    #     p df
+    #   end
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬───────┐
+    #   # │ abc ┆ xyz   │
+    #   # │ --- ┆ ---   │
+    #   # │ f64 ┆ bool  │
+    #   # ╞═════╪═══════╡
+    #   # │ 1.0 ┆ true  │
+    #   # │ …   ┆ …     │
+    #   # │ 5.0 ┆ false │
+    #   # └─────┴───────┘
+    def self.set_tbl_rows(n)
+      ENV["POLARS_FMT_MAX_ROWS"] = n.to_s
+      self
+    end
+
+    # Set the number of characters used to draw the table.
+    #
+    # @param width [Integer]
+    #   number of chars
+    #
+    # @return [Config]
+    def self.set_tbl_width_chars(width)
+      ENV["POLARS_TABLE_WIDTH"] = width.to_s
+      self
+    end
+
+    # Enable additional verbose/debug logging.
+    #
+    # @return [Config]
+    def self.set_verbose(active = true)
+      ENV["POLARS_VERBOSE"] = active ? "1" : "0"
+      self
+    end
+  end
+end

data/lib/polars/convert.rb

@@ -0,0 +1,93 @@
+module Polars
+  module Convert
+    # Construct a DataFrame from a dictionary of sequences.
+    #
+    # This operation clones data, unless you pass in a `Hash<String, Series>`.
+    #
+    # @param data [Hash]
+    #   Two-dimensional data represented as a hash. Hash must contain
+    #   arrays.
+    # @param columns [Array]
+    #   Column labels to use for resulting DataFrame. If specified, overrides any
+    #   labels already present in the data. Must match data dimensions.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   data = {"a" => [1, 2], "b" => [3, 4]}
+    #   Polars.from_hash(data)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 3   │
+    #   # │ 2   ┆ 4   │
+    #   # └─────┴─────┘
+    def from_hash(data, schema: nil, columns: nil)
+      DataFrame._from_hash(data, schema: schema || columns)
+    end
+
+    # Construct a DataFrame from a sequence of dictionaries. This operation clones data.
+    #
+    # @param hashes [Array]
+    #   Array with hashes mapping column name to value.
+    # @param infer_schema_length [Integer]
+    #   How many hashes/rows to scan to determine the data types
+    #   if set to `nil` all rows are scanned. This will be slow.
+    # @param schema [Object]
+    #   Schema that (partially) overwrites the inferred schema.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   data = [{"a" => 1, "b" => 4}, {"a" => 2, "b" => 5}, {"a" => 3, "b" => 6}]
+    #   Polars.from_hashes(data)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 4   │
+    #   # │ 2   ┆ 5   │
+    #   # │ 3   ┆ 6   │
+    #   # └─────┴─────┘
+    #
+    # @example Overwrite first column name and dtype
+    #   Polars.from_hashes(data, schema: {"c" => :i32})
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ c   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i32 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 4   │
+    #   # │ 2   ┆ 5   │
+    #   # │ 3   ┆ 6   │
+    #   # └─────┴─────┘
+    #
+    # @example Let polars infer the dtypes but inform about a 3rd column
+    #   Polars.from_hashes(data, schema: {"a" => :unknown, "b" => :unknown, "c" => :i32})
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬──────┐
+    #   # │ a   ┆ b   ┆ c    │
+    #   # │ --- ┆ --- ┆ ---  │
+    #   # │ i64 ┆ i64 ┆ i32  │
+    #   # ╞═════╪═════╪══════╡
+    #   # │ 1   ┆ 4   ┆ null │
+    #   # │ 2   ┆ 5   ┆ null │
+    #   # │ 3   ┆ 6   ┆ null │
+    #   # └─────┴─────┴──────┘
+    # def from_hashes(hashes, infer_schema_length: 50, schema: nil)
+    #   DataFrame._from_hashes(hashes, infer_schema_length: infer_schema_length, schema: schema)
+    # end
+
+    # def from_records
+    # end
+  end
+end