modal-rb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d89ed493f174adebf2f5a015923904757963cae4a650fd949eb66cab0267dff
+  data.tar.gz: ff2a215607081d69ba5c164460e970a857b7f91bd7781fa44a035e380feb51a9
+SHA512:
+  metadata.gz: 2d319697b1697a8092ef7aa6644785fbf61e6ee3594740322f8736687eac163e859ad0796845bc05c3705d386e3a15a366dc5689ffb7aa938f15f15f6d980086
+  data.tar.gz: eee6a3d7c4d60075b67e92e7ec4b0150f0def437313175cd79004368831ca397233dd6af879c38800b57ec77d133270d42ab5710a6af0be5e821c678dfa1c61a

data/lib/modal/api_client.rb

@@ -0,0 +1,111 @@
+require 'grpc'
+require 'securerandom'
+
+module Modal
+  class ApiClient
+    RETRYABLE_GRPC_STATUS_CODES = Set.new([
+      GRPC::Core::StatusCodes::DEADLINE_EXCEEDED,
+      GRPC::Core::StatusCodes::UNAVAILABLE,
+      GRPC::Core::StatusCodes::CANCELLED,
+      GRPC::Core::StatusCodes::INTERNAL,
+      GRPC::Core::StatusCodes::UNKNOWN,
+    ])
+
+    def initialize
+      @profile = Config.profile
+      target, credentials = parse_server_url(@profile[:server_url])
+
+      @stub = Modal::Client::ModalClient::Stub.new(
+        target,
+        credentials,
+        channel_args: {
+          'grpc.max_receive_message_length' => 100 * 1024 * 1024, # 100 MiB
+          'grpc.max_send_message_length' => 100 * 1024 * 1024, # 100 MiB
+        }
+      )
+    end
+
+    def call(method_name, request_pb, options = {})
+      retries = options[:retries] || 3
+      base_delay = options[:base_delay] || 0.1 # seconds
+      max_delay = options[:max_delay] || 1.0 # seconds
+      delay_factor = options[:delay_factor] || 2
+      timeout = options[:timeout] # milliseconds
+
+      idempotency_key = SecureRandom.uuid
+      attempt = 0
+
+      loop do
+        metadata = {
+          'x-modal-client-type' => Modal::Client::ClientType::CLIENT_TYPE_LIBMODAL.to_s, # TODO: libmodal_rb!!!
+          'x-modal-client-version' => '1.0.0',
+          'x-modal-token-id' => @profile[:token_id],
+          'x-modal-token-secret' => @profile[:token_secret],
+          'x-idempotency-key' => idempotency_key,
+          'x-retry-attempt' => attempt.to_s,
+        }
+        metadata['x-retry-delay'] = base_delay.to_s if attempt > 0
+
+        call_options = { metadata: metadata }
+        call_options[:deadline] = Time.now + timeout / 1000.0 if timeout
+
+        begin
+          response = @stub.send(method_name, request_pb, call_options)
+          return response
+        rescue GRPC::BadStatus => e
+          if RETRYABLE_GRPC_STATUS_CODES.include?(e.code) && attempt < retries
+            puts "Retrying #{method_name} due to #{e.code} (attempt #{attempt + 1}/#{retries})"
+            sleep(base_delay)
+            base_delay = [base_delay * delay_factor, max_delay].min
+            attempt += 1
+          else
+            raise convert_grpc_error(e)
+          end
+        rescue StandardError => e
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def parse_server_url(server_url)
+      if server_url.start_with?('https://')
+        target = server_url.sub('https://', '')
+        credentials = GRPC::Core::ChannelCredentials.new
+      elsif server_url.start_with?('http://')
+        target = server_url.sub('http://', '')
+        credentials = :this_channel_is_insecure
+      else
+        target = server_url
+        credentials = GRPC::Core::ChannelCredentials.new
+      end
+
+      [target, credentials]
+    end
+
+    def convert_grpc_error(grpc_error)
+      case grpc_error.code
+      when GRPC::Core::StatusCodes::NOT_FOUND
+        NotFoundError.new(grpc_error.details)
+      when GRPC::Core::StatusCodes::FAILED_PRECONDITION
+        if grpc_error.details.include?("Secret is missing key")
+          NotFoundError.new(grpc_error.details)
+        else
+          InvalidError.new(grpc_error.details)
+        end
+      when GRPC::Core::StatusCodes::DEADLINE_EXCEEDED
+        FunctionTimeoutError.new(grpc_error.details)
+      when GRPC::Core::StatusCodes::INTERNAL, GRPC::Core::StatusCodes::UNKNOWN
+        InternalFailure.new(grpc_error.details)
+      else
+        RemoteError.new(grpc_error.details)
+      end
+    end
+  end
+
+  @client = ApiClient.new
+  def self.client
+    @client
+  end
+end

data/lib/modal/app.rb

@@ -0,0 +1,65 @@
+module Modal
+  class App
+    attr_reader :app_id
+
+    def initialize(app_id)
+      @app_id = app_id
+    end
+
+    def self.lookup(name, options = {})
+      create_if_missing = options[:create_if_missing] || false
+      environment = options[:environment]
+
+      request = Modal::Client::AppGetOrCreateRequest.new(
+        app_name: name,
+        environment_name: Config.environment_name(environment),
+        object_creation_type: create_if_missing ? Modal::Client::ObjectCreationType::OBJECT_CREATION_TYPE_CREATE_IF_MISSING : Modal::Client::ObjectCreationType::OBJECT_CREATION_TYPE_UNSPECIFIED
+      )
+
+      resp = Modal.client.call(:app_get_or_create, request)
+      new(resp.app_id)
+    end
+
+    def create_sandbox(image, options = {})
+      timeout_secs = options[:timeout] ? options[:timeout] / 1000 : 600
+      cpu_milli = (options[:cpu] || 0.125) * 1000
+      memory_mb = options[:memory] || 128
+      command = options[:command] || ["sleep", "48h"]
+
+      request = Modal::Client::SandboxCreateRequest.new(
+        app_id: @app_id,
+        definition: Modal::Client::Sandbox.new(
+          entrypoint_args: command,
+          image_id: image.image_id,
+          timeout_secs: timeout_secs,
+          network_access: Modal::Client::NetworkAccess.new(
+            network_access_type: Modal::Client::NetworkAccess::NetworkAccessType::OPEN
+          ),
+          resources: Modal::Client::Resources.new(
+            milli_cpu: cpu_milli.round,
+            memory_mb: memory_mb.round
+          )
+        )
+      )
+
+      create_resp = Modal.client.call(:sandbox_create, request)
+      Sandbox.new(create_resp.sandbox_id)
+    end
+
+    def image_from_registry(tag)
+      Image.from_registry_internal(@app_id, tag)
+    end
+
+    def image_from_aws_ecr(tag, secret)
+      unless secret.is_a?(Secret)
+        raise TypeError, "secret must be a reference to an existing Secret, e.g. `Secret.from_name('my_secret')`"
+      end
+
+      image_registry_config = Modal::Client::ImageRegistryConfig.new(
+        registry_auth_type: Modal::Client::RegistryAuthType::REGISTRY_AUTH_TYPE_AWS,
+        secret_id: secret.secret_id
+      )
+      Image.from_registry_internal(@app_id, tag, image_registry_config)
+    end
+  end
+end

data/lib/modal/cls.rb

@@ -0,0 +1,131 @@
+module Modal
+  class Cls
+    attr_reader :service_function_id, :schema, :method_names
+
+    def initialize(service_function_id, schema, method_names)
+      @service_function_id = service_function_id
+      @schema = schema
+      @method_names = method_names
+    end
+
+    def self.lookup(app_name, name, options = {})
+      service_function_name = "#{name}.*"
+      request = Modal::Client::FunctionGetRequest.new(
+        app_name: app_name,
+        object_tag: service_function_name,
+        environment_name: Config.environment_name(options[:environment])
+      )
+
+      service_function = Modal.client.call(:function_get, request)
+      parameter_info = service_function.handle_metadata&.class_parameter_info
+      schema = parameter_info&.schema || []
+
+      if schema.any? && parameter_info.format != Modal::Client::ClassParameterInfo_ParameterSerializationFormat::PARAM_SERIALIZATION_FORMAT_PROTO
+        raise "Unsupported parameter format: #{parameter_info.format}"
+      end
+
+      method_names = if service_function.handle_metadata&.method_handle_metadata
+                       service_function.handle_metadata.method_handle_metadata.keys
+                     else
+                       raise "Cls requires Modal deployments using client v0.67 or later."
+                     end
+
+      new(service_function.function_id, schema, method_names)
+    rescue NotFoundError => e
+      raise NotFoundError.new("Class '#{app_name}/#{name}' not found")
+    end
+
+    def instance(params = {})
+      function_id = if @schema.empty?
+                      @service_function_id
+                    else
+                      bind_parameters(params)
+                    end
+
+      methods = {}
+      @method_names.each do |name|
+        methods[name] = Function_.new(function_id, name)
+      end
+      ClsInstance.new(methods)
+    end
+
+    private
+
+    def bind_parameters(params)
+      serialized_params = encode_parameter_set(@schema, params)
+      request = Modal::Client::FunctionBindParamsRequest.new(
+        function_id: @service_function_id,
+        serialized_params: serialized_params
+      )
+      bind_resp = Modal.client.call(:function_bind_params, request)
+      bind_resp.bound_function_id
+    end
+
+    def encode_parameter_set(schema, params)
+      encoded_params = schema.map do |param_spec|
+        encode_parameter(param_spec, params[param_spec.name.to_sym])
+      end
+
+      encoded_params.sort_by!(&:name)
+      Modal::Client::ClassParameterSet.encode(parameters: encoded_params).to_proto
+    end
+
+    def encode_parameter(param_spec, value)
+      name = param_spec.name
+      param_type = param_spec.type
+      param_value = Modal::Client::ClassParameterValue.new(name: name, type: param_type)
+
+      case param_type
+      when Modal::Client::ParameterType::PARAM_TYPE_STRING
+        if value.nil? && param_spec.has_default
+          value = param_spec.string_default || ""
+        end
+        unless value.is_a?(String)
+          raise "Parameter '#{name}' must be a string"
+        end
+        param_value.string_value = value
+      when Modal::Client::ParameterType::PARAM_TYPE_INT
+        if value.nil? && param_spec.has_default
+          value = param_spec.int_default || 0
+        end
+        unless value.is_a?(Integer)
+          raise "Parameter '#{name}' must be an integer"
+        end
+        param_value.int_value = value
+      when Modal::Client::ParameterType::PARAM_TYPE_BOOL
+        if value.nil? && param_spec.has_default
+          value = param_spec.bool_default || false
+        end
+        unless [true, false].include?(value)
+          raise "Parameter '#{name}' must be a boolean"
+        end
+        param_value.bool_value = value
+      when Modal::Client::ParameterType::PARAM_TYPE_BYTES
+        if value.nil? && param_spec.has_default
+          value = param_spec.bytes_default || ""
+        end
+        unless value.is_a?(String)
+          raise "Parameter '#{name}' must be a byte array (String in Ruby)"
+        end
+        param_value.bytes_value = value.bytes.pack('C*')
+      else
+        raise "Unsupported parameter type: #{param_type}"
+      end
+      param_value
+    end
+  end
+
+  class ClsInstance
+    def initialize(methods)
+      @methods = methods
+    end
+
+    def method(name)
+      func = @methods[name.to_s]
+      unless func
+        raise NotFoundError.new("Method '#{name}' not found on class")
+      end
+      func
+    end
+  end
+end

data/lib/modal/config.rb

@@ -0,0 +1,69 @@
+require 'toml-rb'
+require 'fileutils'
+
+module Modal
+  module Config
+    CONFIG_FILE = File.join(Dir.home, '.modal.toml')
+
+    def self.read_config_file
+      if File.exist?(CONFIG_FILE)
+        TomlRB.parse(File.read(CONFIG_FILE))
+      else
+        {}
+      end
+    rescue StandardError => e
+      raise "Failed to read or parse .modal.toml: #{e.message}"
+    end
+
+    def self.get_profile(profile_name = nil)
+      config = read_config_file
+
+      profile_name ||= ENV['MODAL_PROFILE']
+      unless profile_name
+        config.each do |name, data|
+          if data['active']
+            profile_name = name
+            break
+          end
+        end
+      end
+
+      if profile_name && !config.key?(profile_name)
+        raise "Profile \"#{profile_name}\" not found in .modal.toml. Please set the MODAL_PROFILE environment variable or specify a valid profile."
+      end
+
+      profile_data = profile_name ? config[profile_name] : {}
+
+      server_url = ENV['MODAL_SERVER_URL'] || profile_data['server_url'] || 'https://api.modal.com'
+      token_id = ENV['MODAL_TOKEN_ID'] || profile_data['token_id']
+      token_secret = ENV['MODAL_TOKEN_SECRET'] || profile_data['token_secret']
+      environment = ENV['MODAL_ENVIRONMENT'] || profile_data['environment']
+      image_builder_version = ENV['MODAL_IMAGE_BUILDER_VERSION'] || profile_data['image_builder_version'] || '2024.10'
+
+      unless token_id && token_secret
+        raise "Profile \"#{profile_name}\" is missing token_id or token_secret. Please set them in .modal.toml or as environment variables."
+      end
+
+      {
+        server_url: server_url,
+        token_id: token_id,
+        token_secret: token_secret,
+        environment: environment,
+        image_builder_version: image_builder_version
+      }
+    end
+
+    def self.environment_name(environment = nil)
+      environment || profile[:environment] || ""
+    end
+
+    def self.image_builder_version(version = nil)
+      version || profile[:image_builder_version] || "2024.10"
+    end
+
+    @profile = get_profile
+    def self.profile
+      @profile
+    end
+  end
+end

data/lib/modal/errors.rb

@@ -0,0 +1,11 @@
+module Modal
+  class ModalError < StandardError; end
+  class FunctionTimeoutError < ModalError; end
+  class RemoteError < ModalError; end
+  class InternalFailure < ModalError; end
+  class NotFoundError < ModalError; end
+  class InvalidError < ModalError; end
+  class QueueEmptyError < ModalError; end
+  class QueueFullError < ModalError; end
+  class SandboxFilesystemError < ModalError; end
+end

data/lib/modal/function.rb

@@ -0,0 +1,122 @@
+require 'digest'
+require_relative 'pickle'
+
+module Modal
+  class Function_
+    attr_reader :function_id, :method_name
+
+    MAX_OBJECT_SIZE_BYTES = 2 * 1024 * 1024 # 2 MiB
+    MAX_SYSTEM_RETRIES = 8
+
+    def initialize(function_id, method_name = nil)
+      @function_id = function_id
+      @method_name = method_name
+    end
+
+    def self.lookup(app_name, name, options = {})
+      environment = options[:environment] || Modal::Config.environment_name
+      request = Modal::Client::FunctionGetRequest.new(
+        app_name: app_name,
+        object_tag: name,
+        environment_name: Config.environment_name(environment)
+      )
+      resp = Modal.client.call(:function_get, request)
+      new(resp.function_id)
+    rescue NotFoundError
+      raise NotFoundError.new("Function '#{app_name}/#{name}' not found")
+    end
+
+    def remote(args = [], kwargs = {})
+      input = create_input(args, kwargs)
+      invocation = ControlPlaneInvocation.create(@function_id, input, Modal::Client::FunctionCallInvocationType::FUNCTION_CALL_INVOCATION_TYPE_SYNC)
+
+      retry_count = 0
+      loop do
+        begin
+          return invocation.await_output
+        rescue InternalFailure => e
+          if retry_count <= MAX_SYSTEM_RETRIES
+            invocation.retry(retry_count)
+            retry_count += 1
+          else
+            raise e
+          end
+        end
+      end
+    end
+
+    def spawn(args = [], kwargs = {})
+      input = create_input(args, kwargs)
+      invocation = ControlPlaneInvocation.create(@function_id, input, Modal::Client::FunctionCallInvocationType::FUNCTION_CALL_INVOCATION_TYPE_ASYNC)
+      FunctionCall.new(invocation.function_call_id)
+    end
+
+    private
+
+    def create_input(args, kwargs)
+      # Create a proper Python tuple structure
+      # The Python function expects to receive (*args, **kwargs)
+      # So we need to create a tuple where:
+      # - First element is a tuple of positional args
+      # - Second element is a dict of keyword args
+
+      # Convert Ruby array to Python tuple, Ruby hash to Python dict
+      python_args = args.is_a?(Array) ? args : [args]
+      python_kwargs = kwargs.is_a?(Hash) ? kwargs : {}
+
+      # Create the payload as a tuple of (args_tuple, kwargs_dict)
+      payload = Pickle.dumps([python_args, python_kwargs])
+      args_blob_id = nil
+
+      if payload.bytesize > MAX_OBJECT_SIZE_BYTES
+        args_blob_id = blob_upload(payload)
+      end
+
+      Modal::Client::FunctionInput.new(
+        args: args_blob_id ? nil : payload,
+        args_blob_id: args_blob_id,
+        data_format: Modal::Client::DataFormat::DATA_FORMAT_PICKLE,
+        method_name: @method_name,
+        final_input: false
+      )
+    end
+
+    def blob_upload(data)
+      content_md5 = Digest::MD5.base64digest(data)
+      content_sha256 = Digest::SHA256.base64digest(data)
+      content_length = data.bytesize
+
+      request = Modal::Client::BlobCreateRequest.new(
+        content_md5: content_md5,
+        content_sha256_base64: content_sha256,
+        content_length: content_length
+      )
+      resp = Modal.client.call(:blob_create, request)
+
+      if resp.multipart
+        raise "Function input size exceeds multipart upload threshold, unsupported by this SDK version"
+      elsif resp.upload_url
+        require 'net/http'
+        require 'uri'
+
+        uri = URI.parse(resp.upload_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        req = Net::HTTP::Put.new(uri.request_uri)
+        req['Content-Type'] = 'application/octet-stream'
+        req['Content-MD5'] = content_md5
+        req.body = data
+
+        upload_resp = http.request(req)
+
+        unless upload_resp.code.to_i >= 200 && upload_resp.code.to_i < 300
+          raise "Failed blob upload: #{upload_resp.message}"
+        end
+        resp.blob_id
+      else
+        raise "Missing upload URL in BlobCreate response"
+      end
+    end
+  end
+end

data/lib/modal/function_call.rb

@@ -0,0 +1,30 @@
+require_relative 'invocation'
+
+module Modal
+  class FunctionCall
+    attr_reader :function_call_id
+
+    def initialize(function_call_id)
+      @function_call_id = function_call_id
+    end
+
+    def self.from_id(function_call_id)
+      new(function_call_id)
+    end
+
+    def get(options = {})
+      timeout = options[:timeout]
+      invocation = ControlPlaneInvocation.from_function_call_id(@function_call_id)
+      invocation.await_output(timeout)
+    end
+
+    def cancel(options = {})
+      terminate_containers = options[:terminate_containers] || false
+      request = Modal::Client::FunctionCallCancelRequest.new(
+        function_call_id: @function_call_id,
+        terminate_containers: terminate_containers
+      )
+      Modal.client.call(:function_call_cancel, request)
+    end
+  end
+end

data/lib/modal/image.rb

@@ -0,0 +1,75 @@
+module Modal
+  class Image
+    attr_reader :image_id
+
+    def initialize(image_id)
+      @image_id = image_id
+    end
+
+    def self.from_registry_internal(app_id, tag, image_registry_config = nil)
+      request = Modal::Client::ImageGetOrCreateRequest.new(
+        app_id: app_id,
+        image: Modal::Client::Image.new(
+          dockerfile_commands: ["FROM #{tag}"],
+          image_registry_config: image_registry_config
+        ),
+        namespace: Modal::Client::DeploymentNamespace::DEPLOYMENT_NAMESPACE_WORKSPACE,
+        builder_version: Config.image_builder_version
+      )
+
+      resp = Modal.client.call(:image_get_or_create, request)
+      result = resp.result
+      metadata = resp.metadata
+
+      if result && result.status != :GENERIC_STATUS_UNSPECIFIED
+        metadata = resp.metadata
+      else
+        last_entry_id = ""
+
+        loop do
+          streaming_request = Modal::Client::ImageJoinStreamingRequest.new(
+            image_id: resp.image_id,
+            timeout: 55,
+            last_entry_id: last_entry_id
+          )
+
+          puts "Waiting for image build for #{resp.image_id}..."
+
+          begin
+            stream_resp = Modal.client.call(:image_join_streaming, streaming_request)
+
+            if stream_resp.result && stream_resp.result.status != Modal::Client::GenericResult::GenericStatus::GENERIC_STATUS_UNSPECIFIED
+              result = stream_resp.result
+              metadata = stream_resp.metadata
+              break
+            end
+
+            if stream_resp.entry_id && !stream_resp.entry_id.empty?
+              last_entry_id = stream_resp.entry_id
+            end
+
+          rescue => e
+            puts "Error checking build status: #{e.message}"
+            sleep(5)
+            next
+          end
+
+          sleep(2) # Wait before next check
+        end
+      end
+
+      case result.status
+      when :GENERIC_STATUS_FAILURE
+        raise "Image build for #{resp.image_id} failed with the exception:\n#{result.exception}"
+      when :GENERIC_STATUS_TERMINATED
+        raise "Image build for #{resp.image_id} terminated due to external shut-down. Please try again."
+      when :GENERIC_STATUS_TIMEOUT
+        raise "Image build for #{resp.image_id} timed out. Please try again with a larger timeout parameter."
+      when :GENERIC_STATUS_SUCCESS
+        new(resp.image_id)
+      else
+        raise "Image build for #{resp.image_id} failed with unknown status: #{result.status}"
+      end
+    end
+  end
+end