lipdub 0.1.0

data/Rakefile

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+# Define RSpec task
+RSpec::Core::RakeTask.new(:spec)
+
+# Default task
+task default: :spec
+
+# Custom tasks for gem management
+namespace :gem do
+  desc "Build the gem"
+  task :build do
+    sh "gem build lipdub.gemspec"
+  end
+
+  desc "Install the gem locally"
+  task install: :build do
+    version = File.read("lib/lipdub/version.rb").match(/VERSION = "(.+)"/)[1]
+    sh "gem install ./lipdub-#{version}.gem"
+  end
+
+  desc "Uninstall the gem"
+  task :uninstall do
+    version = File.read("lib/lipdub/version.rb").match(/VERSION = "(.+)"/)[1]
+    sh "gem uninstall lipdub -v #{version}"
+  end
+
+  desc "Clean up built gems"
+  task :clean do
+    sh "rm -f *.gem"
+  end
+
+  desc "Push gem to RubyGems"
+  task push: :build do
+    version = File.read("lib/lipdub/version.rb").match(/VERSION = "(.+)"/)[1]
+    sh "gem push lipdub-#{version}.gem"
+  end
+end

data/lib/lipdub/client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Lipdub
+  class Client
+    attr_reader :configuration
+
+    def initialize(configuration = nil)
+      @configuration = configuration || Lipdub.configuration
+      validate_configuration!
+    end
+
+    def videos
+      @videos ||= Resources::Videos.new(self)
+    end
+
+    def audios
+      @audios ||= Resources::Audios.new(self)
+    end
+
+    def shots
+      @shots ||= Resources::Shots.new(self)
+    end
+
+    def projects
+      @projects ||= Resources::Projects.new(self)
+    end
+
+    def get(path, params = {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body = {}, headers = {})
+      request(:post, path, body: body, headers: headers)
+    end
+
+    def put(path, body = {}, headers = {})
+      request(:put, path, body: body, headers: headers)
+    end
+
+    def put_file(url, file_content, content_type)
+      connection = Faraday.new do |conn|
+        conn.request :multipart
+        conn.adapter Faraday.default_adapter
+      end
+
+      response = connection.put(url) do |req|
+        req.headers['Content-Type'] = content_type
+        req.body = file_content
+      end
+
+      case response.status
+      when 200..299
+        {}  # Return empty hash for successful file uploads
+      else
+        handle_response(response)
+      end
+    end
+
+    private
+
+    def request(method, path, params: {}, body: {}, headers: {})
+      response = connection.public_send(method, path) do |req|
+        req.params.merge!(params) if params.any?
+        req.headers.merge!(headers) if headers.any?
+        req.body = body.to_json if body.any? && !body.is_a?(String)
+      end
+
+      handle_response(response)
+    rescue Faraday::TimeoutError => e
+      raise TimeoutError, "Request timed out: #{e.message}"
+    rescue Faraday::ConnectionFailed => e
+      # WebMock timeout simulation raises ConnectionFailed with "execution expired"
+      if e.message.include?("execution expired")
+        raise TimeoutError, "Request timed out: #{e.message}"
+      else
+        raise ConnectionError, "Connection failed: #{e.message}"
+      end
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: configuration.base_url) do |conn|
+        conn.request :json
+        conn.response :json, content_type: /\bjson$/
+        conn.response :json # Add fallback JSON parsing
+        conn.headers['Authorization'] = "Bearer #{configuration.api_key}"
+        conn.headers['User-Agent'] = "lipdub-ruby/#{VERSION}"
+        conn.options.timeout = configuration.timeout
+        conn.options.open_timeout = configuration.open_timeout
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        response.body || {}
+      when 401
+        raise AuthenticationError.new("Authentication failed", 
+                                     status_code: response.status, 
+                                     response_body: response.body)
+      when 422
+        raise ValidationError.new("Validation error: #{extract_error_message(response)}", 
+                                 status_code: response.status, 
+                                 response_body: response.body)
+      when 404
+        raise NotFoundError.new("Resource not found", 
+                               status_code: response.status, 
+                               response_body: response.body)
+      when 429
+        raise RateLimitError.new("Rate limit exceeded", 
+                                status_code: response.status, 
+                                response_body: response.body)
+      when 500..599
+        raise ServerError.new("Server error", 
+                             status_code: response.status, 
+                             response_body: response.body)
+      else
+        raise APIError.new("Unexpected response: #{response.status}", 
+                          status_code: response.status, 
+                          response_body: response.body)
+      end
+    end
+
+    def extract_error_message(response)
+      return response.reason_phrase unless response.body.is_a?(Hash)
+      
+      message = response.body.dig("error", "message") || 
+                response.body["message"] || 
+                response.body["error"] || 
+                response.reason_phrase
+      
+      message.to_s.empty? ? response.reason_phrase : message
+    end
+
+    def validate_configuration!
+      raise ConfigurationError, "API key is required" unless configuration.valid?
+    end
+  end
+end

data/lib/lipdub/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lipdub
+  class Configuration
+    attr_accessor :api_key, :base_url, :timeout, :open_timeout
+
+    def initialize
+      @base_url = "https://api.lipdub.ai"
+      @timeout = 30
+      @open_timeout = 10
+    end
+
+    def valid?
+      !api_key.nil? && !api_key.empty?
+    end
+  end
+end

data/lib/lipdub/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lipdub
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+
+  class APIError < Error
+    attr_reader :status_code, :response_body
+
+    def initialize(message, status_code: nil, response_body: nil)
+      super(message)
+      @status_code = status_code
+      @response_body = response_body
+    end
+  end
+
+  class AuthenticationError < APIError; end
+  class ValidationError < APIError; end
+  class NotFoundError < APIError; end
+  class RateLimitError < APIError; end
+  class ServerError < APIError; end
+  class TimeoutError < Error; end
+  class ConnectionError < Error; end
+end

data/lib/lipdub/resources/audios.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Lipdub
+  module Resources
+    class Audios < Base
+      # Initiate audio upload process
+      #
+      # @param size_bytes [Integer] Size of the audio file in bytes (1 to 104857600)
+      # @param file_name [String] Name of the audio file with extension
+      # @param content_type [String] MIME type of the audio file (audio/mpeg, audio/wav, audio/mp4)
+      # @param audio_source_url [String, nil] Optional URL of the audio source file
+      # @return [Hash] Response containing audio_id, upload_url, success_url, and failure_url
+      #
+      # @example
+      #   response = client.audios.upload(
+      #     size_bytes: 5242880,
+      #     file_name: "voiceover.mp3",
+      #     content_type: "audio/mpeg"
+      #   )
+      #   # => {
+      #   #   "data" => {
+      #   #     "audio_id" => "audio_123",
+      #   #     "upload_url" => "https://storage.lipdub.ai/upload/audio_123?token=xyz",
+      #   #     "success_url" => "https://api.lipdub.ai/v1/audio/success/audio_123",
+      #   #     "failure_url" => "https://api.lipdub.ai/v1/audio/failure/audio_123"
+      #   #   }
+      #   # }
+      def upload(size_bytes:, file_name:, content_type:, audio_source_url: nil)
+        validate_audio_params!(size_bytes, content_type)
+        
+        body = {
+          size_bytes: size_bytes,
+          file_name: file_name,
+          content_type: content_type
+        }
+        body[:audio_source_url] = audio_source_url if audio_source_url
+
+        post("/v1/audio", body)
+      end
+
+      # Upload audio file to the provided upload URL
+      #
+      # @param upload_url [String] The upload URL received from the upload method
+      # @param file_content [String, IO] The audio file content to upload
+      # @param content_type [String] MIME type of the audio file
+      # @return [Hash] Response from the upload
+      #
+      # @example
+      #   file_content = File.read("voiceover.mp3")
+      #   client.audios.upload_file(upload_url, file_content, "audio/mpeg")
+      def upload_file(upload_url, file_content, content_type)
+        put_file(upload_url, file_content, content_type)
+      end
+
+      # Complete audio upload process with a file path
+      #
+      # @param file_path [String] Path to the audio file
+      # @param content_type [String, nil] MIME type of the audio file (auto-detected if nil)
+      # @return [Hash] Response after successful upload
+      #
+      # @example
+      #   response = client.audios.upload_complete("path/to/audio.mp3")
+      #   # This method handles the entire upload flow:
+      #   # 1. Initiates upload
+      #   # 2. Uploads the file
+      #   # 3. Calls success callback
+      def upload_complete(file_path, content_type: nil)
+        raise ArgumentError, "File does not exist: #{file_path}" unless File.exist?(file_path)
+
+        file_content = File.read(file_path)
+        file_name = File.basename(file_path)
+        content_type ||= detect_content_type(file_path)
+        size_bytes = File.size(file_path)
+
+        # Step 1: Initiate upload
+        upload_response = upload(
+          size_bytes: size_bytes,
+          file_name: file_name,
+          content_type: content_type
+        )
+
+        audio_id = upload_response.dig("data", "audio_id") if upload_response.is_a?(Hash)
+        upload_url = upload_response.dig("data", "upload_url") if upload_response.is_a?(Hash)
+        
+        # Handle case where response might still be a string (fallback)
+        if upload_response.is_a?(String)
+          parsed = JSON.parse(upload_response)
+          audio_id = parsed.dig("data", "audio_id")
+          upload_url = parsed.dig("data", "upload_url")
+        end
+        
+        begin
+          # Step 2: Upload file
+          upload_file(upload_url, file_content, content_type)
+          
+          # Step 3: Mark as successful
+          success(audio_id)
+        rescue => e
+          # Step 3 (alternative): Mark as failed
+          failure(audio_id)
+          raise e
+        end
+      end
+
+      # Mark audio upload as successful
+      #
+      # @param audio_id [String] Unique identifier of the audio file
+      # @return [Hash] Response (typically empty)
+      #
+      # @example
+      #   client.audios.success("audio_123")
+      def success(audio_id)
+        post("/v1/audio/success/#{audio_id}")
+      end
+
+      # Mark audio upload as failed
+      #
+      # @param audio_id [String] Unique identifier of the audio file
+      # @return [Hash] Response (typically empty)
+      #
+      # @example
+      #   client.audios.failure("audio_123")
+      def failure(audio_id)
+        post("/v1/audio/failure/#{audio_id}")
+      end
+
+      # Get audio processing status
+      #
+      # @param audio_id [String] Unique identifier of the audio file
+      # @return [Hash] Response containing audio status information
+      #
+      # @example
+      #   status = client.audios.status("audio_123")
+      def status(audio_id)
+        get("/v1/audio/status/#{audio_id}")
+      end
+
+      # List all audio files
+      #
+      # @param page [Integer] Page number (defaults to 1)
+      # @param page_size [Integer] Number of items per page (defaults to 10)
+      # @return [Hash] Response containing list of audio files
+      #
+      # @example
+      #   audios = client.audios.list(page: 1, page_size: 20)
+      def list(page: 1, page_size: 10)
+        params = {
+          page: page,
+          page_size: page_size
+        }
+        get("/v1/audio", params)
+      end
+
+      private
+
+      def validate_audio_params!(size_bytes, content_type)
+        unless (1..104857600).include?(size_bytes)
+          raise ValidationError, "Audio file size must be between 1 and 104857600 bytes"
+        end
+
+        valid_types = %w[audio/mpeg audio/wav audio/mp4]
+        unless valid_types.include?(content_type)
+          raise ValidationError, "Content type must be one of: #{valid_types.join(', ')}"
+        end
+      end
+
+      def detect_content_type(file_path)
+        extension = File.extname(file_path).downcase
+        case extension
+        when '.mp3'
+          'audio/mpeg'
+        when '.wav'
+          'audio/wav'
+        when '.mp4', '.m4a'
+          'audio/mp4'
+        else
+          'audio/mpeg' # Default fallback
+        end
+      end
+    end
+  end
+end

data/lib/lipdub/resources/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lipdub
+  module Resources
+    class Base
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def get(path, params = {})
+        client.get(path, params)
+      end
+
+      def post(path, body = {}, headers = {})
+        client.post(path, body, headers)
+      end
+
+      def put(path, body = {}, headers = {})
+        client.put(path, body, headers)
+      end
+
+      def put_file(url, file_content, content_type)
+        client.put_file(url, file_content, content_type)
+      end
+    end
+  end
+end

data/lib/lipdub/resources/projects.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Lipdub
+  module Resources
+    class Projects < Base
+      # List all projects
+      #
+      # @param page [Integer] Page number for pagination (defaults to 1)
+      # @param per_page [Integer] Number of items per page, max 100 (defaults to 20)
+      # @return [Hash] Response containing list of projects and count
+      #
+      # @example
+      #   projects = client.projects.list(page: 1, per_page: 50)
+      #   # => {
+      #   #   "data" => [
+      #   #     {
+      #   #       "project_id" => 123,
+      #   #       "projects_tenant_id" => 1,
+      #   #       "projects_user_id" => 47,
+      #   #       "project_name" => "My Sample Project",
+      #   #       "user_email" => "user@example.com",
+      #   #       "created_at" => "2024-01-15T10:30:00Z",
+      #   #       "updated_at" => nil,
+      #   #       "source_language" => {
+      #   #         "language_id" => 1,
+      #   #         "name" => "English",
+      #   #         "supported" => true
+      #   #       },
+      #   #       "project_identity_type" => "single_identity",
+      #   #       "language_project_links" => []
+      #   #     }
+      #   #   ],
+      #   #   "count" => 1
+      #   # }
+      def list(page: 1, per_page: 20)
+        validate_pagination_params!(page, per_page)
+        
+        params = {
+          page: page,
+          per_page: per_page
+        }
+        get("/v1/projects", params)
+      end
+
+      private
+
+      def validate_pagination_params!(page, per_page)
+        raise ValidationError, "Page must be >= 1" if page < 1
+        raise ValidationError, "Per page must be between 1 and 100" unless (1..100).include?(per_page)
+      end
+    end
+  end
+end