rager 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e1955c552055b99969da67b3e85df748ee3077b5f02c8dc46fe418801acbc24
-  data.tar.gz: 5bba65ff81cda2e4dc48711973107402379255e36d80e421d85951694df6edea
+  metadata.gz: 34c1c60d29be37b8a1f9ebb76d975257b26d89aa0345f3bdfb58290e61c82971
+  data.tar.gz: 47d3f41d9b7f9b08701c2b4b82e15cf7f86a7e3e4ffe9dced6e343ea28304597
 SHA512:
-  metadata.gz: 671cc3bc70834f3c5b476dad2dc8b6cd0413f0ec2269c7cc7a75d01244f4f511f3dcf18b6b1a208653e0dd0ee67af6ce0082603173564a103722b284e2da5c43
-  data.tar.gz: f945dd32c95854d2fe6febe850e619bc8a5c4a65b75c67a0e38e9a36219e48cf6b09a55265d9cdb499d2dbfabed8c2dfd356c836eaa88f65d7fe8747dc980bb2
+  metadata.gz: 6dfa77b1500bc0a2693141bff0c6551b72448d100f53f0e612b572d3b894ad5acc09f2cf3bb727d12141511bf902d28b3d43b2e359afc5d3fc9f172aae7caa06
+  data.tar.gz: d9522f23cd419a3b747f5e97e6097fc751008aedc3111954194de0253a24813a1919e0c5720cb653e51407e41173d80080461dadadb4590b716f638ea755444f

data/README.md

@@ -18,7 +18,7 @@ bundle add rager
 Otherwise you can add it to your Gemfile directly:
 
 ```Ruby
-gem "rager", "~> 0.3.0"
+gem "rager", "~> 0.4.0"
 ```
 
 ## License

data/lib/rager/config.rb

@@ -7,9 +7,6 @@ module Rager
   class Config
     extend T::Sig
 
-    sig { returns(Rager::Http::Adapters::Abstract) }
-    attr_accessor :http_adapter
-
     sig { returns(T.nilable(Rager::Logger)) }
     attr_accessor :logger_type
 
@@ -24,11 +21,26 @@ module Rager
 
     sig { void }
     def initialize
-      @http_adapter = T.let(Rager::Http::Adapters::AsyncHttp.new, Rager::Http::Adapters::Abstract)
+      @http_adapter = T.let(nil, T.nilable(Rager::Http::Adapters::Abstract))
       @logger_type = T.let(nil, T.nilable(Rager::Logger))
       @logger = T.let(::Logger.new($stdout), ::Logger)
       @url = T.let(nil, T.nilable(String))
       @api_key = T.let(nil, T.nilable(String))
     end
+
+    sig { returns(Rager::Http::Adapters::Abstract) }
+    def http_adapter
+      @http_adapter ||= default_http_adapter
+    end
+
+    sig { params(http_adapter: Rager::Http::Adapters::Abstract).void }
+    attr_writer :http_adapter
+
+    private
+
+    sig { returns(Rager::Http::Adapters::Abstract) }
+    def default_http_adapter
+      Rager::Http::Adapters::AsyncHttp.new
+    end
   end
 end

data/lib/rager/context.rb

@@ -12,12 +12,12 @@ module Rager
     attr_reader :id
 
     sig { returns(T.nilable(String)) }
-    attr_reader :hash
+    attr_reader :name
 
-    sig { params(id: T.nilable(String)).void }
-    def initialize(id: nil)
+    sig { params(id: T.nilable(String), name: T.nilable(String)).void }
+    def initialize(id: nil, name: nil)
       @id = T.let(id || SecureRandom.uuid, String)
-      @hash = T.let(lookup_git_hash, T.nilable(String))
+      @name = T.let(name, T.nilable(String))
     end
 
     sig do
@@ -162,7 +162,7 @@ module Rager
         output = yield(options)
 
         Result.new(
-          id: @id,
+          id: SecureRandom.uuid,
           context_id: @id,
           operation: operation,
           input: input,
@@ -171,12 +171,13 @@ module Rager
           start_time: start_time.to_i,
           end_time: Time.now.to_i,
           name: name,
+          context_name: @name,
           iids: iids,
           error: nil
         ).tap(&:log)
       rescue => e
         Result.new(
-          id: @id,
+          id: SecureRandom.uuid,
           context_id: @id,
           operation: operation,
           input: input,
@@ -185,6 +186,7 @@ module Rager
           start_time: start_time.to_i,
           end_time: Time.now.to_i,
           name: name,
+          context_name: @name,
           iids: iids,
           error: e.message
         ).tap(&:log)
@@ -192,11 +194,5 @@ module Rager
         raise e
       end
     end
-
-    sig { returns(T.nilable(String)) }
-    def lookup_git_hash
-      result = `git rev-parse HEAD`
-      $?.success? ? result.strip : nil
-    end
   end
 end

data/lib/rager/result.rb

@@ -19,15 +19,15 @@ module Rager
     sig { returns(Rager::Operation) }
     attr_reader :operation
 
-    sig { returns(Rager::Options) }
-    attr_reader :options
-
     sig { returns(Rager::Types::Input) }
     attr_reader :input
 
     sig { returns(T.nilable(Rager::Types::Output)) }
     attr_reader :output
 
+    sig { returns(Rager::Options) }
+    attr_reader :options
+
     sig { returns(Integer) }
     attr_reader :start_time
 
@@ -37,6 +37,9 @@ module Rager
     sig { returns(T.nilable(String)) }
     attr_reader :name
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :context_name
+
     sig { returns(T.nilable(T::Array[String])) }
     attr_reader :iids
 
@@ -54,6 +57,7 @@ module Rager
         start_time: Integer,
         end_time: Integer,
         name: T.nilable(String),
+        context_name: T.nilable(String),
         iids: T.nilable(T::Array[String]),
         error: T.nilable(String)
       ).void
@@ -68,6 +72,7 @@ module Rager
       start_time:,
       end_time:,
       name: nil,
+      context_name: nil,
       iids: nil,
       error: nil
     )
@@ -80,6 +85,7 @@ module Rager
       @start_time = start_time
       @end_time = end_time
       @name = T.let(name, T.nilable(String))
+      @context_name = T.let(context_name, T.nilable(String))
       @iids = T.let(iids, T.nilable(T::Array[String]))
       @error = T.let(error, T.nilable(String))
 
@@ -177,17 +183,21 @@ module Rager
     sig { returns(T::Hash[String, T.untyped]) }
     def to_h
       {
-        id: @id,
-        context_id: @context_id,
-        operation: @operation.serialize,
-        input: serialize_input,
-        output: serialize_output,
-        options: @options.serialize_safe,
-        start_time: @start_time,
-        end_time: @end_time,
-        name: @name,
-        iids: @iids,
-        error: @error
+        version: "1",
+        data: {
+          id: @id,
+          context_id: @context_id,
+          operation: @operation.serialize,
+          input: serialize_input,
+          output: serialize_output,
+          options: @options.serialize_safe,
+          start_time: @start_time,
+          end_time: @end_time,
+          name: @name,
+          context_name: @context_name,
+          iids: @iids,
+          error: @error
+        }
       }
     end
 

data/lib/rager/utils/http.rb

@@ -9,6 +9,21 @@ module Rager
     module Http
       extend T::Sig
 
+      sig { params(url: String, headers: T.nilable(T::Hash[String, String])).returns(T.nilable(String)) }
+      def self.download_binary(url, headers = nil)
+        response = Rager.config.http_adapter.make_request(
+          Rager::Http::Request.new(url: url, headers: headers || {})
+        )
+
+        if response.success? && response.body
+          binary_data = T.cast(response.body, String)
+          binary_data.force_encoding(Encoding::BINARY)
+          binary_data
+        end
+      rescue
+        nil
+      end
+
       sig { params(url: String, path: T.nilable(String), headers: T.nilable(T::Hash[String, String])).returns(String) }
       def self.download_file(url, path = nil, headers = nil)
         path ||= begin
@@ -21,16 +36,11 @@ module Rager
           end
         end
 
-        response = Rager.config.http_adapter.make_request(
-          Rager::Http::Request.new(url: url, headers: headers || {})
-        )
-
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, T.cast(response.body, T.nilable(String))) unless response.success?
+        binary_data = download_binary(url, headers)
+        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed") if binary_data.nil?
 
-        File.binwrite(path, T.cast(T.must(response.body), String))
+        File.binwrite(path, binary_data)
         path
-      rescue Rager::Errors::HttpError
-        raise
       rescue => e
         raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed: #{e.message}")
       end

data/lib/rager/utils/replicate.rb

@@ -9,26 +9,47 @@ module Rager
     module Replicate
       extend T::Sig
 
-      sig { params(prediction_url: String, key: T.nilable(String), path: T.nilable(String)).returns(T.nilable(String)) }
-      def self.download_prediction(prediction_url, key = nil, path = nil)
+      sig { params(prediction_url: String, key: T.nilable(String), http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.download_prediction(prediction_url, key = nil, http_adapter: nil)
+        download_url = get_download_url(prediction_url, key, http_adapter: http_adapter)
+        return nil if download_url.nil?
+
+        Rager::Utils::Http.download_binary(download_url)
+      rescue
+        nil
+      end
+
+      sig { params(prediction_url: String, key: T.nilable(String), path: String, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.download_prediction_to_file(prediction_url, key = nil, path:, http_adapter: nil)
+        download_url = get_download_url(prediction_url, key, http_adapter: http_adapter)
+        return nil if download_url.nil?
+
+        Rager::Utils::Http.download_file(download_url, path)
+      rescue
+        nil
+      end
+
+      sig { params(prediction_url: String, key: T.nilable(String), http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.get_download_url(prediction_url, key = nil, http_adapter: nil)
         api_key = ENV["REPLICATE_API_KEY"]
         raise Rager::Errors::MissingCredentialsError.new("Replicate", "REPLICATE_API_KEY") if api_key.nil?
 
-        response = Rager.config.http_adapter.make_request(
+        adapter = http_adapter || Rager.config.http_adapter
+        response = adapter.make_request(
           Rager::Http::Request.new(
             url: prediction_url,
             headers: {"Authorization" => "Bearer #{api_key}", "Content-Type" => "application/json"}
           )
         )
 
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, T.cast(response.body, T.nilable(String))) unless response.success?
+        raise Rager::Errors::HttpError.new(adapter, response.status, T.cast(response.body, T.nilable(String))) unless response.success?
 
         data = JSON.parse(T.cast(T.must(response.body), String))
         return nil if ["starting", "processing"].include?(data["status"])
 
         if data["status"] == "failed"
           error_msg = data["error"] || "Prediction failed"
-          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 422, "Prediction failed: #{error_msg}")
+          raise Rager::Errors::HttpError.new(adapter, 422, "Prediction failed: #{error_msg}")
         end
 
         return nil unless data["status"] == "succeeded"
@@ -47,8 +68,7 @@ module Rager
         end
 
         return nil if download_url.nil? || download_url.empty?
-
-        Rager::Utils::Http.download_file(download_url, path)
+        download_url
       rescue JSON::ParserError => e
         raise Rager::Errors::ParseError.new("Failed to parse prediction response", e.message)
       rescue Rager::Errors::HttpError, Rager::Errors::ParseError, Rager::Errors::MissingCredentialsError
@@ -57,15 +77,20 @@ module Rager
         nil
       end
 
-      sig { params(prediction_url: String, key: T.nilable(String), path: T.nilable(String), max_attempts: Integer, sleep_interval: Integer).returns(T.nilable(String)) }
-      def self.poll_prediction(prediction_url, key: nil, path: nil, max_attempts: 30, sleep_interval: 10)
+      sig { params(prediction_url: String, key: T.nilable(String), path: T.nilable(String), max_attempts: Integer, sleep_interval: Integer, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.poll_prediction(prediction_url, key: nil, path: nil, max_attempts: 30, sleep_interval: 10, http_adapter: nil)
         max_attempts.times do
-          result = download_prediction(prediction_url, key, path)
+          result = if path
+            download_prediction_to_file(prediction_url, key, path: path, http_adapter: http_adapter)
+          else
+            download_prediction(prediction_url, key, http_adapter: http_adapter)
+          end
           return result unless result.nil?
           sleep(sleep_interval)
         end
 
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 408, "Prediction polling timed out after #{max_attempts} attempts")
+        adapter = http_adapter || Rager.config.http_adapter
+        raise Rager::Errors::HttpError.new(adapter, 408, "Prediction polling timed out after #{max_attempts} attempts")
       end
     end
   end

data/lib/rager/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Rager
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rager
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - mvkvc
@@ -148,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="