easy_ml 0.1.4 → 0.2.0.pre.rc1

data/app/controllers/easy_ml/datasources_controller.rb

@@ -0,0 +1,88 @@
+# == Schema Information
+#
+# Table name: easy_ml_datasources
+#
+#  id              :bigint           not null, primary key
+#  name            :string           not null
+#  datasource_type :string
+#  root_dir        :string
+#  configuration   :json
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+module EasyML
+  class DatasourcesController < ApplicationController
+    def index
+      @datasources = Datasource.all.order(id: :asc)
+      render inertia: "pages/DatasourcesPage", props: {
+        datasources: @datasources.map { |datasource| datasource_to_json(datasource) },
+      }
+    end
+
+    def show
+      @datasource = Datasource.find(params[:id])
+      render json: @datasource, serializer: DatasourceSerializer
+    end
+
+    def edit
+      datasource = EasyML::Datasource.find_by(id: params[:id])
+
+      render inertia: "pages/DatasourceFormPage", props: {
+        datasource: datasource_to_json(datasource),
+        constants: EasyML::Datasource.constants,
+      }
+    end
+
+    def new
+      render inertia: "pages/DatasourceFormPage", props: {
+        constants: EasyML::Datasource.constants,
+      }
+    end
+
+    def create
+      EasyML::Datasource.transaction do
+        datasource = EasyML::Datasource.create!(datasource_params)
+      end
+
+      redirect_to easy_ml_datasources_path, notice: "Datasource was successfully created."
+    rescue ActiveRecord::RecordInvalid => e
+      redirect_to new_easy_ml_datasource_path, alert: e.record.errors.full_messages.join(", ")
+    end
+
+    def destroy
+      @datasource = Datasource.find(params[:id])
+      @datasource.destroy
+
+      redirect_to easy_ml_datasources_path, notice: "Datasource was successfully deleted."
+    end
+
+    def update
+      datasource = EasyML::Datasource.find(params[:id])
+      if datasource.update(datasource_params)
+        redirect_to easy_ml_datasources_path, notice: "Datasource was successfully updated."
+      else
+        redirect_to edit_easy_ml_datasource_path(datasource), alert: datasource.errors.full_messages.join(", ")
+      end
+    end
+
+    def sync
+      datasource = Datasource.find(params[:id])
+      datasource.update(is_syncing: true)
+
+      # Start sync in background to avoid blocking
+      datasource.refresh_async
+
+      redirect_to easy_ml_datasources_path, notice: "Datasource is syncing..."
+    rescue ActiveRecord::RecordNotFound
+      redirect_to easy_ml_datasources_path, error: "Datasource not found..."
+    end
+
+    private
+
+    def datasource_params
+      params.require(:datasource).permit(:name, :s3_bucket, :s3_prefix, :s3_region, :datasource_type).merge!(
+        datasource_type: "s3",
+      )
+    end
+  end
+end

data/app/controllers/easy_ml/deploys_controller.rb

@@ -0,0 +1,20 @@
+module EasyML
+  class DeploysController < ApplicationController
+    def create
+      run = EasyML::RetrainingRun.find(params[:retraining_run_id])
+      run.update(is_deploying: true)
+      @deploy = EasyML::Deploy.create!(
+        model_id: params[:easy_ml_model_id],
+        retraining_run_id: params[:retraining_run_id],
+        trigger: "manual",
+      )
+      @deploy.deploy
+
+      flash[:notice] = "Model deployment has started"
+      redirect_to easy_ml_model_path(@deploy.model)
+    rescue => e
+      flash[:alert] = "Trouble deploying model: #{e.message}"
+      redirect_to easy_ml_model_path(@deploy.model)
+    end
+  end
+end

data/app/controllers/easy_ml/models_controller.rb

@@ -0,0 +1,151 @@
+# == Schema Information
+#
+# Table name: easy_ml_models
+#
+#  id            :bigint           not null, primary key
+#  name          :string           not null
+#  model_type    :string
+#  status        :string
+#  dataset_id    :bigint
+#  configuration :json
+#  version       :string           not null
+#  root_dir      :string
+#  file          :json
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+module EasyML
+  class ModelsController < ApplicationController
+    include EasyML::Engine.routes.url_helpers
+
+    def index
+      models = EasyML::Model.all.includes(includes_list).order(:last_trained_at, :id)
+
+      render inertia: "pages/ModelsPage", props: {
+        models: models.map { |model| model_to_json(model) },
+      }
+    end
+
+    def new
+      render inertia: "pages/NewModelPage", props: {
+        datasets: EasyML::Dataset.all.map do |dataset|
+          dataset.slice(:id, :name, :num_rows)
+        end,
+        constants: EasyML::Model.constants,
+      }
+    end
+
+    def edit
+      model = Model.includes(includes_list).find(params[:id])
+      render inertia: "pages/EditModelPage", props: {
+        model: model_to_json(model),
+        datasets: EasyML::Dataset.all.map do |dataset|
+          dataset.slice(:id, :name, :num_rows)
+        end,
+        constants: EasyML::Model.constants,
+      }
+    end
+
+    def create
+      model = Model.new(model_params)
+
+      if model.save
+        flash[:notice] = "Model was successfully created."
+        redirect_to easy_ml_models_path
+      else
+        render inertia: "pages/NewModelPage", props: {
+          datasets: EasyML::Dataset.all.map do |dataset|
+            dataset.slice(:id, :name, :num_rows)
+          end,
+          constants: EasyML::Model.constants,
+          errors: model.errors.to_hash(true),
+        }
+      end
+    end
+
+    def update
+      model = Model.find(params[:id])
+
+      if model.update(model_params)
+        flash[:notice] = "Model was successfully updated."
+        redirect_to easy_ml_models_path
+      else
+        render inertia: "pages/EditModelPage", props: {
+          model: model_to_json(model),
+          datasets: EasyML::Dataset.all.map { |dataset| dataset_to_json(dataset) },
+          constants: EasyML::Model.constants,
+          errors: model.errors.to_hash(true),
+        }
+      end
+    end
+
+    def show
+      model = Model.includes(includes_list)
+                   .find(params[:id])
+
+      if request.format.json?
+        render json: { model: model_to_json(model) }
+      else
+        render inertia: "pages/ShowModelPage", props: {
+                 model: model_to_json(model),
+               }
+      end
+    end
+
+    def destroy
+      model = Model.find(params[:id])
+
+      if model.destroy
+        flash[:notice] = "Model was successfully deleted."
+        redirect_to easy_ml_models_path
+      else
+        flash[:alert] = "Failed to delete the model."
+        redirect_to easy_ml_models_path
+      end
+    end
+
+    def train
+      model = EasyML::Model.find(params[:id])
+      model.train
+      flash[:notice] = "Model training started!"
+
+      redirect_to easy_ml_models_path
+    end
+
+    private
+
+    def includes_list
+      [:retraining_runs, :retraining_job, dataset: [:columns, :features, :splitter]]
+    end
+
+    def model_params
+      params.require(:model).permit(
+        :name,
+        :model_type,
+        :dataset_id,
+        :task,
+        :objective,
+        metrics: [],
+        retraining_job_attributes: [
+          :id,
+          :frequency,
+          :active,
+          :metric,
+          :direction,
+          :threshold,
+          :tuning_frequency,
+          :batch_mode,
+          :batch_size,
+          :batch_overlap,
+          :batch_key,
+          :tuning_enabled,
+          at: [:hour, :day_of_week, :day_of_month],
+          tuner_config: [
+            :n_trials,
+            config: {},
+          ],
+        ],
+      )
+    end
+  end
+end

data/app/controllers/easy_ml/retraining_runs_controller.rb

@@ -0,0 +1,19 @@
+module EasyML
+  class RetrainingRunsController < ApplicationController
+    def index
+      model = EasyML::Model.find(params[:id])
+      limit = (params[:limit] || 20).to_i
+      offset = (params[:offset] || 0).to_i
+
+      render json: ModelSerializer.new(
+        model,
+        params: { limit: limit, offset: offset },
+      ).serializable_hash
+    end
+
+    def show
+      run = EasyML::RetrainingRun.find(params[:id])
+      render json: RetrainingRunSerializer.new(run).serializable_hash
+    end
+  end
+end

data/app/controllers/easy_ml/settings_controller.rb

@@ -0,0 +1,59 @@
+# == Schema Information
+#
+# Table name: easy_ml_settings
+#
+#  id                   :bigint           not null, primary key
+#  storage              :string
+#  timezone             :string
+#  s3_access_key_id     :string
+#  s3_secret_access_key :string
+#  s3_bucket            :string
+#  s3_region            :string
+#  s3_prefix            :string
+#  created_at           :datetime         not null
+#  updated_at           :datetime         not null
+#
+module EasyML
+  class SettingsController < ApplicationController
+    def index
+      @settings = Settings.first_or_create
+      render inertia: "pages/SettingsPage", props: {
+        settings: { settings: settings_to_json(@settings) },
+      }
+    end
+
+    def update
+      @settings = Settings.first_or_create
+
+      @settings.update(settings_params)
+      EasyML::Configuration.configure do |config|
+        config.storage = @settings.storage
+        config.timezone = @settings.timezone
+        config.s3_access_key_id = @settings.s3_access_key_id
+        config.s3_secret_access_key = @settings.s3_secret_access_key
+        config.s3_bucket = @settings.s3_bucket
+        config.s3_region = @settings.s3_region
+        config.s3_prefix = @settings.s3_prefix
+      end
+      flash.now[:notice] = "Settings saved."
+      render inertia: "pages/SettingsPage", props: {
+        settings: @settings.as_json,
+      }
+    end
+
+    private
+
+    def settings_params
+      params.require(:settings).permit(
+        :storage,
+        :timezone,
+        :s3_access_key_id,
+        :s3_secret_access_key,
+        :s3_bucket,
+        :s3_region,
+        :s3_prefix,
+        :wandb_api_key
+      )
+    end
+  end
+end

data/app/frontend/components/AlertProvider.tsx

@@ -0,0 +1,108 @@
+import React, { createContext, useContext, useState, useCallback } from 'react';
+import { AlertCircle, CheckCircle, XCircle, X } from 'lucide-react';
+
+type AlertType = 'success' | 'error' | 'info';
+
+interface Alert {
+  id: string;
+  type: AlertType;
+  message: string;
+  isLeaving?: boolean;
+}
+
+interface AlertContextType {
+  alerts: Alert[];
+  showAlert: (type: AlertType, message: string) => void;
+  removeAlert: (id: string) => void;
+}
+
+const AlertContext = createContext<AlertContextType | undefined>(undefined);
+
+export function AlertProvider({ children }: { children: React.ReactNode }) {
+  const [alerts, setAlerts] = useState<Alert[]>([]);
+  let numSeconds = 1.25;
+
+  const removeAlert = useCallback((id: string) => {
+    setAlerts(prev => 
+      prev.map(alert => 
+        alert.id === id ? { ...alert, isLeaving: true } : alert
+      )
+    );
+
+    setTimeout(() => {
+      setAlerts(prev => prev.filter(alert => alert.id !== id));
+    }, 300);
+  }, []);
+
+  const showAlert = useCallback((type: AlertType, message: string) => {
+    const id = Math.random().toString(36).substring(7);
+    setAlerts(prev => [...prev, { id, type, message }]);
+
+    setTimeout(() => {
+      removeAlert(id);
+    }, numSeconds * 1000);
+  }, [removeAlert]);
+
+  return (
+    <AlertContext.Provider value={{ alerts, showAlert, removeAlert }}>
+      {children}
+    </AlertContext.Provider>
+  );
+}
+
+export function useAlerts() {
+  const context = useContext(AlertContext);
+  if (context === undefined) {
+    throw new Error('useAlerts must be used within an AlertProvider');
+  }
+  return context;
+}
+
+export function AlertContainer() {
+  const { alerts, removeAlert } = useAlerts();
+
+  if (alerts.length === 0) return null;
+
+  return (
+    <div className="fixed top-4 right-4 left-4 z-50 flex flex-col gap-2">
+      {alerts.map(alert => (
+        <div
+          key={alert.id}
+          className={`flex items-center justify-between p-4 rounded-lg shadow-lg 
+            transition-all duration-300 ease-in-out
+            ${alert.isLeaving ? 'opacity-0 feature -translate-y-2' : 'opacity-100'}
+            ${
+              alert.type === 'success' ? 'bg-green-50 text-green-900' :
+              alert.type === 'error' ? 'bg-red-50 text-red-900' :
+              'bg-blue-50 text-blue-900'
+            }`}
+        >
+          <div className="flex items-center gap-3">
+            {alert.type === 'success' ? (
+              <CheckCircle className={`w-5 h-5 ${
+                alert.type === 'success' ? 'text-green-500' :
+                alert.type === 'error' ? 'text-red-500' :
+                'text-blue-500'
+              }`} />
+            ) : alert.type === 'error' ? (
+              <XCircle className="w-5 h-5 text-red-500" />
+            ) : (
+              <AlertCircle className="w-5 h-5 text-blue-500" />
+            )}
+            <p className="text-sm font-medium">{alert.message}</p>
+          </div>
+          <button
+            onClick={() => removeAlert(alert.id)}
+            className={`p-1 rounded-full hover:bg-opacity-10 ${
+              alert.type === 'success' ? 'hover:bg-green-900' :
+              alert.type === 'error' ? 'hover:bg-red-900' :
+              'hover:bg-blue-900'
+            }`}
+          >
+            <X className="w-4 h-4" />
+          </button>
+        </div>
+      ))}
+    </div>
+  );
+}

data/app/frontend/components/DatasetPreview.tsx

@@ -0,0 +1,161 @@
+import React, { useState } from 'react';
+import { Database, Table, ChevronDown, ChevronUp, BarChart, ChevronLeft, ChevronRight } from 'lucide-react';
+import type { Dataset, Column } from '../types';
+
+interface DatasetPreviewProps {
+  dataset: Dataset;
+}
+
+const STATS_PER_PAGE = 6;
+
+export function DatasetPreview({ dataset }: DatasetPreviewProps) {
+  const [showStats, setShowStats] = useState(false);
+  const [currentPage, setCurrentPage] = useState(1);
+  const columns = dataset.sample_data[0] ?  Object.keys(dataset.sample_data[0]) : [];
+
+  const totalPages = Math.ceil(dataset.columns.length / STATS_PER_PAGE);
+  const paginatedColumns = dataset.columns.slice(
+    (currentPage - 1) * STATS_PER_PAGE,
+    currentPage * STATS_PER_PAGE
+  );
+
+  return (
+    <div className="bg-white rounded-lg shadow-lg p-6">
+      <div className="flex items-start justify-between mb-6">
+        <div>
+          <div className="flex items-center gap-2">
+            <Database className="w-5 h-5 text-blue-600" />
+            <h3 className="text-xl font-semibold text-gray-900">{dataset.name}</h3>
+          </div>
+          <p className="text-gray-600 mt-1">{dataset.description}</p>
+          <p className="text-sm text-gray-500 mt-2">
+            {dataset.num_rows.toLocaleString()} rows • <span className="font-medium">Raw:</span> {dataset.columns.length} columns • <span className="font-medium">Processed:</span> {columns.length} columns • Last synced{' '}
+            {new Date(dataset.updated_at).toLocaleDateString()}
+          </p>
+        </div>
+        <button
+          onClick={() => setShowStats(!showStats)}
+          className="flex items-center gap-1 text-blue-600 hover:text-blue-800"
+        >
+          <BarChart className="w-4 h-4" />
+          <span className="text-sm font-medium">
+            {showStats ? 'Hide Statistics' : 'Show Statistics'}
+          </span>
+          {showStats ? (
+            <ChevronUp className="w-4 h-4" />
+          ) : (
+            <ChevronDown className="w-4 h-4" />
+          )}
+        </button>
+      </div>
+
+      <div className="space-y-6">
+        {showStats && (
+          <>
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {paginatedColumns.map((column: Column) => (
+                <div
+                  key={column.name}
+                  className="bg-gray-50 rounded-lg p-4"
+                >
+                  <div className="flex items-center justify-between mb-2">
+                    <h4 className="font-medium text-gray-900">{column.name}</h4>
+                    <span className="text-xs font-medium text-gray-500 px-2 py-1 bg-gray-200 rounded-full">
+                      {column.datatype}
+                    </span>
+                  </div>
+                  <p className="text-sm text-gray-600 mb-3">{column.description}</p>
+                  {column.statistics && (
+                    <div className="space-y-1">
+                      {Object.entries(column.statistics.raw).map(([key, value]) => {
+                        if (key === "counts") { 
+                          return null;
+                        }
+                        return (
+                        <div key={key} className="flex justify-between text-sm">
+                          <span className="text-gray-500">
+                            {key.charAt(0).toUpperCase() + key.slice(1)}:
+                          </span>
+                          <span className="font-medium text-gray-900">
+                            {typeof value === 'number' ? 
+                              value.toLocaleString(undefined, {
+                                maximumFractionDigits: 2
+                              }) : 
+                              value}
+                          </span>
+                        </div>
+                      )})}
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+
+            {totalPages > 1 && (
+              <div className="flex items-center justify-between border-t pt-4">
+                <div className="text-sm text-gray-500">
+                  Showing {((currentPage - 1) * STATS_PER_PAGE) + 1} to {Math.min(currentPage * STATS_PER_PAGE, dataset.columns.length)} of {dataset.columns.length} columns
+                </div>
+                <div className="flex items-center gap-2">
+                  <button
+                    onClick={() => setCurrentPage(p => Math.max(1, p - 1))}
+                    disabled={currentPage === 1}
+                    className="p-1 rounded-md hover:bg-gray-100 disabled:opacity-50"
+                  >
+                    <ChevronLeft className="w-5 h-5" />
+                  </button>
+                  <span className="text-sm text-gray-600">
+                    Page {currentPage} of {totalPages}
+                  </span>
+                  <button
+                    onClick={() => setCurrentPage(p => Math.min(totalPages, p + 1))}
+                    disabled={currentPage === totalPages}
+                    className="p-1 rounded-md hover:bg-gray-100 disabled:opacity-50"
+                  >
+                    <ChevronRight className="w-5 h-5" />
+                  </button>
+                </div>
+              </div>
+            )}
+          </>
+        )}
+
+        <div className="overflow-x-auto">
+          <div className="inline-block min-w-full align-middle">
+            <div className="overflow-hidden shadow-sm ring-1 ring-black ring-opacity-5 rounded-lg">
+              <table className="min-w-full divide-y divide-gray-300">
+                <thead className="bg-gray-50">
+                  <tr>
+                    {columns.map((column) => (
+                      <th
+                        key={column}
+                        scope="col"
+                        className="px-3 py-3.5 text-left text-sm font-semibold text-gray-900"
+                      >
+                        {column}
+                      </th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-gray-200 bg-white">
+                  {dataset.sample_data.map((row: Record<string, any>, i: number) => (
+                    <tr key={i}>
+                      {columns.map((column) => (
+                        <td
+                          key={row[column]}
+                          className="whitespace-nowrap px-3 py-4 text-sm text-gray-500"
+                        >
+                          {row[column]?.toString()}
+                        </td>
+                      ))}
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

data/app/frontend/components/EmptyState.tsx

@@ -0,0 +1,28 @@
+import React from 'react';
+import { LucideIcon } from 'lucide-react';
+
+interface EmptyStateProps {
+  icon: LucideIcon;
+  title: string;
+  description: string;
+  actionLabel: string;
+  onAction: () => void;
+}
+
+export function EmptyState({ icon: Icon, title, description, actionLabel, onAction }: EmptyStateProps) {
+  return (
+    <div className="text-center py-12">
+      <div className="w-16 h-16 bg-gray-100 rounded-full flex items-center justify-center mx-auto mb-4">
+        <Icon className="w-8 h-8 text-gray-400" />
+      </div>
+      <h3 className="text-lg font-medium text-gray-900 mb-2">{title}</h3>
+      <p className="text-gray-500 mb-6 max-w-sm mx-auto">{description}</p>
+      <button
+        onClick={onAction}
+        className="inline-flex items-center gap-2 px-4 py-2 bg-blue-600 text-white text-sm font-medium rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
+      >
+        {actionLabel}
+      </button>
+    </div>
+  );
+}