mux_ruby 1.5.0 → 1.9.0

data/lib/mux_ruby/api_client.rb

@@ -57,33 +57,33 @@ module MuxRuby
         elsif response.code == 401
           fail UnauthorizedError.new(:code => response.code,
                                      :response_headers => response.headers,
-                                    :response_body => response.body),
-            response.status_message
+                                     :response_body => response.body,
+                                     :message => response.status_message)
         elsif response.code == 403
           fail ForbiddenError.new(:code => response.code,
                                   :response_headers => response.headers,
-                                  :response_body => response.body),
-            response.status_message
+                                  :response_body => response.body,
+                                  :message => response.status_message)
         elsif response.code == 404
           fail NotFoundError.new(:code => response.code,
                                  :response_headers => response.headers,
-                                 :response_body => response.body),
-            response.status_message
+                                 :response_body => response.body,
+                                 :message => response.status_message)
         elsif response.code == 429
           fail TooManyRequestsError.new(:code => response.code,
                                  :response_headers => response.headers,
-                                 :response_body => response.body),
-            response.status_message
+                                 :response_body => response.body,
+                                 :message => response.status_message)
         elsif response.code.between?(500, 599)
           fail ServiceError.new(:code => response.code,
                                 :response_headers => response.headers,
-                                :response_body => response.body),
-            response.status_message
+                                :response_body => response.body,
+                                :message => response.status_message)
         else
           fail ApiError.new(:code => response.code,
                             :response_headers => response.headers,
-                            :response_body => response.body),
-            response.status_message
+                            :response_body => response.body,
+                            :message => response.status_message)
         end
       end
 
@@ -280,7 +280,7 @@ module MuxRuby
     def build_request_url(path)
       # Add leading and trailing slashes to path
       path = "/#{path}".gsub(/\/+/, '/')
-      URI.encode(@config.base_url + path)
+      "#{@config.base_url}#{path}"
     end
 
     # Builds the HTTP request body

data/lib/mux_ruby/configuration.rb

@@ -3,8 +3,6 @@
 # NOTE: This file is auto generated. Do not edit this file manually.
 =end
 
-require 'uri'
-
 module MuxRuby
   class Configuration
     # Defines url scheme
@@ -167,8 +165,7 @@ module MuxRuby
     end
 
     def base_url
-      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
-      URI.encode(url)
+      "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
     end
 
     # Gets API key (with prefix if set).

data/lib/mux_ruby/models/asset.rb

@@ -7,20 +7,27 @@ require 'date'
 
 module MuxRuby
   class Asset
+    # Unique identifier for the Asset.
     attr_accessor :id
 
+    # Time at which the object was created. Measured in seconds since the Unix epoch.
     attr_accessor :created_at
 
     attr_accessor :deleted_at
 
+    # The status of the asset.
     attr_accessor :status
 
+    # The duration of the asset in seconds (max duration for a single asset is 24 hours).
     attr_accessor :duration
 
+    # The maximum resolution that has been stored for the asset. The asset may be delivered at lower resolutions depending on the device and bandwidth, however it cannot be delivered at a higher value than is stored.
     attr_accessor :max_stored_resolution
 
+    # The maximum frame rate that has been stored for the asset. The asset may be delivered at lower frame rates depending on the device and bandwidth, however it cannot be delivered at a higher value than is stored. This field may return -1 if the frame rate of the input cannot be reliably determined. 
     attr_accessor :max_stored_frame_rate
 
+    # The aspect ratio of the asset in the form of `width:height`, for example `16:9`.
     attr_accessor :aspect_ratio
 
     attr_accessor :playback_ids
@@ -31,10 +38,13 @@ module MuxRuby
 
     attr_accessor :per_title_encode
 
+    # Whether the asset is created from a live stream and the live stream is currently `active` and not in `idle` state.
     attr_accessor :is_live
 
+    # Arbitrary metadata set for the asset. Max 255 characters.
     attr_accessor :passthrough
 
+    # Unique identifier for the live stream. This is an optional parameter added when the asset is created from a live stream.
     attr_accessor :live_stream_id
 
     attr_accessor :master
@@ -43,10 +53,20 @@ module MuxRuby
 
     attr_accessor :mp4_support
 
+    # Asset Identifier of the video used as the source for creating the clip.
+    attr_accessor :source_asset_id
+
+    # Normalize the audio track loudness level. This parameter is only applicable to on-demand (not live) assets.
     attr_accessor :normalize_audio
 
     attr_accessor :static_renditions
 
+    # An array of individual live stream recording sessions. A recording session is created on each encoder connection during the live stream
+    attr_accessor :recording_times
+
+    attr_accessor :non_standard_input_reasons
+
+    # Indicates this asset is a test asset if the value is `true`. A Test asset can help evaluate the Mux Video APIs without incurring any cost. There is no limit on number of test assets created. Test assets are watermarked with the Mux logo, limited to 10 seconds, and deleted after 24 hrs.
     attr_accessor :test
 
     class EnumAttributeValidator
@@ -92,8 +112,11 @@ module MuxRuby
         :'master' => :'master',
         :'master_access' => :'master_access',
         :'mp4_support' => :'mp4_support',
+        :'source_asset_id' => :'source_asset_id',
         :'normalize_audio' => :'normalize_audio',
         :'static_renditions' => :'static_renditions',
+        :'recording_times' => :'recording_times',
+        :'non_standard_input_reasons' => :'non_standard_input_reasons',
         :'test' => :'test'
       }
     end
@@ -119,8 +142,11 @@ module MuxRuby
         :'master' => :'AssetMaster',
         :'master_access' => :'String',
         :'mp4_support' => :'String',
+        :'source_asset_id' => :'String',
         :'normalize_audio' => :'BOOLEAN',
         :'static_renditions' => :'AssetStaticRenditions',
+        :'recording_times' => :'Array<AssetRecordingTimes>',
+        :'non_standard_input_reasons' => :'AssetNonStandardInputReasons',
         :'test' => :'BOOLEAN'
       }
     end
@@ -213,6 +239,10 @@ module MuxRuby
         self.mp4_support = 'none'
       end
 
+      if attributes.has_key?(:'source_asset_id')
+        self.source_asset_id = attributes[:'source_asset_id']
+      end
+
       if attributes.has_key?(:'normalize_audio')
         self.normalize_audio = attributes[:'normalize_audio']
       else
@@ -223,6 +253,16 @@ module MuxRuby
         self.static_renditions = attributes[:'static_renditions']
       end
 
+      if attributes.has_key?(:'recording_times')
+        if (value = attributes[:'recording_times']).is_a?(Array)
+          self.recording_times = value
+        end
+      end
+
+      if attributes.has_key?(:'non_standard_input_reasons')
+        self.non_standard_input_reasons = attributes[:'non_standard_input_reasons']
+      end
+
       if attributes.has_key?(:'test')
         self.test = attributes[:'test']
       end
@@ -238,6 +278,10 @@ module MuxRuby
     # Check to see if the all the properties in the model are valid
     # @return true if the model is valid
     def valid?
+      status_validator = EnumAttributeValidator.new('String', ['preparing', 'ready', 'errored'])
+      return false unless status_validator.valid?(@status)
+      max_stored_resolution_validator = EnumAttributeValidator.new('String', ['Audio only', 'SD', 'HD', 'FHD', 'UHD'])
+      return false unless max_stored_resolution_validator.valid?(@max_stored_resolution)
       master_access_validator = EnumAttributeValidator.new('String', ['temporary', 'none'])
       return false unless master_access_validator.valid?(@master_access)
       mp4_support_validator = EnumAttributeValidator.new('String', ['standard', 'none'])
@@ -245,12 +289,32 @@ module MuxRuby
       true
     end
 
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] status Object to be assigned
+    def status=(status)
+      validator = EnumAttributeValidator.new('String', ['preparing', 'ready', 'errored'])
+      unless validator.valid?(status)
+        fail ArgumentError, "invalid value for \"status\", must be one of #{validator.allowable_values}."
+      end
+      @status = status
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] max_stored_resolution Object to be assigned
+    def max_stored_resolution=(max_stored_resolution)
+      validator = EnumAttributeValidator.new('String', ['Audio only', 'SD', 'HD', 'FHD', 'UHD'])
+      unless validator.valid?(max_stored_resolution)
+        fail ArgumentError, "invalid value for \"max_stored_resolution\", must be one of #{validator.allowable_values}."
+      end
+      @max_stored_resolution = max_stored_resolution
+    end
+
     # Custom attribute writer method checking allowed values (enum).
     # @param [Object] master_access Object to be assigned
     def master_access=(master_access)
       validator = EnumAttributeValidator.new('String', ['temporary', 'none'])
       unless validator.valid?(master_access)
-        fail ArgumentError, 'invalid value for "master_access", must be one of #{validator.allowable_values}.'
+        fail ArgumentError, "invalid value for \"master_access\", must be one of #{validator.allowable_values}."
       end
       @master_access = master_access
     end
@@ -260,7 +324,7 @@ module MuxRuby
     def mp4_support=(mp4_support)
       validator = EnumAttributeValidator.new('String', ['standard', 'none'])
       unless validator.valid?(mp4_support)
-        fail ArgumentError, 'invalid value for "mp4_support", must be one of #{validator.allowable_values}.'
+        fail ArgumentError, "invalid value for \"mp4_support\", must be one of #{validator.allowable_values}."
       end
       @mp4_support = mp4_support
     end
@@ -288,8 +352,11 @@ module MuxRuby
           master == o.master &&
           master_access == o.master_access &&
           mp4_support == o.mp4_support &&
+          source_asset_id == o.source_asset_id &&
           normalize_audio == o.normalize_audio &&
           static_renditions == o.static_renditions &&
+          recording_times == o.recording_times &&
+          non_standard_input_reasons == o.non_standard_input_reasons &&
           test == o.test
     end
 
@@ -302,7 +369,7 @@ module MuxRuby
     # Calculates hash code according to all attributes.
     # @return [Fixnum] Hash code
     def hash
-      [id, created_at, deleted_at, status, duration, max_stored_resolution, max_stored_frame_rate, aspect_ratio, playback_ids, tracks, errors, per_title_encode, is_live, passthrough, live_stream_id, master, master_access, mp4_support, normalize_audio, static_renditions, test].hash
+      [id, created_at, deleted_at, status, duration, max_stored_resolution, max_stored_frame_rate, aspect_ratio, playback_ids, tracks, errors, per_title_encode, is_live, passthrough, live_stream_id, master, master_access, mp4_support, source_asset_id, normalize_audio, static_renditions, recording_times, non_standard_input_reasons, test].hash
     end
 
     # Builds the object from hash

data/lib/mux_ruby/models/asset_errors.rb

@@ -7,8 +7,10 @@ require 'date'
 
 module MuxRuby
   class AssetErrors
+    # The type of error that occurred for this asset.
     attr_accessor :type
 
+    # Error messages with more details.
     attr_accessor :messages
 
     # Attribute mapping from ruby-style variable name to JSON key.

data/lib/mux_ruby/models/asset_master.rb

@@ -6,11 +6,34 @@
 require 'date'
 
 module MuxRuby
+  # An object containing the current status of Master Access and the link to the Master MP4 file when ready. This object does not exist if `master_acess` is set to `none` and when the temporary URL expires.
   class AssetMaster
     attr_accessor :status
 
     attr_accessor :url
 
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
@@ -54,9 +77,21 @@ module MuxRuby
     # Check to see if the all the properties in the model are valid
     # @return true if the model is valid
     def valid?
+      status_validator = EnumAttributeValidator.new('String', ['ready', 'preparing', 'errored'])
+      return false unless status_validator.valid?(@status)
       true
     end
 
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] status Object to be assigned
+    def status=(status)
+      validator = EnumAttributeValidator.new('String', ['ready', 'preparing', 'errored'])
+      unless validator.valid?(status)
+        fail ArgumentError, "invalid value for \"status\", must be one of #{validator.allowable_values}."
+      end
+      @status = status
+    end
+
     # Checks equality by comparing each attribute.
     # @param [Object] Object to be compared
     def ==(o)

data/lib/mux_ruby/models/asset_non_standard_input_reasons.rb

@@ -0,0 +1,335 @@
+=begin
+# Mux Ruby - Copyright 2019 Mux Inc.
+# NOTE: This file is auto generated. Do not edit this file manually.
+=end
+
+require 'date'
+
+module MuxRuby
+  class AssetNonStandardInputReasons
+    # The video codec used on the input file.
+    attr_accessor :video_codec
+
+    # The audio codec used on the input file.
+    attr_accessor :audio_codec
+
+    # The video key frame Interval (also called as Group of Picture or GOP) of the input file.
+    attr_accessor :video_gop_size
+
+    # The video frame rate of the input file.
+    attr_accessor :video_frame_rate
+
+    # The video resolution of the input file.
+    attr_accessor :video_resolution
+
+    # The video pixel aspect ratio of the input file.
+    attr_accessor :pixel_aspect_ratio
+
+    # Video Edit List reason indicates that the input file's video track contains a complex Edit Decision List.
+    attr_accessor :video_edit_list
+
+    # Audio Edit List reason indicates that the input file's audio track contains a complex Edit Decision List.
+    attr_accessor :audio_edit_list
+
+    # A catch-all reason when the input file in created with non-standard encoding parameters.
+    attr_accessor :unexpected_media_file_parameters
+
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'video_codec' => :'video_codec',
+        :'audio_codec' => :'audio_codec',
+        :'video_gop_size' => :'video_gop_size',
+        :'video_frame_rate' => :'video_frame_rate',
+        :'video_resolution' => :'video_resolution',
+        :'pixel_aspect_ratio' => :'pixel_aspect_ratio',
+        :'video_edit_list' => :'video_edit_list',
+        :'audio_edit_list' => :'audio_edit_list',
+        :'unexpected_media_file_parameters' => :'unexpected_media_file_parameters'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'video_codec' => :'String',
+        :'audio_codec' => :'String',
+        :'video_gop_size' => :'String',
+        :'video_frame_rate' => :'String',
+        :'video_resolution' => :'String',
+        :'pixel_aspect_ratio' => :'String',
+        :'video_edit_list' => :'String',
+        :'audio_edit_list' => :'String',
+        :'unexpected_media_file_parameters' => :'String'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      if attributes.has_key?(:'video_codec')
+        self.video_codec = attributes[:'video_codec']
+      end
+
+      if attributes.has_key?(:'audio_codec')
+        self.audio_codec = attributes[:'audio_codec']
+      end
+
+      if attributes.has_key?(:'video_gop_size')
+        self.video_gop_size = attributes[:'video_gop_size']
+      end
+
+      if attributes.has_key?(:'video_frame_rate')
+        self.video_frame_rate = attributes[:'video_frame_rate']
+      end
+
+      if attributes.has_key?(:'video_resolution')
+        self.video_resolution = attributes[:'video_resolution']
+      end
+
+      if attributes.has_key?(:'pixel_aspect_ratio')
+        self.pixel_aspect_ratio = attributes[:'pixel_aspect_ratio']
+      end
+
+      if attributes.has_key?(:'video_edit_list')
+        self.video_edit_list = attributes[:'video_edit_list']
+      end
+
+      if attributes.has_key?(:'audio_edit_list')
+        self.audio_edit_list = attributes[:'audio_edit_list']
+      end
+
+      if attributes.has_key?(:'unexpected_media_file_parameters')
+        self.unexpected_media_file_parameters = attributes[:'unexpected_media_file_parameters']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      video_gop_size_validator = EnumAttributeValidator.new('String', ['high'])
+      return false unless video_gop_size_validator.valid?(@video_gop_size)
+      video_edit_list_validator = EnumAttributeValidator.new('String', ['non-standard'])
+      return false unless video_edit_list_validator.valid?(@video_edit_list)
+      audio_edit_list_validator = EnumAttributeValidator.new('String', ['non-standard'])
+      return false unless audio_edit_list_validator.valid?(@audio_edit_list)
+      unexpected_media_file_parameters_validator = EnumAttributeValidator.new('String', ['non-standard'])
+      return false unless unexpected_media_file_parameters_validator.valid?(@unexpected_media_file_parameters)
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] video_gop_size Object to be assigned
+    def video_gop_size=(video_gop_size)
+      validator = EnumAttributeValidator.new('String', ['high'])
+      unless validator.valid?(video_gop_size)
+        fail ArgumentError, "invalid value for \"video_gop_size\", must be one of #{validator.allowable_values}."
+      end
+      @video_gop_size = video_gop_size
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] video_edit_list Object to be assigned
+    def video_edit_list=(video_edit_list)
+      validator = EnumAttributeValidator.new('String', ['non-standard'])
+      unless validator.valid?(video_edit_list)
+        fail ArgumentError, "invalid value for \"video_edit_list\", must be one of #{validator.allowable_values}."
+      end
+      @video_edit_list = video_edit_list
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] audio_edit_list Object to be assigned
+    def audio_edit_list=(audio_edit_list)
+      validator = EnumAttributeValidator.new('String', ['non-standard'])
+      unless validator.valid?(audio_edit_list)
+        fail ArgumentError, "invalid value for \"audio_edit_list\", must be one of #{validator.allowable_values}."
+      end
+      @audio_edit_list = audio_edit_list
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] unexpected_media_file_parameters Object to be assigned
+    def unexpected_media_file_parameters=(unexpected_media_file_parameters)
+      validator = EnumAttributeValidator.new('String', ['non-standard'])
+      unless validator.valid?(unexpected_media_file_parameters)
+        fail ArgumentError, "invalid value for \"unexpected_media_file_parameters\", must be one of #{validator.allowable_values}."
+      end
+      @unexpected_media_file_parameters = unexpected_media_file_parameters
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          video_codec == o.video_codec &&
+          audio_codec == o.audio_codec &&
+          video_gop_size == o.video_gop_size &&
+          video_frame_rate == o.video_frame_rate &&
+          video_resolution == o.video_resolution &&
+          pixel_aspect_ratio == o.pixel_aspect_ratio &&
+          video_edit_list == o.video_edit_list &&
+          audio_edit_list == o.audio_edit_list &&
+          unexpected_media_file_parameters == o.unexpected_media_file_parameters
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [video_codec, audio_codec, video_gop_size, video_frame_rate, video_resolution, pixel_aspect_ratio, video_edit_list, audio_edit_list, unexpected_media_file_parameters].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        MuxRuby.const_get(type).build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end