easy_ml 0.2.0.pre.rc58 → 0.2.0.pre.rc60

data/app/serializers/easy_ml/column_serializer.rb

@@ -19,9 +19,19 @@
 #
 module EasyML
   class ColumnSerializer
+    class SmallSerializer
+      include JSONAPI::Serializer
+      attributes :id, :name
+    end
+
     include JSONAPI::Serializer
 
     attributes :id, :name, :description, :dataset_id, :datatype, :polars_datatype, :preprocessing_steps,
-               :hidden, :drop_if_null, :sample_values, :statistics, :is_target
+               :hidden, :drop_if_null, :sample_values, :statistics, :is_target,
+               :is_computed, :computed_by, :lineage
+
+    attribute :required do |object|
+      object.required?
+    end
   end
 end

data/app/serializers/easy_ml/dataset_serializer.rb

@@ -24,6 +24,27 @@ require_relative "./column_serializer"
 #
 module EasyML
   class DatasetSerializer
+    class SmallSerializer
+      include JSONAPI::Serializer
+
+      attributes :id, :name, :description, :target, :num_rows, :status,
+                 :datasource_id, :preprocessing_steps, :workflow_status, :statistics
+
+      attribute :columns do |dataset|
+        dataset.columns.order(:id).map do |column|
+          ColumnSerializer::SmallSerializer.new(column).serializable_hash.dig(:data, :attributes)
+        end
+      end
+      attribute :stacktrace do |object|
+        if !object.failed? || object.events.empty?
+          nil
+        else
+          last_event = object.events.where(status: :failed).order(id: :desc).limit(1).last
+          last_event&.stacktrace
+        end
+      end
+    end
+
     include JSONAPI::Serializer
 
     attributes :id, :name, :description, :target, :num_rows, :status,
@@ -47,7 +68,7 @@ module EasyML
       if dataset.workflow_status.to_sym == :analyzing
         nil
       else
-        dataset.data(limit: 10, all_columns: true)&.to_hashes
+        dataset.data(limit: 10, all_columns: true, refresh: false)&.to_hashes || dataset.raw.data(limit: 10, all_columns: true).to_hashes
       end
     end
 
@@ -62,7 +83,7 @@ module EasyML
     end
 
     attribute :needs_refresh do |dataset|
-      dataset.needs_refresh?
+      dataset.needs_refresh?(exclude: [:datasource_needs_refresh])
     end
 
     attribute :stacktrace do |object|

data/config/initializers/enumerable.rb

@@ -0,0 +1,17 @@
+module Enumerable
+  def count_by(&block)
+    self.group_by(&block).inject({}) do |h, (k, v)|
+      h.tap do
+        h[k] = v.count
+      end
+    end
+  end
+
+  def key_by(&block)
+    self.group_by(&block).inject({}) do |h, (k, v)|
+      h.tap do
+        h[k] = v.first
+      end
+    end
+  end
+end

data/lib/easy_ml/data/date_converter.rb

@@ -3,35 +3,104 @@ module EasyML
     module DateConverter
       COMMON_DATE_FORMATS = [
         "%Y-%m-%dT%H:%M:%S.%6N",   # e.g., "2021-01-01T00:00:00.000000"
-        "%Y-%m-%d %H:%M:%S.%L Z", # e.g., "2025-01-03 23:04:49.492 Z"
-        "%Y-%m-%d %H:%M:%S.%L",    # e.g., "2021-01-01 00:01:36.000"
-        "%Y-%m-%d %H:%M:%S.%L",   # e.g., "2021-01-01 00:01:36.000"
-        "%Y-%m-%d %H:%M:%S",      # e.g., "2021-01-01 00:01:36"
-        "%Y-%m-%d %H:%M",         # e.g., "2021-01-01 00:01"
-        "%Y-%m-%d",               # e.g., "2021-01-01"
-        "%m/%d/%Y %H:%M:%S",      # e.g., "01/01/2021 00:01:36"
-        "%m/%d/%Y",               # e.g., "01/01/2021"
-        "%d-%m-%Y",               # e.g., "01-01-2021"
-        "%d-%b-%Y %H:%M:%S",      # e.g., "01-Jan-2021 00:01:36"
-        "%d-%b-%Y",               # e.g., "01-Jan-2021"
-        "%b %d, %Y",              # e.g., "Jan 01, 2021"
-        "%Y/%m/%d %H:%M:%S",      # e.g., "2021/01/01 00:01:36"
+        "%Y-%m-%d %H:%M:%S.%L Z",   # e.g., "2025-01-03 23:04:49.492 Z"
+        "%Y-%m-%d %H:%M:%S.%L",     # e.g., "2021-01-01 00:01:36.000"
+        "%Y-%m-%d %H:%M:%S.%L",     # duplicate format intentionally
+        "%Y-%m-%d %H:%M:%S",        # e.g., "2021-01-01 00:01:36"
+        "%Y-%m-%d %H:%M",           # e.g., "2021-01-01 00:01"
+        "%Y-%m-%d",                 # e.g., "2021-01-01"
+        "%m/%d/%Y %H:%M:%S",        # e.g., "01/01/2021 00:01:36"
+        "%m/%d/%Y",                 # e.g., "01/01/2021"
+        "%d-%m-%Y",                 # e.g., "01-01-2021"
+        "%d-%b-%Y %H:%M:%S",        # e.g., "01-Jan-2021 00:01:36"
+        "%d-%b-%Y",                # e.g., "01-Jan-2021"
+        "%b %d, %Y",               # e.g., "Jan 01, 2021"
+        "%Y/%m/%d %H:%M:%S",        # e.g., "2021/01/01 00:01:36"
         "%Y/%m/%d",                # e.g., "2021/01/01"
       ].freeze
 
       FORMAT_MAPPINGS = {
         ruby_to_polars: {
           "%L" => "%3f",  # milliseconds
-          "%6N" => "%6f", # microseconds
-          "%N" => "%9f", # nanoseconds
+          "%6N" => "%6f",  # microseconds
+          "%N" => "%9f",  # nanoseconds
         },
       }.freeze
 
       class << self
-        # Attempts to convert a string column to datetime if it appears to be a date
-        # @param df [Polars::DataFrame] The dataframe containing the series
-        # @param column [String] The name of the column to convert
-        # @return [Polars::DataFrame] The dataframe with converted column (if successful)
+        # Infers a strftime format string from the given date string.
+        #
+        # @param date_str [String] The date string to analyze.
+        # @return [String, nil] The corresponding strftime format if recognized, or nil if not.
+        def infer_strftime_format(date_str)
+          return nil if date_str.blank?
+
+          # YYYY-MM-DD (e.g., "2021-01-01")
+          return "%Y-%m-%d" if date_str =~ /^\d{4}-\d{2}-\d{2}$/
+
+          # YYYY/MM/DD (e.g., "2021/01/01")
+          return "%Y/%m/%d" if date_str =~ /^\d{4}\/\d{2}\/\d{2}$/
+
+          # Date & time with T separator (ISO 8601-like)
+          if date_str.include?("T")
+            # Without fractional seconds, e.g., "2021-01-01T12:34:56"
+            return "%Y-%m-%dT%H:%M:%S" if date_str =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/
+
+            # With fractional seconds, e.g., "2021-01-01T12:34:56.789" or "2021-01-01T12:34:56.123456"
+            if date_str =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.(\d+)$/
+              fraction = Regexp.last_match(1)
+              case fraction.length
+              when 3 then return "%Y-%m-%dT%H:%M:%S.%L"  # milliseconds
+              when 6 then return "%Y-%m-%dT%H:%M:%S.%6N" # microseconds
+              when 9 then return "%Y-%m-%dT%H:%M:%S.%N"  # nanoseconds
+              else
+                # Fallback if fractional part has unexpected length:
+                return "%Y-%m-%dT%H:%M:%S.%N"
+              end
+            end
+          end
+
+          # Date & time with space separator
+          if date_str.include?(" ")
+            # Without fractional seconds, e.g., "2021-01-01 12:34:56"
+            return "%Y-%m-%d %H:%M:%S" if date_str =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/
+
+            # With fractional seconds, e.g., "2021-01-01 12:34:56.789"
+            if date_str =~ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.(\d+)$/
+              fraction = Regexp.last_match(1)
+              case fraction.length
+              when 3 then return "%Y-%m-%d %H:%M:%S.%L"
+              when 6 then return "%Y-%m-%d %H:%M:%S.%6N"
+              when 9 then return "%Y-%m-%d %H:%M:%S.%N"
+              else
+                return "%Y-%m-%d %H:%M:%S.%N"
+              end
+            end
+          end
+
+          # Common US-style formats
+
+          # MM/DD/YYYY (e.g., "01/31/2021")
+          return "%m/%d/%Y" if date_str =~ /^\d{2}\/\d{2}\/\d{4}$/
+
+          # DD-MM-YYYY (e.g., "31-01-2021")
+          return "%d-%m-%Y" if date_str =~ /^\d{2}-\d{2}-\d{4}$/
+
+          # DD-Mon-YYYY (e.g., "31-Jan-2021")
+          return "%d-%b-%Y" if date_str =~ /^\d{2}-[A-Za-z]{3}-\d{4}$/
+
+          # Mon DD, YYYY (e.g., "Jan 31, 2021")
+          return "%b %d, %Y" if date_str =~ /^[A-Za-z]{3} \d{2}, \d{4}$/
+
+          # Could add additional heuristics as needed...
+
+          nil  # Return nil if no known format matches.
+        end
+
+        # Attempts to convert a string column to datetime if it appears to be a date.
+        # @param df [Polars::DataFrame] The dataframe containing the series.
+        # @param column [String] The name of the column to convert.
+        # @return [Polars::DataFrame] The dataframe with the converted column (if successful).
         def maybe_convert_date(df, column = nil)
           if column.nil?
             series = df
@@ -40,19 +109,42 @@ module EasyML
           else
             series = df[column]
           end
+
           return df if series.dtype.is_a?(Polars::Datetime)
           return df unless series.dtype == Polars::Utf8
 
-          format = detect_polars_format(series)
-          return df unless format
+          sample = series.filter(series.is_not_null).head(100).to_a
+          ruby_format = detect_date_format(sample)
 
-          df.with_column(
-            Polars.col(column.to_s).str.strptime(Polars::Datetime, format).alias(column.to_s)
-          )
+          if ruby_format
+            format = convert_format(:ruby_to_polars, ruby_format)
+            df = try_format(df, column, format)
+
+            if df.filter(Polars.col("TRY").is_null).count > df.filter(Polars.col(column.to_s).is_null).count
+              df = df.drop("TRY")
+              best_format = df[column.to_s][0..100].to_a.count_by do |date_str|
+                infer_strftime_format(date_str)
+              end.max_by { |_format, count| count }[0]
+              df = try_format(df, column, best_format)
+            end
+
+            df = df.with_column(df["TRY"].alias(column.to_s)).drop("TRY")
+          end
+
+          df
         end
 
         private
 
+        def try_format(df, column, format)
+          df = df.with_column(
+            Polars.col(column.to_s)
+              .str
+              .strptime(Polars::Datetime, format, strict: false)
+              .alias("TRY")
+          )
+        end
+
         def detect_polars_format(series)
           return nil unless series.is_a?(Polars::Series)
 
@@ -66,14 +158,29 @@ module EasyML
 
           sample = date_strings.compact.sample([100, date_strings.length].min)
 
-          COMMON_DATE_FORMATS.detect do |format|
-            sample.all? do |date_str|
-              DateTime.strptime(date_str, format)
-              true
-            rescue StandardError
-              false
+          best_format = nil
+          best_success_rate = 0.0
+          sample_count = sample.length
+
+          COMMON_DATE_FORMATS.each do |fmt|
+            success_count = sample.count do |date_str|
+              begin
+                DateTime.strptime(date_str, fmt)
+                true
+              rescue StandardError
+                false
+              end
             end
+            success_rate = success_count.to_f / sample_count
+            if success_rate > best_success_rate
+              best_success_rate = success_rate
+              best_format = fmt
+            end
+            # If every sample string matches this format, return it immediately.
+            return fmt if success_rate == 1.0
           end
+
+          best_success_rate >= 0.8 ? best_format : nil
         end
 
         def convert_format(conversion, format)

data/lib/easy_ml/data/polars_column.rb

@@ -12,6 +12,7 @@ module EasyML
         string: Polars::String,
         text: Polars::String,
         categorical: Polars::Categorical,
+        null: Polars::Null,
       }
       POLARS_MAP = TYPE_MAP.invert.stringify_keys
       class << self
@@ -19,6 +20,20 @@ module EasyML
           POLARS_MAP.dig(polars_type.class.to_s)
         end
 
+        def parse_polars_dtype(dtype_string)
+          case dtype_string
+          when /^Polars::Datetime/
+            time_unit = dtype_string[/time_unit: "(.*?)"/, 1]
+            time_zone = dtype_string[/time_zone: (.*)?\)/, 1]
+            time_zone = time_zone == "nil" ? nil : time_zone&.delete('"')
+            Polars::Datetime.new(time_unit, time_zone)
+          when /^Polars::/
+            Polars.const_get(dtype_string.split("::").last)
+          else
+            raise ArgumentError, "Unknown Polars data type: #{dtype_string}"
+          end
+        end
+
         def sym_to_polars(symbol)
           TYPE_MAP.dig(symbol)
         end
@@ -50,6 +65,8 @@ module EasyML
               :boolean
             when Polars::Utf8
               determine_string_type(series)
+            when Polars::Null
+              :null
             else
               :categorical
             end

data/lib/easy_ml/data/polars_in_memory.rb

@@ -0,0 +1,30 @@
+module EasyML
+  module Data
+    class PolarsInMemory
+      attr_reader :df
+
+      def initialize(df)
+        @df = df
+      end
+
+      def self.query(df, **kwargs)
+        new(df).query(**kwargs)
+      end
+
+      def query(drop_cols: [], filter: nil, limit: nil, select: nil, unique: nil, sort: nil, descending: false)
+        return if df.nil?
+
+        df = self.df.clone
+        df = df.filter(filter) if filter
+        select = df.columns & ([select] || []).flatten
+        df = df.select(select) if select.present?
+        df = df.unique if unique
+        drop_cols &= df.columns
+        df = df.drop(drop_cols) unless drop_cols.empty?
+        df = df.sort(sort, reverse: descending) if sort
+        df = df.limit(limit) if limit
+        df
+      end
+    end
+  end
+end

data/lib/easy_ml/data/polars_reader.rb

@@ -12,6 +12,22 @@ module EasyML
         @schema = options[:schema]
       end
 
+      def sha
+        files = parquet_files.sort
+
+        file_hashes = files.map do |file|
+          meta = Polars.read_parquet_schema(file)
+          row_count = Polars.scan_parquet(file).select(Polars.col("*").count).collect[0, 0]
+
+          Digest::SHA256.hexdigest([
+            meta.to_json,
+            row_count.to_s,
+          ].join("|"))
+        end
+
+        Digest::SHA256.hexdigest(file_hashes.join)
+      end
+
       def schema=(value)
         @schema = value
         polars_args[:dtypes] = value
@@ -55,7 +71,10 @@ module EasyML
         return files if any_parquet? && columns.nil?
 
         puts "Converting to Parquet..."
-
+        if columns.nil? || columns.all? { |c| c.datatype.nil? }
+          learn_dataset
+          columns = nil
+        end
         csv_files.each do |path|
           df = read_file(path, columns)
           df = cast(df, columns)

data/lib/easy_ml/data/splits/in_memory_split.rb

@@ -23,7 +23,7 @@ module EasyML
         end
 
         def read(segment, split_ys: false, target: nil, drop_cols: [], filter: nil, limit: nil, select: nil,
-                          unique: nil)
+                          unique: nil, sort: nil, descending: false)
           return nil if @data.keys.none?
 
           df = if segment.to_s == "all"
@@ -33,10 +33,8 @@ module EasyML
             end
           return nil if df.nil?
 
-          df = df.filter(filter) if filter.present?
-          drop_cols &= df.columns
-          df = df.drop(drop_cols) unless drop_cols.empty?
-          df = df.unique if unique
+          df = EasyML::Data::PolarsInMemory.query(df, drop_cols: drop_cols, filter: filter, limit: limit, select: select,
+                                                      unique: unique, sort: sort, descending: descending)
 
           split_features_targets(df, split_ys, target)
         end

data/lib/easy_ml/data/splits/split.rb

@@ -7,10 +7,11 @@ module EasyML
         VALID_SEGMENTS = %w[train test valid all].freeze
 
         def initialize(options = {})
+          # Method kept for compatibility with subclasses
         end
 
         def load_data(segment, **kwargs)
-          drop_cols = dataset.drop_columns(all_columns: kwargs[:all_columns] || false)
+          drop_cols = dataset.drop_columns(all_columns: kwargs.key?(:all_columns) && kwargs[:all_columns])
           kwargs.delete(:all_columns)
           kwargs = kwargs.merge!(drop_cols: drop_cols, target: dataset.target)
           read(segment, **kwargs)

data/lib/easy_ml/data/synced_directory.rb

@@ -18,7 +18,7 @@ module EasyML
         @polars_args = options.dig(:polars_args)
       end
 
-      delegate :query, :data, :all_files, :files, to: :reader
+      delegate :query, :data, :all_files, :files, :sha, to: :reader
 
       def before_sync
         return unless should_sync?

data/lib/easy_ml/data.rb

@@ -2,11 +2,10 @@ module EasyML
   module Data
     require_relative "data/utils"
     require_relative "data/polars_reader"
+    require_relative "data/polars_in_memory"
     require_relative "data/synced_directory"
-    require_relative "data/preprocessor"
     require_relative "data/splits"
     require_relative "data/polars_column"
-    require_relative "data/statistics_learner"
     require_relative "data/date_converter"
   end
 end

data/lib/easy_ml/feature_store.rb

@@ -40,8 +40,8 @@ module EasyML
       end
     end
 
-    def query(filter: nil)
-      query_all_partitions(filter)
+    def query(**kwargs)
+      query_all_partitions(**kwargs)
     end
 
     def empty?
@@ -82,18 +82,40 @@ module EasyML
 
     private
 
+    def cleanup(type: :partitions)
+      case type
+      when :partitions
+        list_partitions.each do |partition|
+          FileUtils.rm(partition)
+        end
+      when :no_partitions
+        FileUtils.rm_rf(feature_path)
+      when :all
+        wipe
+      end
+    end
+
     def store_without_partitioning(df)
       lock_file do
+        cleanup(type: :partitions)
         path = feature_path
+        safe_write(df, path)
+      end
+    end
+
+    def safe_write(df, path)
+      begin
         FileUtils.mkdir_p(File.dirname(path))
         df.write_parquet(path)
+      rescue => e
+        binding.pry
       end
     end
 
     def store_partition(partition_df, primary_key, partition_start)
       lock_partition(partition_start) do
+        cleanup(type: :no_partitions)
         path = partition_path(partition_start)
-        FileUtils.mkdir_p(File.dirname(path))
 
         if File.exist?(path)
           reader = EasyML::Data::PolarsReader.new
@@ -101,36 +123,25 @@ module EasyML
           preserved_records = existing_df.filter(
             Polars.col(primary_key).is_in(partition_df[primary_key]).is_not
           )
-          partition_df = Polars.concat([preserved_records, partition_df], how: "vertical")
+          if preserved_records.shape[1] != partition_df.shape[1]
+            wipe
+          else
+            partition_df = Polars.concat([preserved_records, partition_df], how: "vertical")
+          end
         end
 
-        partition_df.write_parquet(path)
+        safe_write(partition_df, path)
       end
     end
 
-    def query_partitions(filter)
-      primary_key_values = filter.extract_primary_key_values
-      batch_size = feature.batch_size || 10_000
-
-      partition_files = primary_key_values.map do |key|
-        partition_start = (key / batch_size.to_f).floor * batch_size
-        partition_path(partition_start)
-      end.uniq.select { |path| File.exist?(path) }
-
-      return Polars::DataFrame.new if partition_files.empty?
-
-      reader = EasyML::Data::PolarsReader.new
-      reader.query(partition_files, filter: filter)
-    end
-
-    def query_all_partitions(filter)
+    def query_all_partitions(**kwargs)
       reader = EasyML::Data::PolarsReader.new
       pattern = File.join(feature_dir, "feature*.parquet")
       files = Dir.glob(pattern)
 
       return Polars::DataFrame.new if files.empty?
 
-      reader.query(files, filter: filter)
+      reader.query(files, **kwargs)
     end
 
     def compute_partition_boundaries(min_key, max_key, batch_size)

data/lib/easy_ml/railtie/generators/migration/migration_generator.rb

@@ -44,6 +44,10 @@ module EasyML
             add_computed_columns_to_easy_ml_columns
             add_slug_to_easy_ml_models
             add_default_to_is_target
+            remove_preprocessor_statistics_from_easy_ml_datasets
+            add_learned_at_to_easy_ml_columns
+            add_sha_to_datasources_datasets_and_columns
+            add_last_feature_sha_to_columns
           ].freeze
 
           # Specify the next migration number

data/lib/easy_ml/railtie/templates/migration/add_computed_columns_to_easy_ml_columns.rb.tt

@@ -2,13 +2,17 @@ class AddComputedColumnsToEasyMLColumns < ActiveRecord::Migration[<%= ActiveReco
   def change
     add_column :easy_ml_columns, :computed_by, :string
     add_column :easy_ml_columns, :is_computed, :boolean, default: false
+    add_column :easy_ml_columns, :feature_id, :bigint
     
     add_index :easy_ml_columns, :computed_by
     add_index :easy_ml_columns, :is_computed
+    add_index :easy_ml_columns, :feature_id
 
     add_column :easy_ml_column_histories, :computed_by, :string
     add_index :easy_ml_column_histories, :computed_by
     add_column :easy_ml_column_histories, :is_computed, :boolean, default: false
     add_index :easy_ml_column_histories, :is_computed
+    add_column :easy_ml_column_histories, :feature_id, :bigint
+    add_index :easy_ml_column_histories, :feature_id
   end
 end

data/lib/easy_ml/railtie/templates/migration/add_last_feature_sha_to_columns.rb.tt

@@ -0,0 +1,9 @@
+class AddLastFeatureShaToColumns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    add_column :easy_ml_columns, :last_feature_sha, :string
+    add_index :easy_ml_columns, :last_feature_sha
+
+    add_column :easy_ml_column_histories, :last_feature_sha, :string
+    add_index :easy_ml_column_histories, :last_feature_sha
+  end
+end

data/lib/easy_ml/railtie/templates/migration/add_learned_at_to_easy_ml_columns.rb.tt

@@ -0,0 +1,13 @@
+class AddLearnedAtToEasyMLColumns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    add_column :easy_ml_columns, :learned_at, :timestamp
+    add_column :easy_ml_columns, :is_learning, :boolean, default: false
+    add_index :easy_ml_columns, :learned_at
+    add_index :easy_ml_columns, :is_learning
+
+    add_column :easy_ml_column_histories, :learned_at, :timestamp
+    add_column :easy_ml_column_histories, :is_learning, :boolean, default: false
+    add_index :easy_ml_column_histories, :learned_at
+    add_index :easy_ml_column_histories, :is_learning
+  end
+end

data/lib/easy_ml/railtie/templates/migration/add_sha_to_datasources_datasets_and_columns.rb.tt

@@ -0,0 +1,21 @@
+class AddShaToDatasourcesDatasetsAndColumns < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    add_column :easy_ml_datasources, :sha, :string
+    add_column :easy_ml_datasets, :last_datasource_sha, :string
+
+    add_index :easy_ml_datasources, :sha
+    add_index :easy_ml_datasets, :last_datasource_sha
+
+    add_column :easy_ml_datasource_histories, :sha, :string
+    add_index :easy_ml_datasource_histories, :sha
+
+    add_column :easy_ml_dataset_histories, :last_datasource_sha, :string
+    add_index :easy_ml_dataset_histories, :last_datasource_sha
+
+    add_column :easy_ml_columns, :last_datasource_sha, :string
+    add_index :easy_ml_columns, :last_datasource_sha
+
+    add_column :easy_ml_column_histories, :last_datasource_sha, :string
+    add_index :easy_ml_column_histories, :last_datasource_sha
+  end
+end

data/lib/easy_ml/railtie/templates/migration/remove_preprocessor_statistics_from_easy_ml_datasets.rb.tt

@@ -0,0 +1,11 @@
+class RemovePreprocessorStatisticsFromEasyMLDatasets < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    if column_exists?(:easy_ml_datasets, :preprocessor_statistics)
+      remove_column :easy_ml_datasets, :preprocessor_statistics
+    end
+
+    if column_exists?(:easy_ml_dataset_histories, :preprocessor_statistics)
+      remove_column :easy_ml_dataset_histories, :preprocessor_statistics
+    end
+  end
+end

data/lib/easy_ml/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module EasyML
-  VERSION = "0.2.0-rc58"
+  VERSION = "0.2.0-rc60"
 
   module Version
   end