x 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ff134774b6d6b28f3f72c740c74b1f44b11ce94cff63fbfe4eabc0414f600c3
-  data.tar.gz: 9f3b9abd3ca2628979676b5f634781b960adf6afe8a77559cf6f3a96ee738098
+  metadata.gz: 4a01e8a21951f3b998cfae0253c4d35c5412ac39f94681283b9059d4a196651e
+  data.tar.gz: 5b4a5bb02d86b27391b005acb329893025222c20e9d0c99b88ed0d7e6322dc5e
 SHA512:
-  metadata.gz: cd471d0b216161f5e68832e83b5024a8a89cdda1c815f49543f8361b225776ad46f84690eddf9a9b884cf0ab540924ecae94ebd145f26ac07e44ffdf7c4ff1f2
-  data.tar.gz: 3670666ca95e154a253be800af600cdcaf44195b9dcd3d001e1404d85f27dd5939ce09bd25588cfbe81cefef92ce22bfcd26e105dcb70d813bc4efa221a4360d
+  metadata.gz: 8972eafdb4c041a61258f409fef5a93dc0ff56b70e5c8dd384e126652c1ab32a4e52dc56bd253d7c204ea6313e3ac321e93c7245c722c0d5491b59443c63435a
+  data.tar.gz: 4a5dfb958b61b78cdcf9312250d3ba00182894241da1c3e9114f08f1029fb174be07043f607a864986e3d09d6d308dfac4d13549e2483d5746235b34c4dd05a2

data/CHANGELOG.md

@@ -1,4 +1,13 @@
-## [Unreleased]
+## [0.10.0] - 2023-10-08
+
+- Add media upload helper methods (6c6a267)
+- Add PayloadTooLargeError class (cd61850)
+
+## [0.9.1] - 2023-10-06
+
+- Allow successful empty responses (06bf7db)
+- Update default User-Agent string (296b36a)
+- Move query parameter escaping into RequestBuilder (56d6bd2)
 
 ## [0.9.0] - 2023-09-26
 

data/README.md

@@ -90,6 +90,14 @@ Building and maintaining an open-source project like this takes a considerable a
 
 [Click here to sponsor this project.](https://github.com/sponsors/sferik)
 
+## Sponsors
+
+Many thanks to our sponsors (listed in order of when they sponsored this project):
+
+<a href="https://betterstack.com"><img src="https://raw.githubusercontent.com/sferik/x-ruby/main/sponsor_logos/better_stack.svg" alt="Better Stack" width="200" align="middle"></a>
+<img src="https://raw.githubusercontent.com/sferik/x-ruby/main/sponsor_logos/spacer.png" width="20" align="middle">
+<a href="https://sentry.io"><img src="https://raw.githubusercontent.com/sferik/x-ruby/main/sponsor_logos/sentry.svg" alt="Sentry" width="200" align="middle"></a>
+
 ## Development
 
 1. Checkout and repo:

data/lib/x/client.rb

@@ -19,6 +19,9 @@ module X
     def_delegators :@request_builder, :content_type=, :user_agent=
     def_delegators :@response_handler, :array_class, :object_class
     def_delegators :@response_handler, :array_class=, :object_class=
+    alias_method :base_url, :base_uri
+    alias_method :base_url=, :base_uri=
+    attr_accessor :authenticator, :connection, :request_builder, :redirect_handler, :response_handler
 
     def initialize(bearer_token: nil,
       api_key: nil, api_key_secret: nil, access_token: nil, access_token_secret: nil,

data/lib/x/connection.rb

@@ -1,5 +1,6 @@
 require "forwardable"
 require "net/http"
+require "openssl"
 require "uri"
 require_relative "errors/network_error"
 
@@ -16,8 +17,10 @@ module X
     DEFAULT_WRITE_TIMEOUT = 60 # seconds
     NETWORK_ERRORS = [
       Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
       Net::OpenTimeout,
-      Net::ReadTimeout
+      Net::ReadTimeout,
+      OpenSSL::SSL::SSLError
     ].freeze
 
     attr_reader :base_uri, :proxy_uri, :http_client
@@ -39,9 +42,9 @@ module X
     end
 
     def send_request(request)
-      @http_client.request(request)
+      response = @http_client.request(request)
     rescue *NETWORK_ERRORS => e
-      raise NetworkError, "Network error: #{e.message}"
+      raise NetworkError.new("Network error: #{e.message}", response: response)
     end
 
     def base_uri=(base_url)
@@ -56,6 +59,17 @@ module X
       @http_client.instance_variable_get(:@debug_output)
     end
 
+    def configuration
+      {
+        base_url: base_uri.to_s,
+        open_timeout: open_timeout,
+        read_timeout: read_timeout,
+        write_timeout: write_timeout,
+        proxy_url: proxy_uri.to_s,
+        debug_output: debug_output
+      }
+    end
+
     private
 
     def apply_http_client_settings(open_timeout:, read_timeout:, write_timeout:, debug_output:)
@@ -84,15 +98,15 @@ module X
     end
 
     def build_http_client(host:, port:)
-      if @proxy_uri.nil?
-        Net::HTTP.new(host, port)
-      else
+      if defined?(@proxy_uri)
         Net::HTTP.new(host, port, @proxy_uri&.host, @proxy_uri&.port, @proxy_uri&.user, @proxy_uri&.password)
+      else
+        Net::HTTP.new(host, port)
       end
     end
 
     def conditionally_apply_http_client_settings
-      if @http_client
+      if defined?(@http_client)
         settings = current_http_client_settings
         yield
         apply_http_client_settings(**settings)

data/lib/x/errors/error.rb

@@ -1,15 +1,12 @@
 require "json"
-require "net/http"
 
 module X
   # Base error class
   class Error < ::StandardError
-    JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
-
     attr_reader :object
 
     def initialize(msg, response:)
-      @object = JSON.parse(response.body || "{}") if JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+      @object = JSON.parse(response.body) if response&.body && !response.body.empty?
       super(msg)
     end
   end

data/lib/x/errors/internal_server_error.rb

@@ -0,0 +1,5 @@
+require_relative "server_error"
+
+module X
+  class InternalServerError < ServerError; end
+end

data/lib/x/errors/network_error.rb

@@ -1,5 +1,5 @@
-require_relative "error"
+require_relative "server_error"
 
 module X
-  class NetworkError < StandardError; end
+  class NetworkError < Error; end
 end

data/lib/x/errors/payload_too_large_error.rb

@@ -0,0 +1,5 @@
+require_relative "client_error"
+
+module X
+  class PayloadTooLargeError < ClientError; end
+end

data/lib/x/media_upload.rb

@@ -0,0 +1,125 @@
+require "securerandom"
+
+module X
+  # Helper module for uploading images and videos
+  module MediaUpload
+    extend self
+
+    MAX_RETRIES = 3
+    BYTES_PER_MB = 1_048_576
+    MEDIA_CATEGORIES = %w[dm_gif dm_image dm_video subtitles tweet_gif tweet_image tweet_video].freeze
+    DM_GIF, DM_IMAGE, DM_VIDEO, SUBTITLES, TWEET_GIF, TWEET_IMAGE, TWEET_VIDEO = MEDIA_CATEGORIES
+    DEFAULT_MIME_TYPE = "application/octet-stream".freeze
+    MIME_TYPES = %w[image/gif image/jpeg video/mp4 image/png application/x-subrip image/webp].freeze
+    GIF_MIME_TYPE, JPEG_MIME_TYPE, MP4_MIME_TYPE, PNG_MIME_TYPE, SUBRIP_MIME_TYPE, WEBP_MIME_TYPE = MIME_TYPES
+    MIME_TYPE_MAP = {"gif" => GIF_MIME_TYPE, "jpg" => JPEG_MIME_TYPE, "jpeg" => JPEG_MIME_TYPE, "mp4" => MP4_MIME_TYPE,
+                     "png" => PNG_MIME_TYPE, "srt" => SUBRIP_MIME_TYPE, "webp" => WEBP_MIME_TYPE}.freeze
+
+    def media_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path, media_category),
+      boundary: SecureRandom.hex)
+      validate!(file_path: file_path, media_category: media_category)
+      upload_client = client.dup.tap { |c| c.base_uri = "https://upload.twitter.com/1.1/" }
+      upload_body = construct_upload_body(file_path, media_type, boundary)
+      upload_client.content_type = "multipart/form-data, boundary=#{boundary}"
+      upload_client.post("media/upload.json?media_category=#{media_category}", upload_body)
+    end
+
+    def chunked_media_upload(client:, file_path:, media_category:, media_type: infer_media_type(file_path,
+      media_category), boundary: SecureRandom.hex, chunk_size_mb: 8)
+      validate!(file_path: file_path, media_category: media_category)
+      upload_client = client.dup.tap { |c| c.base_uri = "https://upload.twitter.com/1.1/" }
+      media = init(upload_client, file_path, media_type, media_category)
+      chunk_size = chunk_size_mb * BYTES_PER_MB
+      chunk_paths = split(file_path, chunk_size)
+      append(upload_client, chunk_paths, media, media_type, boundary)
+      upload_client.post("media/upload.json?command=FINALIZE&media_id=#{media["media_id"]}")
+    end
+
+    def await_processing(client:, media:)
+      upload_client = client.dup.tap { |c| c.base_uri = "https://upload.twitter.com/1.1/" }
+      loop do
+        status = upload_client.get("media/upload.json?command=STATUS&media_id=#{media["media_id"]}")
+        return status if status["processing_info"]["state"] == "succeeded"
+
+        sleep status["processing_info"]["check_after_secs"].to_i
+      end
+    end
+
+    private
+
+    def validate!(file_path:, media_category:)
+      raise "File not found: #{file_path}" unless File.exist?(file_path)
+
+      return if MEDIA_CATEGORIES.include?(media_category.downcase)
+
+      raise ArgumentError, "Invalid media_category: #{media_category}. Valid values: #{MEDIA_CATEGORIES.join(", ")}"
+    end
+
+    def infer_media_type(file_path, media_category)
+      case media_category.downcase
+      when TWEET_GIF, DM_GIF then GIF_MIME_TYPE
+      when TWEET_VIDEO, DM_VIDEO then MP4_MIME_TYPE
+      when SUBTITLES then SUBRIP_MIME_TYPE
+      else MIME_TYPE_MAP[File.extname(file_path).delete(".").downcase] || DEFAULT_MIME_TYPE
+      end
+    end
+
+    def init(upload_client, file_path, media_type, media_category)
+      total_bytes = File.size(file_path)
+      query = "command=INIT&media_type=#{media_type}&media_category=#{media_category}&total_bytes=#{total_bytes}"
+      upload_client.post("media/upload.json?#{query}")
+    end
+
+    def split(file_path, chunk_size)
+      file_number = -1
+
+      [].tap do |chunk_paths|
+        File.open(file_path, "rb") do |f|
+          while (chunk = f.read(chunk_size))
+            chunk_paths << "#{Dir.mktmpdir}/x#{format("%03d", file_number += 1)}".tap do |path|
+              File.write(path, chunk)
+            end
+          end
+        end
+      end
+    end
+
+    def append(upload_client, chunk_paths, media, media_type, boundary = SecureRandom.hex)
+      threads = chunk_paths.map.with_index do |chunk_path, index|
+        Thread.new do
+          upload_body = construct_upload_body(chunk_path, media_type, boundary)
+          query = "command=APPEND&media_id=#{media["media_id"]}&segment_index=#{index}"
+          upload_chunk(upload_client, query, upload_body, chunk_path, boundary)
+        end
+      end
+      threads.each(&:join)
+    end
+
+    def upload_chunk(upload_client, query, upload_body, chunk_path, boundary)
+      # Initialize a new client to avoid shared connection issues
+      client = upload_client.dup
+      client.connection = Connection.new(**upload_client.connection.configuration.merge(base_url: "https://upload.twitter.com/1.1/"))
+      client.content_type = "multipart/form-data, boundary=#{boundary}"
+      client.post("media/upload.json?#{query}", upload_body)
+    rescue NetworkError, ServerError
+      retries ||= 0
+      ((retries += 1) < MAX_RETRIES) ? retry : raise
+    ensure
+      cleanup_chunk(chunk_path)
+    end
+
+    def cleanup_chunk(chunk_path)
+      dirname = File.dirname(chunk_path)
+      File.delete(chunk_path)
+      Dir.delete(dirname) if Dir.empty?(dirname)
+    end
+
+    def construct_upload_body(file_path, media_type, boundary = SecureRandom.hex)
+      "--#{boundary}\r\n" \
+        "Content-Disposition: form-data; name=\"media\"; filename=\"#{File.basename(file_path)}\"\r\n" \
+        "Content-Type: #{media_type}\r\n\r\n" \
+        "#{File.read(file_path)}\r\n" \
+        "--#{boundary}--\r\n"
+    end
+  end
+end

data/lib/x/oauth_authenticator.rb

@@ -72,22 +72,18 @@ module X
     end
 
     def signature_base_string(method, url, params)
-      "#{method}&#{encode(url)}&#{encode(encode_params(params))}"
-    end
-
-    def encode_params(params)
-      params.sort.map { |k, v| "#{k}=#{encode(v.to_s)}" }.join("&")
+      "#{method}&#{escape(url)}&#{escape(URI.encode_www_form(params.sort))}"
     end
 
     def signing_key
-      "#{encode(api_key_secret)}&#{encode(access_token_secret)}"
+      "#{escape(api_key_secret)}&#{escape(access_token_secret)}"
     end
 
     def format_oauth_header(params)
-      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{encode(v.to_s)}\"" }.join(", ")}"
+      "OAuth #{params.sort.map { |k, v| "#{k}=\"#{escape(v.to_s)}\"" }.join(", ")}"
     end
 
-    def encode(value)
+    def escape(value)
       # TODO: Replace CGI.escape with CGI.escapeURIComponent when support for Ruby 3.1 is dropped
       CGI.escape(value.to_s).gsub("+", "%20")
     end

data/lib/x/redirect_handler.rb

@@ -47,9 +47,7 @@ module X
     end
 
     def send_new_request(new_uri, new_request)
-      @connection = Connection.new(base_url: new_uri, open_timeout: connection.open_timeout,
-        read_timeout: connection.read_timeout, write_timeout: connection.write_timeout,
-        debug_output: connection.debug_output, proxy_url: connection.proxy_uri)
+      @connection = Connection.new(**connection.configuration.merge(base_url: new_uri))
       connection.send_request(new_request)
     end
   end

data/lib/x/request_builder.rb

@@ -12,7 +12,7 @@ module X
       delete: Net::HTTP::Delete
     }.freeze
     DEFAULT_CONTENT_TYPE = "application/json; charset=utf-8".freeze
-    DEFAULT_USER_AGENT = "X-Client/#{VERSION} Ruby/#{RUBY_VERSION}".freeze
+    DEFAULT_USER_AGENT = "X-Client/#{VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} (#{RUBY_PLATFORM})".freeze
     AUTHORIZATION_HEADER = "Authorization".freeze
     CONTENT_TYPE_HEADER = "Content-Type".freeze
     USER_AGENT_HEADER = "User-Agent".freeze
@@ -24,22 +24,30 @@ module X
       @user_agent = user_agent
     end
 
-    def build(authenticator, http_method, url, body: nil)
-      request = create_request(http_method, url, body)
+    def build(authenticator, http_method, uri, body: nil)
+      request = create_request(http_method, uri, body)
       add_authorization(request, authenticator)
       add_content_type(request)
       add_user_agent(request)
       request
     end
 
+    def configuration
+      {
+        content_type: content_type,
+        user_agent: user_agent
+      }
+    end
+
     private
 
-    def create_request(http_method, url, body)
+    def create_request(http_method, uri, body)
       http_method_class = HTTP_METHODS[http_method]
 
       raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
 
-      request = http_method_class.new(url)
+      escaped_uri = escape_query_params(uri)
+      request = http_method_class.new(escaped_uri)
       request.body = body if body && http_method != :get
       request
     end
@@ -55,5 +63,9 @@ module X
     def add_user_agent(request)
       request.add_field(USER_AGENT_HEADER, user_agent) if user_agent
     end
+
+    def escape_query_params(uri)
+      URI(uri).tap { |u| u.query = URI.encode_www_form(URI.decode_www_form(uri.query)) if uri.query }
+    end
   end
 end

data/lib/x/response_handler.rb

@@ -1,12 +1,13 @@
 require "json"
 require "net/http"
-require_relative "errors/bad_request_error"
 require_relative "errors/authentication_error"
+require_relative "errors/bad_request_error"
 require_relative "errors/forbidden_error"
 require_relative "errors/not_found_error"
-require_relative "errors/too_many_requests_error"
-require_relative "errors/server_error"
+require_relative "errors/payload_too_large_error"
+require_relative "errors/internal_server_error"
 require_relative "errors/service_unavailable_error"
+require_relative "errors/too_many_requests_error"
 
 module X
   # Process HTTP responses
@@ -18,8 +19,9 @@ module X
       401 => AuthenticationError,
       403 => ForbiddenError,
       404 => NotFoundError,
+      413 => PayloadTooLargeError,
       429 => TooManyRequestsError,
-      500 => ServerError,
+      500 => InternalServerError,
       503 => ServiceUnavailableError
     }.freeze
     JSON_CONTENT_TYPE_REGEXP = %r{application/(problem\+|)json}
@@ -32,19 +34,30 @@ module X
     end
 
     def handle(response)
-      if successful_json_response?(response)
-        return JSON.parse(response.body, array_class: array_class, object_class: object_class)
+      if success?(response)
+        JSON.parse(response.body, array_class: array_class, object_class: object_class) if json?(response)
+      else
+        error_class = ERROR_CLASSES[response.code.to_i] || Error
+        error_message = "#{response.code} #{response.message}"
+        raise error_class.new(error_message, response: response)
       end
+    end
 
-      error_class = ERROR_CLASSES[response.code.to_i] || Error
-      error_message = "#{response.code} #{response.message}"
-      raise error_class.new(error_message, response: response)
+    def configuration
+      {
+        array_class: array_class,
+        object_class: object_class
+      }
     end
 
     private
 
-    def successful_json_response?(response)
-      response.is_a?(Net::HTTPSuccess) && response.body && JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+    def success?(response)
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    def json?(response)
+      response.body && JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
     end
   end
 end

data/lib/x/version.rb

@@ -1,5 +1,5 @@
 require "rubygems/version"
 
 module X
-  VERSION = Gem::Version.create("0.9.0")
+  VERSION = Gem::Version.create("0.10.0")
 end

data/sig/x.rbs

@@ -28,17 +28,16 @@ module X
     def generate_signature: (String method, String url, Hash[String, String] params) -> String
     def hmac_signature: (String base_string) -> String
     def signature_base_string: (String method, String url, Hash[String, String] params) -> String
-    def encode_params: (Hash[String, String] params) -> String
     def signing_key: -> String
     def format_oauth_header: (Hash[String, String] params) -> String
-    def encode: (String value) -> String
+    def escape: (String value) -> String
   end
 
   class Error < StandardError
     JSON_CONTENT_TYPE_REGEXP: Regexp
 
-    attr_reader object: Hash[String, untyped]
-    def initialize: (String msg, response: Net::HTTPResponse) -> void
+    attr_reader object: untyped
+    def initialize: (String msg, response: Net::HTTPResponse?) -> void
 
     private
     def json_response?: (Net::HTTPResponse response) -> bool
@@ -56,9 +55,15 @@ module X
   class ForbiddenError < ClientError
   end
 
+  class InternalServerError < ServerError
+  end
+
   class NotFoundError < ClientError
   end
 
+  class PayloadTooLargeError < ClientError
+  end
+
   class TooManyRedirectsError < ClientError
   end
 
@@ -88,7 +93,8 @@ module X
     DEFAULT_OPEN_TIMEOUT: Integer
     DEFAULT_READ_TIMEOUT: Integer
     DEFAULT_WRITE_TIMEOUT: Integer
-    NETWORK_ERRORS: Array[(singleton(::Errno::ECONNREFUSED) | singleton(::Net::OpenTimeout) | singleton(::Net::ReadTimeout))]
+    NETWORK_ERRORS: Array[(singleton(Errno::ECONNREFUSED) | singleton(Errno::ECONNRESET) | singleton(Net::OpenTimeout) | singleton(Net::ReadTimeout) | singleton(OpenSSL::SSL::SSLError))]
+
     extend Forwardable
     @http_client: Net::HTTP
 
@@ -101,6 +107,7 @@ module X
     def send_request: (Net::HTTPRequest request) -> Net::HTTPResponse
     def base_uri=: (URI::Generic | String base_url) -> void
     def debug_output: -> IO?
+    def configuration: -> Hash[Symbol, untyped]
 
     private
     def apply_http_client_settings: (open_timeout: Float | Integer, read_timeout: Float | Integer, write_timeout: Float | Integer, debug_output: IO?) -> untyped
@@ -121,13 +128,15 @@ module X
     attr_accessor content_type: String
     attr_accessor user_agent: String
     def initialize: (?content_type: String, ?user_agent: String) -> void
-    def build: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Symbol http_method, URI::Generic url, ?body: String?) -> (Net::HTTPRequest)
+    def build: (BearerTokenAuthenticator | OauthAuthenticator authenticator, Symbol http_method, URI::Generic uri, ?body: String?) -> (Net::HTTPRequest)
+    def configuration: -> Hash[Symbol, untyped]
 
     private
-    def create_request: (Symbol http_method, URI::Generic url, String? body) -> (Net::HTTPRequest)
+    def create_request: (Symbol http_method, URI::Generic uri, String? body) -> (Net::HTTPRequest)
     def add_authorization: (Net::HTTPRequest request, BearerTokenAuthenticator | OauthAuthenticator authenticator) -> void
     def add_content_type: (Net::HTTPRequest request) -> void
     def add_user_agent: (Net::HTTPRequest request) -> void
+    def escape_query_params: (URI::Generic uri) -> URI::Generic
   end
 
   class RedirectHandler
@@ -149,16 +158,18 @@ module X
   class ResponseHandler
     DEFAULT_ARRAY_CLASS: Class
     DEFAULT_OBJECT_CLASS: Class
-    ERROR_CLASSES: Hash[Integer, singleton(AuthenticationError) | singleton(BadRequestError) | singleton(ForbiddenError) | singleton(NotFoundError) | singleton(ServerError) | singleton(ServiceUnavailableError) | singleton(TooManyRequestsError)]
+    ERROR_CLASSES: Hash[Integer, singleton(AuthenticationError) | singleton(BadRequestError) | singleton(ForbiddenError) | singleton(InternalServerError) | singleton(NotFoundError) | singleton(PayloadTooLargeError) | singleton(ServiceUnavailableError) | singleton(TooManyRequestsError)]
     JSON_CONTENT_TYPE_REGEXP: Regexp
 
     attr_accessor array_class: Class
     attr_accessor object_class: Class
     def initialize: (?array_class: Class, ?object_class: Class) -> void
-    def handle: (Net::HTTPResponse response) -> Hash[String, untyped]
+    def handle: (Net::HTTPResponse response) -> untyped
+    def configuration: -> Hash[Symbol, Class]
 
     private
-    def successful_json_response?: (Net::HTTPResponse response) -> bool
+    def success?: (Net::HTTPResponse response) -> bool
+    def json?: (Net::HTTPResponse response) -> bool
   end
 
   class Client
@@ -169,15 +180,80 @@ module X
     @redirect_handler: RedirectHandler
     @response_handler: ResponseHandler
 
-    attr_reader base_uri: URI::Generic
+    attr_accessor access_token: String
+    attr_accessor access_token_secret: String
+    attr_accessor api_key: String
+    attr_accessor api_key_secret: String
+    attr_accessor bearer_token: String
+    attr_accessor base_uri: URI::Generic | String
+    attr_accessor open_timeout: Float | Integer
+    attr_accessor read_timeout: Float | Integer
+    attr_accessor write_timeout: Float | Integer
+    attr_accessor proxy_url: String
+    attr_accessor content_type: String
+    attr_accessor user_agent: String
+    attr_accessor debug_output: IO?
+    attr_accessor array_class: Class
+    attr_accessor object_class: Class
+    attr_accessor max_redirects: Integer
+    attr_accessor authenticator: BearerTokenAuthenticator | OauthAuthenticator
+    attr_accessor connection: Connection
+    attr_accessor request_builder: RequestBuilder
+    attr_accessor redirect_handler: RedirectHandler
+    attr_accessor response_handler: ResponseHandler
+    alias base_url base_uri
+
+
     def initialize: (?bearer_token: String?, ?api_key: String?, ?api_key_secret: String?, ?access_token: String?, ?access_token_secret: String?, ?base_url: URI::Generic | String, ?content_type: String, ?user_agent: String, ?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO?, ?array_class: Class, ?object_class: Class, ?max_redirects: Integer) -> void
-    def get: (String endpoint) -> Hash[String, untyped]
-    def post: (String endpoint, ?nil body) -> Hash[String, untyped]
-    def put: (String endpoint, ?nil body) -> Hash[String, untyped]
-    def delete: (String endpoint) -> Hash[String, untyped]
+    def get: (String endpoint) -> untyped
+    def post: (String endpoint, ?String? body) -> untyped
+    def put: (String endpoint, ?String? body) -> untyped
+    def delete: (String endpoint) -> untyped
 
     private
     def initialize_authenticator: (String? bearer_token, String? api_key, String? api_key_secret, String? access_token, String? access_token_secret) -> (BearerTokenAuthenticator | OauthAuthenticator)
-    def send_request: (Symbol http_method, String endpoint, ?nil body) -> Hash[String, untyped]
+    def send_request: (Symbol http_method, String endpoint, ?String? body) -> untyped
   end
+
+  module MediaUpload
+    MAX_RETRIES: Integer
+    BYTES_PER_MB: Integer
+    MEDIA_CATEGORIES: Array[String]
+    DM_GIF: String
+    DM_IMAGE: String
+    DM_VIDEO: String
+    SUBTITLES: String
+    TWEET_GIF: String
+    TWEET_IMAGE: String
+    TWEET_VIDEO: String
+    DEFAULT_MIME_TYPE: String
+    MIME_TYPES: Array[String]
+    GIF_MIME_TYPE: String
+    JPEG_MIME_TYPE: String
+    MP4_MIME_TYPE: String
+    PNG_MIME_TYPE: String
+    SUBRIP_MIME_TYPE: String
+    WEBP_MIME_TYPE: String
+    MIME_TYPE_MAP: Hash[String, String]
+    extend MediaUpload
+
+    def media_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String) -> untyped
+    def chunked_media_upload: (client: Client, file_path: String, media_category: String, ?media_type: String, ?boundary: String, ?chunk_size_mb: Integer) -> untyped
+    def await_processing: (client: Client, media: untyped) -> untyped
+
+    private
+    def validate!: (file_path: String, media_category: String) -> nil
+    def infer_media_type: (String file_path, String media_category) -> String
+    def init: (Client upload_client, String file_path, String media_type, String media_category) -> untyped
+    def split: (String file_path, Integer chunk_size) -> Array[String]
+    def append: (Client upload_client, Array[String] chunk_paths, untyped media, String media_type, ?String boundary) -> Array[String]
+    def upload_chunk: (Client upload_client, String query, String chunk_path, String media_type, String boundary) -> Integer?
+    def cleanup_chunk: (String chunk_path) -> Integer?
+    def finalize: (Client upload_client, untyped media) -> untyped
+    def construct_upload_body: (String file_path, String media_type, ?String boundary) -> String
+  end
+end
+
+class Dir
+  def self.mktmpdir: (?String? prefix_suffix) -> String
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: x
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-26 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -31,12 +31,15 @@ files:
 - lib/x/errors/client_error.rb
 - lib/x/errors/error.rb
 - lib/x/errors/forbidden_error.rb
+- lib/x/errors/internal_server_error.rb
 - lib/x/errors/network_error.rb
 - lib/x/errors/not_found_error.rb
+- lib/x/errors/payload_too_large_error.rb
 - lib/x/errors/server_error.rb
 - lib/x/errors/service_unavailable_error.rb
 - lib/x/errors/too_many_redirects_error.rb
 - lib/x/errors/too_many_requests_error.rb
+- lib/x/media_upload.rb
 - lib/x/oauth_authenticator.rb
 - lib/x/redirect_handler.rb
 - lib/x/request_builder.rb
@@ -69,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: A Ruby interface to the X API.