stretchy-model 0.6.5 → 0.7.0

data/lib/stretchy/machine_learning/model.rb

@@ -1,6 +1,9 @@
+require 'stretchy/machine_learning/errors'
+
 module Stretchy 
   module MachineLearning
     class Model
+
       PRETRAINED_MODELS = {
         :neural_sparse => {
           :encoding => 'amazon/neural-sparse/opensearch-neural-sparse-encoding-v1',
@@ -31,7 +34,165 @@ module Stretchy
       end
 
       class << self
-        attr_accessor :model, :group_id 
+        include Errors
+        # delegate :find, :status, :deployed?, :registered?, :task_id, :deploy_id, :model_id, :register, :deploy, :undeploy, :delete, to: :model
+
+        METHODS = [
+                    :model,
+                    :group_id, 
+                    :version, 
+                    :description, 
+                    :model_format, 
+                    :enabled, 
+                    :connector_id, 
+                    :connector, 
+                    :function_name, 
+                    :model_config, 
+                    :model_content_hash_value, 
+                    :url  
+                  ]
+
+        def settings
+          @settings ||= {}
+        end
+
+        METHODS.each do |method|
+          define_method(method) do |args = nil|
+            return settings[method] unless args.present?
+            settings[method] = args
+
+            if method == :connector
+              connector_class = "#{args.to_s.camelize}".constantize
+              settings[:connector] = connector_class
+              # raise ConnectorMissingError if connector_class.id.nil?
+              settings[:connector_id] = connector_class.id
+            end
+
+            if method == :model
+              settings[:model] = model_lookup(args)
+            end
+          end
+        end
+
+        def model_id
+          @model_id || registry.model_id
+        end
+
+        def task_id
+          @task_id || registry.register_task_id
+        end
+
+        def deploy_id
+          @deploy_id || registry.deploy_task_id
+        end
+
+
+        def registry
+          @registry ||= Stretchy::MachineLearning::Registry.register(class_name: self.name, class_type: 'model')
+        end
+
+        def register
+          begin
+  
+            response = client.register(body: self.to_hash, deploy: true)
+  
+            @task_id = response['task_id']
+  
+            self.registry.update(register_task_id: @task_id)
+  
+            yield self if block_given? 
+  
+            registered?
+            self.registry.update(model_id: @model_id) 
+            @model_id
+          rescue => e
+            Stretchy.logger.error "Error registering model: #{e.message}"
+            false
+          end
+          true
+        end
+
+        def registered?
+          return false unless task_id
+          response = status
+          @model_id = response['model_id'] if response['model_id']
+          response['state'] == 'COMPLETED' && @model_id.present?
+        end
+  
+        def status
+          client.get_status(task_id: self.task_id)
+        end
+
+
+        def deploy
+          @deployed = nil
+
+          @deploy_id = client.deploy(id: self.model_id)['task_id']
+          self.registry.update(deploy_task_id: @deploy_id)
+          yield self if block_given? 
+          @deploy_id
+        end
+  
+        def undeploy
+          @deployed = nil
+          response = client.undeploy(id: self.model_id)
+          self.registry.update(deploy_task_id: nil)
+          yield self if block_given? 
+          response
+        end
+  
+        def deployed?
+          return @deployed if @deployed
+          response = client.get_model(id: self.model_id)
+          # raise "Model not deployed" if response['model_state'] == 'FAILED'
+          @deployed = response['model_state'] == 'DEPLOYED'
+        end
+  
+        def delete
+          self.registry.delete
+          client.delete_model(id: self.model_id)
+        end
+
+        def find 
+          begin
+            client.get_model(id: self.model_id)
+          rescue "#{Stretchy.configuration.search_backend_const}::Transport::Transport::Errors::InternalServerError".constantize => e
+            raise Stretchy::MachineLearning::Errors::ModelMissingError
+          end
+        end
+
+        def model_name(model_name = nil)
+          @model_name = model_name if model_name
+          @model_name || to_s.demodulize.underscore 
+        end
+  
+        def to_hash
+          {
+            name: self.model || self.model_name,
+            model_group_id: self.group_id,
+            version: self.version,
+            description: self.description,
+            model_format: self.model_format,
+            is_enabled: self.enabled?,
+            connector_id: self.connector.present? ? self.connector.id : nil,
+            function_name: self.function_name
+          }.compact
+        end
+  
+        def enabled?
+          self.enabled
+        end
+  
+        def wait_until_complete(max_attempts: 20, sleep_time: 4)
+          attempts = 0
+          loop do
+            result = yield
+            break if result
+            attempts += 1
+            break if attempts >= max_attempts
+            sleep(sleep_time)
+          end
+        end
 
         def all
           client.get_model
@@ -78,114 +239,6 @@ module Stretchy
         end
       end
 
-      attr_accessor :model,
-                    :group_id, 
-                    :version, 
-                    :description, 
-                    :model_format, 
-                    :enabled, 
-                    :connector_id, 
-                    :connector, 
-                    :function_name, 
-                    :model_config, 
-                    :model_content_hash_value, 
-                    :url
-
-      attr_reader :task_id, :model_id, :deploy_id
-
-      def initialize(args = {})
-        model_name = args.delete(:model)
-        args.each do |k,v|
-          self.send("#{k}=", v)
-        end
-        @model = self.class.model_lookup model_name
-      end
-
-      def register
-        begin
-          response = client.register(body: self.to_hash, deploy: true)
-
-          @task_id = response['task_id']
-
-          yield self if block_given? 
-
-          @model_id
-        rescue => e
-          Stretchy.logger.error "Error registering model: #{e.message}"
-          false
-        end
-        true
-      end
-
-      def registered?
-        response = status
-        @model_id = response['model_id'] if response['model_id']
-        response['state'] == 'COMPLETED' && @model_id.present?
-      end
-
-      def status
-        client.get_status(task_id: self.task_id)
-      end
-
-      def deploy
-        @deployed = nil
-        @deploy_id = client.deploy(id: self.model_id)['task_id']
-        yield self if block_given? 
-        @deploy_id
-      end
-
-      def undeploy
-        @deployed = nil
-        response = client.undeploy(id: self.model_id)
-        yield self if block_given? 
-        response
-      end
-
-      def deployed?
-        return @deployed if @deployed
-        response = client.get_model(id: self.model_id)
-        # raise "Model not deployed" if response['model_state'] == 'FAILED'
-        @deployed = response['model_state'] == 'DEPLOYED'
-      end
-
-      def delete
-        client.delete_model(id: self.model_id)
-      end
-
-      def client
-        @@client
-      end
-
-      def find 
-        client.get_model(id: self.model_id)
-      end
-
-      def to_hash
-        {
-          name: self.model,
-          model_group_id: self.group_id,
-          version: self.version,
-          description: self.description,
-          model_format: self.model_format,
-          is_enabled: self.enabled?
-        }.compact
-      end
-
-      def enabled?
-        self.enabled
-      end
-
-      def wait_until_complete(max_attempts: 20, sleep_time: 4)
-        attempts = 0
-        loop do
-          result = yield
-          break if result
-          attempts += 1
-          break if attempts >= max_attempts
-          sleep(sleep_time)
-        end
-      end
-
 
     end
   end

data/lib/stretchy/machine_learning/registry.rb

@@ -0,0 +1,19 @@
+module Stretchy::MachineLearning
+  class Registry < StretchyModel
+
+    index_name ".stretchy_ml_registry_#{Stretchy.env}"
+
+    attribute :model_id, :keyword
+    attribute :model_group_id, :keyword
+    attribute :deploy_task_id, :keyword
+    attribute :register_task_id, :keyword
+    attribute :class_name, :keyword
+    attribute :class_type, :keyword
+
+    def self.register(**args) 
+      self.create_index! unless index_exists?
+      where(class_name: args[:class_name]).first || create(**args)
+    end
+
+  end
+end

data/lib/stretchy/model/callbacks.rb

@@ -8,6 +8,7 @@ module Stretchy
         included do
           mattr_accessor :_circuit_breaker_callbacks, default: []
 
+          define_model_callbacks :initialize, only: :after
           define_model_callbacks :create, :save, :update, :destroy
           define_model_callbacks :find, :touch, only: :after
         end

data/lib/stretchy/model/common.rb

@@ -0,0 +1,157 @@
+module Stretchy
+    module Model
+        module Common
+            extend ActiveSupport::Concern
+
+            # Get the highlighted results for a specific field.
+            #
+            # This method is used to get the highlighted results for a specific field from the search results. It accepts a field for which to get the highlighted results.
+            #
+            # ### Parameters
+            #
+            # - `field:` The Symbol or String representing the field for which to get the highlighted results.
+            #
+            # ### Returns
+            # Returns an Array of Strings representing the highlighted results for the specified field.
+            #
+            # ---
+            #
+            # ### Examples
+            #
+            # #### Get the highlighted results for a field
+            #
+            # ```ruby
+            #   result = Model.query_string("name: Soph*").highlight(name: {pre_tags: "__", post_tags: "__"}).first
+            #   result.highlights_for(:name)
+            # ```
+            #
+            def highlights_for(attribute)
+                highlights[attribute.to_s]
+            end
+
+            class_methods do
+
+                # Set or get the default sort key.
+                #
+                # This method is used to set or get the default sort key to be used in sort operations. If a field is provided, it sets the field as the default sort key. If no field is provided, it returns the current default sort key.
+                #
+                # `created_at` is the default sort key.
+                #
+                # ### Parameters
+                #
+                # - `field:` The Symbol or String representing the field to be used as the default sort key (optional).
+                #
+                # ### Returns
+                # Returns the current default sort key if no field is provided. If a field is provided, it sets the field as the default sort key and returns the field.
+                #
+                # ---
+                #
+                # ### Examples
+                #
+                # #### Set the default sort key
+                #
+                # ```ruby
+                #   class Model < StretchyModel
+                #       default_sort_key :updated_at
+                #   end
+                # ```
+                #
+                # #### Get the default sort key
+                #
+                # ```ruby
+                #   Model.default_sort_key
+                # ```
+                #
+                def default_sort_key(field = nil)
+                    @default_sort_key = field unless field.nil?
+                    @default_sort_key
+                end
+
+
+                # Set or get the default size.
+                #
+                # This method is used to set or get the default size to be used in operations that return documents. If a size is provided, it sets the size as the default size. 
+                # If no size is provided, it returns the current default size.
+                # 
+                # 10000 is the default size for StretchyModel
+                #
+                # ### Parameters
+                #
+                # - `size:` The Integer representing the size to be used as the default size (optional).
+                #
+                # ### Returns
+                # Returns the current default size if no size is provided. If a size is provided, it sets the size as the default size and returns the size.
+                #
+                # ---
+                #
+                # ### Examples
+                #
+                # #### Set the default size
+                #
+                # ```ruby
+                #   class Model < StretchyModel
+                #       default_size 100
+                #   end
+                # ```
+                #
+                # #### Get the default size
+                #
+                # ```ruby
+                #   Model.default_size
+                # ```
+                #
+                def default_size(size = nil)
+                    @default_size = size unless size.nil?
+                    @default_size
+                end
+
+                
+                # Set or get the default pipeline.
+                #
+                # This method is used to set or get the default pipeline at the index level to be used in operations that require a pipeline. 
+                #  
+                # If a pipeline is provided, it sets the pipeline as the default pipeline. 
+                # If no pipeline is provided, it returns the current default pipeline.
+                #
+                # ### Parameters
+                #
+                # - `pipeline:` The String representing the pipeline to be used as the default pipeline (optional).
+                #
+                # ### Returns
+                # Returns the current default pipeline if no pipeline is provided. If a pipeline is provided, it sets the pipeline as the default pipeline and returns the pipeline.
+                #
+                # ---
+                #
+                # ### Examples
+                #
+                # #### Set the default pipeline
+                #
+                # ```ruby
+                #   class Model < StretchyModel
+                #       default_pipeline 'my_pipeline'
+                #   end
+                # ```
+                #
+                # #### Get the default pipeline
+                #
+                # ```ruby
+                #   Model.default_pipeline
+                # ```
+                #
+                def default_pipeline(pipeline = nil)
+                    @default_pipeline = pipeline.to_s unless pipeline.nil?
+                    @default_pipeline
+                end
+
+                private
+
+                # Return a Relation instance to chain queries
+                #
+                def relation
+                    Relation.create(self, {})
+                end
+
+            end
+        end
+    end
+end

data/lib/stretchy/model/persistence.rb

@@ -0,0 +1,144 @@
+module Stretchy
+    module Model
+        module Persistence
+            extend ActiveSupport::Concern
+
+            class_methods do
+                # Create a new instance and save it to the database.
+                #
+                # This class method is used to create a new instance of the model and save it to the database. It accepts a list of keyword attributes to set on the new instance.
+                #
+                # ### Parameters
+                #
+                # - `*args:` A list of keyword arguments representing the attributes to set on the new instance.
+                #
+                # ### Returns
+                # Returns the newly created instance of the model.
+                #
+                # ---
+                #
+                # ### Examples
+                #
+                # #### Create a new instance
+                #
+                # ```ruby
+                #   Model.create(name: 'John Doe', age: 30)
+                # ```
+                #
+                def create(*args)
+                    self.new(*args).save
+                end
+            end
+
+            # Save the current instance to the database.
+            #
+            # This instance method is used to save the current instance of the model to the database. If the instance is a new record, it runs the `:create` callbacks and saves the instance to the database. It then sets the `id` of the instance to the `_id` returned by the save operation.
+            #
+            # ### Returns
+            # Returns the `id` of the saved instance.
+            #
+            # ---
+            #
+            # ### Examples
+            #
+            # #### Save an instance
+            #
+            # ```ruby
+            #   model = Model.new(name: 'John Doe', age: 30)
+            #   model.save
+            # ```
+            #
+            def save
+                run_callbacks :save do
+                    if new_record?
+                        run_callbacks :create do
+                            response = self.class.gateway.save(self.attributes)
+                            self.id = response['_id']
+                        end
+                    else
+                        self.class.gateway.save(self.attributes)
+                    end
+                    self
+                end
+            end
+
+            # Destroy the current instance.
+            #
+            # This instance method is used to delete the current instance of the model from the database. 
+            # It differs from delete in that it runs the `:destroy` callbacks before deleting the instance.
+            # 
+            #
+            # ### Returns
+            # Returns `true` if the instance was successfully deleted, `false` otherwise.
+            #
+            # ---
+            #
+            # ### Examples
+            #
+            # #### Delete an instance
+            #
+            # ```ruby
+            #   model = Model.find(id: '1')
+            #   model.destroy
+            # ```
+            #
+            def destroy
+                run_callbacks :destroy do
+                    delete
+                end
+            end
+
+            # Delete the current instance from the database.
+            #
+            # This instance method is used to delete the current instance of the model from the database. It uses the `id` of the instance to perform the delete operation.
+            #
+            # ### Returns
+            # Returns `true` if the instance was successfully deleted, `false` otherwise.
+            #
+            # ---
+            #
+            # ### Examples
+            #
+            # #### Delete an instance
+            #
+            # ```ruby
+            #   model = Model.find(id: '1')
+            #   model.delete
+            # ```
+            #
+            def delete
+                self.class.gateway.delete(self.id)["result"] == 'deleted'
+            end
+
+            # Update the current instance with the given attributes and save it to the database.
+            #
+            # This instance method is used to update the current instance of the model with the given attributes and save it to the database. It accepts a list of keyword arguments representing the attributes to update.
+            #
+            # ### Parameters
+            #
+            # - `*args:` A list of keyword arguments representing the attributes to update.
+            #
+            # ### Returns
+            # Returns `true` if the instance was successfully updated, `false` otherwise.
+            #
+            # ---
+            #
+            # ### Examples
+            #
+            # #### Update an instance
+            #
+            # ```ruby
+            #   model = Model.find(id: '1')
+            #   model.update(name: 'Jane Doe', age: 32)
+            # ```
+            #
+            def update(*args)
+                run_callbacks :update do
+                    self.assign_attributes(*args)
+                    self.save
+                end
+            end
+
+        end
+    end
+end

data/lib/stretchy/model/refreshable.rb

@@ -0,0 +1,26 @@
+module Stretchy
+  module Model
+    # Adds callbacks to the model to refresh the index after save or destroy.
+    #
+    # ```ruby
+    # included do
+    #   after_save :refresh_index
+    #   after_destroy :refresh_index
+    # end
+    # ```
+    module Refreshable
+      extend ActiveSupport::Concern
+
+      
+      included do
+        after_save :refresh_index
+        after_destroy :refresh_index
+      end
+
+      def refresh_index
+        self.class.refresh_index!
+      end
+
+    end
+  end
+end

data/lib/stretchy/open_search_compatibility.rb

@@ -1,4 +1,5 @@
 require 'opensearch/api/namespace/machine_learning/model'
+require 'opensearch/api/namespace/connector'
 
 module Stretchy
     module OpenSearchCompatibility
@@ -82,6 +83,7 @@ module Stretchy
             ::Elasticsearch::Persistence::Repository.send(:include, patch)
             ::Elasticsearch::Persistence::Repository.send(:include, store)
             OpenSearch::API.send(:include, OpenSearch::API::MachineLearning::Models)
+            OpenSearch::API.send(:include, OpenSearch::API::Connector)
 
         end
 

data/lib/stretchy/pipeline.rb

@@ -30,7 +30,8 @@ module Stretchy
         end
       end
     
-      def find(id)
+      def find(id=nil)
+        id = self.pipeline_name if id.nil?
         client.get_pipeline(id: id)
       end