x 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2906018cf3e05342abe1bc6c938f3d1b3cf9d1d84c3813a96a11b693fbe0960
-  data.tar.gz: f84f47e1a9ea06b101712ae1f9fd7198d71b2cbc7487a654b8442dd13e3244e0
+  metadata.gz: 4a01e8a21951f3b998cfae0253c4d35c5412ac39f94681283b9059d4a196651e
+  data.tar.gz: 5b4a5bb02d86b27391b005acb329893025222c20e9d0c99b88ed0d7e6322dc5e
 SHA512:
-  metadata.gz: 2c98c3ea7e22d0b023a328207c9599dca0f74b54d5ed05eea04378c5c2ed5a2803799b7dcafa54d041d3b7dac8b3e08c8559d4cacb03b2419796368fa153401e
-  data.tar.gz: 36c0faa98a5f6657a88ce770924e2669f91fcea2985b38f1c82dc0766d0c5a5cf6a4b0342d4684f5b679b41dc76f5fa94b791a6468b6f0514c28f6d70864b41a
+  metadata.gz: 8972eafdb4c041a61258f409fef5a93dc0ff56b70e5c8dd384e126652c1ab32a4e52dc56bd253d7c204ea6313e3ac321e93c7245c722c0d5491b59443c63435a
+  data.tar.gz: 4a5dfb958b61b78cdcf9312250d3ba00182894241da1c3e9114f08f1029fb174be07043f607a864986e3d09d6d308dfac4d13549e2483d5746235b34c4dd05a2

data/CHANGELOG.md

@@ -1,4 +1,7 @@
-## [Unreleased]
+## [0.10.0] - 2023-10-08
+
+- Add media upload helper methods (6c6a267)
+- Add PayloadTooLargeError class (cd61850)
 
 ## [0.9.1] - 2023-10-06
 

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/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

@@ -32,6 +32,13 @@ module X
       request
     end
 
+    def configuration
+      {
+        content_type: content_type,
+        user_agent: user_agent
+      }
+    end
+
     private
 
     def create_request(http_method, uri, body)

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}
@@ -41,6 +43,13 @@ module X
       end
     end
 
+    def configuration
+      {
+        array_class: array_class,
+        object_class: object_class
+      }
+    end
+
     private
 
     def success?(response)

data/lib/x/version.rb

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

data/sig/x.rbs

@@ -36,8 +36,8 @@ module X
   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
@@ -55,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
 
@@ -87,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
 
@@ -100,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,6 +129,7 @@ module X
     attr_accessor user_agent: String
     def initialize: (?content_type: String, ?user_agent: String) -> void
     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 uri, String? body) -> (Net::HTTPRequest)
@@ -149,13 +158,14 @@ 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 success?: (Net::HTTPResponse response) -> bool
@@ -170,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.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Erik Berlin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-06 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