fastpixapi 0.0.1

data/lib/fastpix_api_sdk/utils/retries.rb

@@ -0,0 +1,95 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday/retry'
+require 'sorbet-runtime'
+
+module FastpixApiSDK
+  module Utils
+    class BackoffStrategy
+      extend T::Sig
+
+      sig { returns(T.nilable(::Float)) }
+      attr_accessor :exponent
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :initial_interval
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :max_elapsed_time
+
+      sig { returns(T.nilable(::Integer)) }
+      attr_accessor :max_interval
+
+      sig do
+        params(
+          exponent: T.nilable(::Float),
+          initial_interval: T.nilable(::Integer),
+          max_elapsed_time: T.nilable(::Integer),
+          max_interval: T.nilable(::Integer)
+        ).void
+      end
+      def initialize(exponent: nil, initial_interval: nil, max_elapsed_time: nil, max_interval: nil)
+        @exponent = T.let(exponent, T.nilable(::Float))
+        @initial_interval = T.let(initial_interval, T.nilable(::Integer))
+        @max_elapsed_time = T.let(max_elapsed_time, T.nilable(::Integer))
+        @max_interval = T.let(max_interval, T.nilable(::Integer))
+      end
+    end
+
+    class RetryConfig
+      extend T::Sig
+
+      sig { returns(T.nilable(BackoffStrategy)) }
+      attr_accessor :backoff
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :retry_connection_errors
+
+      sig { returns(T.nilable(::String)) }
+      attr_accessor :strategy
+
+      sig do
+        params(
+          backoff: T.nilable(BackoffStrategy),
+          retry_connection_errors: T.nilable(T::Boolean),
+          strategy: T.nilable(::String)
+        ).void
+      end
+      def initialize(backoff: nil, retry_connection_errors: nil, strategy: nil)
+        @backoff = T.let(backoff, T.nilable(BackoffStrategy))
+        @retry_connection_errors = T.let(retry_connection_errors, T.nilable(T::Boolean))
+        @strategy = T.let(strategy, T.nilable(::String))
+      end
+
+      sig { params(initial_time: ::Time).returns(::Hash) }
+      def to_faraday_retry_options(initial_time:)
+        retry_options = {
+          # must overwrite default max of 2 retries and it must be positive
+          max: 1_000_000_000,
+          # ensure all HTTP methods are retried, especially via retry_if
+          methods: [],
+        }
+
+        if @retry_connection_errors
+          retry_options[:exceptions] = Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed]
+        end
+
+        if @strategy == 'backoff' && @backoff
+          retry_options[:backoff_factor] = @backoff.exponent unless @backoff.exponent.nil?
+          retry_options[:interval] = (@backoff.initial_interval.to_f / 1000) unless @backoff.initial_interval.nil?
+          retry_options[:max_interval] = @backoff.max_interval unless @backoff.max_interval.nil?
+
+          unless @backoff.max_elapsed_time.nil?
+            stop_time = initial_time + (@backoff.max_elapsed_time.to_f / 1000)
+            retry_options[:retry_if] = ->(_env, _exc) { Time.now < stop_time }
+          end
+        end
+
+        retry_options
+      end
+    end
+  end
+end

data/lib/fastpix_api_sdk/utils/security.rb

@@ -0,0 +1,133 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+
+module FastpixApiSDK
+  module Utils
+    extend T::Sig
+
+    sig { params(req: Faraday::Request, security: Object).void }
+    def self.configure_request_security(req, security)
+      return if security.nil?
+      sec_fields = security.fields
+      sec_fields.each do |sec_field|
+        value = security.send(sec_field.name)
+        next if value.nil?
+
+        metadata = sec_field.metadata[:security]
+        next if metadata.nil?
+
+        _parse_security_option(req, value) if metadata[:option]
+
+        if metadata[:scheme]
+          # Special case for basic auth which could be a flattened struct
+          if metadata[:sub_type] == 'basic' && !value.respond_to?(:fields)
+            _parse_security_scheme(req, metadata, security)
+          else
+            _parse_security_scheme(req, metadata, value)
+          end
+        end
+      end
+    end
+
+    sig { params(req: Faraday::Request, option: Object).void }
+    def self._parse_security_option(req, option)
+      opt_fields = option.fields
+      opt_fields.each do |opt_field|
+        metadata = opt_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:scheme)
+
+        _parse_security_scheme(req, metadata, option.send(opt_field.name))
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String], scheme: Object).void }
+    def self._parse_security_scheme(req, scheme_metadata, scheme)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      if scheme.respond_to? :fields
+        if scheme_type == 'http' && sub_type == 'basic'
+          _parse_basic_auth_scheme(req, scheme)
+          return
+        end
+
+        scheme_fields = scheme.fields
+        scheme_fields.each do |field|
+          metadata = field.metadata[:security]
+          next if metadata.nil? || metadata[:field_name].nil?
+
+          value = scheme.send(field.name)
+          _parse_security_scheme_value(req, scheme_metadata, metadata, value)
+        end
+      else
+        _parse_security_scheme_value(req, scheme_metadata, scheme_metadata, scheme)
+      end
+    end
+
+    sig do
+      params(req: Faraday::Request, scheme_metadata: T::Hash[Symbol, String],
+             security_metadata: T::Hash[Symbol, String], value: Object).void
+    end
+    def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
+      scheme_type = scheme_metadata[:type]
+      sub_type = scheme_metadata[:sub_type]
+
+      header_name = security_metadata[:field_name]
+
+      case scheme_type
+      when 'apiKey'
+        case sub_type
+        when 'header'
+          req.headers[header_name] = value
+        when 'query'
+          req.params[header_name] = value
+        when 'cookie'
+          req.cookies[header_name] = value
+        else
+          raise StandardError, 'not supported'
+        end
+      when 'openIdConnect'
+        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+      when 'oauth2'
+        req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+      when 'http'
+        if sub_type == 'bearer'
+          req.headers[header_name] = value.downcase.start_with?('bearer ') ? value : "Bearer #{value}"
+        elsif sub_type != 'custom'
+          raise StandardError, 'not supported'
+        end
+      else
+        raise StandardError, 'not supported'
+      end
+    end
+
+    sig { params(req: Faraday::Request, scheme: Object).void }
+    def self._parse_basic_auth_scheme(req, scheme)
+      username, password = ''
+
+      scheme_fields = scheme.fields
+      scheme_fields.each do |scheme_field|
+        metadata = scheme_field.metadata[:security]
+        next if metadata.nil? || !metadata.include?(:field_name)
+
+        field_name = metadata[:field_name]
+        value = scheme.send(scheme_field.name)
+
+        username = value if field_name == 'username'
+        password = value if field_name == 'password'
+      end
+
+      data = "#{username}:#{password}".encode
+      # Use strict_encode, because encode adds newlines after 60 chars
+      # https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
+      req.headers['Authorization'] = "Basic #{Base64.strict_encode64(data)}"
+    end
+  end
+end

data/lib/fastpix_api_sdk/utils/url.rb

@@ -0,0 +1,102 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday/retry'
+require 'sorbet-runtime'
+
+module FastpixApiSDK
+  module Utils
+    sig { params(clazz: Class, server_url: String, path: String, path_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(String) }
+    def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
+      clazz.fields.each do |f|
+        param_metadata = f.metadata[:path_param]
+        next if param_metadata.nil?
+
+        if param_metadata.fetch(:style, 'simple') == 'simple'
+          param = path_params.send(f.name) if !path_params.nil?
+          param = _populate_from_globals(f.name, param, 'pathParam', gbls)
+        end
+
+        f_name = param_metadata.fetch(:field_name, f.name)
+        serialization = param_metadata.fetch(:serialization, '')
+        if serialization != ''
+          serialized_params = _get_serialized_params(param_metadata, f_name, param)
+          serialized_params.each do |k, v|
+            path = path.sub("{#{k}}", v)
+          end
+        else
+          if param.is_a? Array
+            pp_vals = []
+            param.each do |pp_val|
+              pp_vals.append(pp_val.to_s)
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          elsif param.is_a? Hash
+            pp_vals = []
+            param.each do |pp_key, pp_val|
+              value = val_to_string(pp_val)
+
+              if param_metadata.fetch(:explode, false)
+                pp_vals.append("#{pp_key}=#{value}")
+              else
+                pp_vals.append("#{pp_key},#{value}")
+              end
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          elsif !(param.is_a?(String) || param.is_a?(Integer) ||
+            param.is_a?(Float) || param.is_a?(Complex) || param.is_a?(TrueClass) ||
+            param.is_a?(FalseClass))
+            pp_vals = []
+            attrs = param.fields.filter { |field| field.name && param.respond_to?(field.name.to_sym) }.map(&:name)
+            attrs.each do |attr|
+              field = param.field(attr)
+
+              param_value_metadata = field.metadata[:path_param]
+
+              next if param_value_metadata.nil?
+
+              parm_name = param_value_metadata.fetch(:field_name, f.name)
+
+              param_field_val = param.send(attr)
+
+              if param_field_val.is_a? T::Enum
+                param_field_val = param_field_val.serialize
+              elsif param_field_val.is_a? DateTime
+                param_field_val = param_field_val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+              end
+              if !field.nil? && T::Utils::Nilable.is_union_with_nilclass(field.type) && param_field_val.nil?
+                next
+              elsif param_metadata.fetch(:explode, false)
+                pp_vals.append("#{parm_name}=#{param_field_val}")
+              else
+                pp_vals.append("#{parm_name},#{param_field_val}")
+              end
+            end
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(','))
+          else
+            path = path.sub("{#{param_metadata.fetch(:field_name, f.name)}}", param.to_s)
+          end
+        end
+      end
+
+      server_url.delete_suffix('/') + path
+    end
+
+    sig { params(url_with_params: String, params: T::Hash[Symbol, String]).returns(String) }
+    def self.template_url(url_with_params, params)
+      params.each do |key, value|
+        if value.respond_to? :serialize
+          val_str = value.serialize
+        else
+          val_str = value
+        end
+        url_with_params = url_with_params.gsub("{#{key}}", val_str)
+      end
+
+      url_with_params
+    end
+
+  end
+end

data/lib/fastpix_api_sdk/utils/utils.rb

@@ -0,0 +1,186 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'sorbet-runtime'
+require 'base64'
+require 'stringio'
+
+module FastpixApiSDK
+  module Utils
+    extend T::Sig
+
+    sig { params(val: Object, primitives: T::Boolean).returns(Object) }
+    def self.val_to_string(val, primitives: true)
+      if val.is_a? T::Enum
+        val.serialize
+      elsif val.is_a? DateTime
+        val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+      elsif primitives
+        val.to_s
+      else
+        val
+      end
+    end
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object)
+        .returns(T::Hash[Symbol, T::Array[String]])
+    end
+    def self._get_serialized_params(metadata, field_name, obj)
+      params = {}
+
+      serialization = metadata.fetch(:serialization, '')
+      params[metadata.fetch(:field_name, field_name)] = obj.to_json if serialization == 'json'
+
+      params
+    end
+
+
+    sig { params(status: Integer).returns(T::Boolean) }
+    def self.error_status?(status)
+      status_major = status / 100
+      return true if status_major == 4
+      return true if status_major == 5
+
+      false
+    end
+
+    sig { params(content_type: String, pattern: String).returns(T::Boolean) }
+    def self.match_content_type(content_type, pattern)
+      return true if content_type == pattern || ['*', '*/*'].include?(pattern)
+
+      pieces = content_type.split(';')
+      pieces.each do |piece|
+        return true if pattern == piece.strip
+      end
+
+      false
+    end
+
+    sig { params(status_code: Integer, status_codes: T::Array[String]).returns(T::Boolean) }
+    def self.match_status_code(status_code, status_codes)
+      return true if status_codes.include? 'default'
+      status_code = status_code.to_s
+      status_codes.each do |code|
+        return true if code == status_code
+        return true if code.downcase.end_with?('xx') && status_code[0] == code[0]
+      end
+      false
+    end
+
+    sig { params(optional: T::Boolean).returns(T.proc.params(s: String).returns(DateTime)) }
+    def self.datetime_from_iso_format(optional)
+      lambda do |s|
+        return nil if optional && s.nil?
+
+        return DateTime.strptime(s, '%Y-%m-%dT%H:%M:%S.%NZ')
+      end
+    end
+
+    sig { params(optional: T::Boolean).returns(T.proc.params(s: String).returns(Date)) }
+    def self.date_from_iso_format(optional)
+      lambda do |s|
+        return nil if optional && s.nil?
+
+        return Date.iso8601(s)
+      end
+    end
+
+    sig do
+      params(enum_type: T.class_of(T::Enum), optional: T::Boolean)
+        .returns(T.proc.params(s: String).returns(T::Enum))
+    end
+    def self.enum_from_string(enum_type, optional)
+      lambda do |s|
+        return nil if optional && s.nil?
+
+        return enum_type.deserialize(s)
+      end
+    end
+
+    sig { params(name: String).returns(T.proc.returns(String)) }
+    def self.field_name(name)
+      proc { |_, field_name = name| field_name }
+    end
+
+
+    sig { params(field: ::Crystalline::MetadataFields::Field, data_class: Object).returns(Object) }
+    def self.parse_field(field, data_class)
+      field_metadata = field.metadata[:metadata_string]
+      return nil if field_metadata.nil?
+
+      field_value = data_class.send(field.name)
+      return nil if field_value.nil?
+
+      field_value
+    end
+
+    sig do
+      params(form: T::Array[T::Array[T.any(String, T::Array[T.nilable(String)])]])
+        .returns(T::Hash[Symbol, Object])
+    end
+    def self.encode_form(form)
+      payload = {}
+      form.each do |field_name, field|
+        if field.length == 2
+          if field[0].nil?
+            # Handle multiple values for the same field name (arrays)
+            if payload.key?(field_name)
+              # Convert to array if not already
+              unless payload[field_name].is_a?(Array)
+                payload[field_name] = [payload[field_name]]
+              end
+              payload[field_name] << field[1]
+            else
+              payload[field_name] = field[1]
+            end
+          else
+            # Handle file uploads
+            file_part = Faraday::Multipart::FilePart.new(
+              StringIO.new(field[1]),
+              'application/octet-stream',
+              field[0]
+            )
+            
+            # Handle multiple files for the same field name (arrays)
+            if payload.key?(field_name)
+              unless payload[field_name].is_a?(Array)
+                payload[field_name] = [payload[field_name]]
+              end
+              payload[field_name] << file_part
+            else
+              payload[field_name] = file_part
+            end
+          end
+        elsif field.length == 3
+          param_part = Faraday::Multipart::ParamPart.new(field[1].to_json, field[2])
+          
+          # Handle multiple values for the same field name (arrays)
+          if payload.key?(field_name)
+            unless payload[field_name].is_a?(Array)
+              payload[field_name] = [payload[field_name]]
+            end
+            payload[field_name] << param_part
+          else
+            payload[field_name] = param_part
+          end
+        end
+      end
+      payload
+    end
+
+    sig { params(param_name: Symbol, value: Object, param_type: String, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(Object) }
+    def self._populate_from_globals(param_name, value, param_type, gbls)
+      if value.nil? && !gbls.nil?
+        global_value = gbls.dig(:parameters, param_type.to_sym, param_name.to_sym)
+        value = global_value if !global_value.nil?
+      end
+      value
+    end
+
+  end
+end

data/lib/fastpixapi.rb

@@ -0,0 +1,29 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module FastpixApiSDK
+  autoload :SDK, 'fastpix_api_sdk/sdk'
+  autoload :StartLiveStream, 'fastpix_api_sdk/start_live_stream'
+  autoload :ManageLiveStream, 'fastpix_api_sdk/manage_live_stream'
+  autoload :Playback, 'fastpix_api_sdk/playback'
+  autoload :SimulcastStream, 'fastpix_api_sdk/simulcast_stream'
+  autoload :InputVideo, 'fastpix_api_sdk/input_video'
+  autoload :ManageVideos, 'fastpix_api_sdk/manage_videos'
+  module Models
+    autoload :Components, 'fastpix_api_sdk/models/components'
+    autoload :Operations, 'fastpix_api_sdk/models/operations'
+    autoload :Errors, 'fastpix_api_sdk/models/errors'
+  end
+end
+
+require_relative 'fastpix_api_sdk/utils/utils'
+require_relative 'fastpix_api_sdk/utils/request_bodies'
+require_relative 'fastpix_api_sdk/utils/query_params'
+require_relative 'fastpix_api_sdk/utils/forms'
+require_relative 'fastpix_api_sdk/utils/headers'
+require_relative 'fastpix_api_sdk/utils/url'
+require_relative 'fastpix_api_sdk/utils/security'
+require_relative 'crystalline'
+require_relative 'fastpix_api_sdk/sdkconfiguration'