httpx-patched 1.6.2.1

data/sig/io/udp.rbs

@@ -0,0 +1,25 @@
+module HTTPX
+  class UDP
+    include Loggable
+
+    @host: String
+    @port: Integer
+    @io: UDPSocket
+    @options: Options
+
+    def initialize: (String ip, Integer port, Options options) -> void
+
+    def to_io: () -> IO
+
+    def connect: () -> void
+
+    def connected?: () -> bool
+
+    # :nocov:
+    def close: () -> void
+
+    def read: (Integer size, String buffer) -> Integer?
+
+    def write: (Buffer buffer) -> Integer?
+  end
+end

data/sig/io/unix.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  class UNIX < TCP
+
+    attr_reader path: String
+
+    alias host path
+
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @io: Socket
+
+    def initialize: (http_uri origin, String? path, Options options) -> void
+
+    def connect: () -> void
+
+    private
+
+    def build_socket: () -> Socket
+  end
+end

data/sig/io.rbs

@@ -0,0 +1,3 @@
+module HTTPX
+  type io_type = "udp" | "tcp" | "ssl" | "unix"
+end

data/sig/loggable.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  interface _IOLogger
+    def <<: (string?) -> void
+  end
+
+  module Loggable
+    USE_DEBUG_LOGS: bool
+
+    COLORS: Hash[Symbol, Integer]
+
+    def log: (?level: Integer?, ?color: Symbol?, ?debug_level: Integer, ?debug: _IOLogger?) { () -> String } -> void
+
+    def log_exception: (Exception error, ?level: Integer, ?color: Symbol, ?debug_level: Integer, ?debug: _IOLogger?) -> void
+
+    def log_redact: (_ToS text, ?bool should_redact) -> String
+  end
+end

data/sig/options.rbs

@@ -0,0 +1,202 @@
+module HTTPX
+  class Options
+    # include _ToHash
+
+    BUFFER_SIZE: Integer
+    WINDOW_SIZE: Integer
+    MAX_BODY_THRESHOLD_SIZE: Integer
+    CONNECT_TIMEOUT: Integer
+    READ_TIMEOUT: Integer
+    WRITE_TIMEOUT: Integer
+    REQUEST_TIMEOUT: Integer
+    OPERATION_TIMEOUT: Integer
+    KEEP_ALIVE_TIMEOUT: Integer
+    SETTINGS_TIMEOUT: Integer
+    CLOSE_HANDSHAKE_TIMEOUT: Integer
+    SET_TEMPORARY_NAME: ^(Class klass, ?Symbol pl) -> void
+
+    DEFAULT_OPTIONS: Hash[Symbol, untyped]
+    REQUEST_BODY_IVARS: Array[Symbol]
+
+    type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :request_timeout
+    type timeout = Hash[timeout_type, Numeric?]
+
+    def self.new: (?options) -> instance
+
+    attr_reader self.options_names: Array[Symbol]
+
+    # headers
+    attr_reader uri: URI?
+
+    # headers
+    attr_reader headers: headers?
+
+    # timeout
+    attr_reader timeout: timeout
+
+    # http2_settings
+    attr_reader http2_settings: Hash[Symbol, Integer | bool]
+
+    # max_concurrent_requests
+    attr_reader max_concurrent_requests: Integer?
+
+    # max_requests
+    attr_reader max_requests: Numeric?
+
+    # window_size
+    attr_reader window_size: Integer
+
+    # buffer_size
+    attr_reader buffer_size: Integer
+
+    # body_threshold_size
+    attr_reader body_threshold_size: Integer
+
+    # transport
+    attr_reader transport: io_type | nil
+
+    # addresses
+    attr_reader addresses: Array[Resolver::Entry]?
+
+    # supported_compression_formats
+    attr_reader supported_compression_formats: Array[String]
+
+    # compress_request_body
+    attr_reader compress_request_body: bool
+
+    # decompress_response_body
+    attr_reader decompress_response_body: bool
+
+    # origin
+    attr_reader origin: URI::Generic?
+
+    # base_path
+    attr_reader base_path: String?
+
+    # classes
+    attr_reader resolver_native_class: singleton(Resolver::Native)
+
+    attr_reader resolver_system_class: singleton(Resolver::System)
+
+    attr_reader resolver_https_class: singleton(Resolver::HTTPS)
+
+    attr_reader http1_class: singleton(Connection::HTTP1)
+
+    attr_reader http2_class: singleton(Connection::HTTP2)
+
+    attr_reader connection_class: singleton(Connection)
+
+    attr_reader pool_class: singleton(Pool)
+
+    attr_reader request_class: singleton(Request)
+
+    attr_reader response_class: singleton(Response)
+
+    attr_reader headers_class: singleton(Headers)
+
+    attr_reader request_body_class: singleton(Request::Body)
+
+    attr_reader response_body_class: singleton(Response::Body)
+
+    attr_reader options_class: singleton(Options)
+
+    attr_reader resolver_class: Symbol | singleton(Resolver::Resolver)
+
+    attr_reader ssl: Hash[Symbol, untyped]
+
+    # io
+    type io_option = _ToIO | Hash[String, _ToIO]
+    attr_reader io: io_option?
+
+    # fallback_protocol
+    attr_reader fallback_protocol: String
+
+    # debug
+    attr_reader debug: _IOLogger?
+
+    # debug_level
+    attr_reader debug_level: Integer
+
+    # persistent
+    attr_reader persistent: bool
+
+    # close_on_fork
+    attr_reader close_on_fork: bool
+
+    # resolver_options
+    attr_reader resolver_options: Hash[Symbol, untyped]
+
+    # resolver_options
+    attr_reader pool_options: pool_options
+
+    # ip_families
+    attr_reader ip_families: Array[ip_family]?
+
+    def ==: (Options other) -> bool
+
+    def options_equals?: (Options other, ?Array[Symbol] ignore_ivars) -> bool
+
+    def merge: (_ToHash[Symbol, untyped] other) -> instance
+
+    def to_hash: () -> Hash[Symbol, untyped]
+
+    def extend_with_plugin_classes: (Module pl) -> void
+
+    private
+
+    def initialize: (?options options) -> void
+
+    def access_option: (Hash[Symbol, untyped] | Object | nil obj, Symbol k, Hash[Symbol, Symbol]? ivar_map) -> untyped
+
+    # integer
+    def option_max_concurrent_requests: (Numeric value) -> Numeric
+    def option_max_requests: (Numeric value) -> Numeric
+    def option_window_size: (Numeric value) -> Numeric
+    def option_buffer_size: (Numeric value) -> Numeric
+    def option_body_threshold_size: (Numeric value) -> Numeric
+    def option_debug_level: (Numeric value) -> Numeric
+
+    # to hash
+    def option_ssl: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_http2_settings: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_resolver_options: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+    def option_pool_options: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+
+    # no transform
+    def option_request_class: (singleton(Request) value) -> singleton(Request)
+    def option_response_class: (singleton(Response) value) -> singleton(Response)
+    def option_headers_class: (singleton(Headers) value) -> singleton(Headers)
+    def option_request_body_class: (singleton(Request::Body) value) -> singleton(Request::Body)
+    def option_response_body_class: (singleton(Response::Body) value) -> singleton(Response::Body)
+    def option_connection_class: (singleton(Connection) value) -> singleton(Connection)
+    def option_options_class: (singleton(Options) value) -> singleton(Options)
+    def option_pool_class: (singleton(Pool) value) -> singleton(Pool)
+    def option_resolver_class: (Symbol | singleton(Resolver::Resolver) value) -> (Symbol | singleton(Resolver::Resolver))
+    def option_io: (io_option value) -> io_option
+    def option_fallback_protocol: (String value) -> String
+    def option_debug: (_IOLogger value) -> _IOLogger
+    def option_debug_redact: (bool value) -> bool
+    def option_compress_request_body: (bool value) -> bool
+    def option_decompress_response_body: (bool value) -> bool
+    def option_persistent: (bool value) -> bool
+    def option_close_on_fork: (bool value) -> bool
+
+    def option_origin: (http_uri | String value) -> http_uri
+
+    def option_base_path: (_ToStr value) -> String
+
+    def option_headers: (headers_input | Headers value) -> Headers
+
+    def option_timeout: (_ToHash[timeout_type, Numeric?]) -> timeout
+
+    def option_supported_compression_formats: (_ToS | _ToAry[_ToS] value) -> Array[String]
+
+    def option_transport: (_ToS value) -> String
+
+    def option_addresses: (ipaddr | _ToAry[ipaddr] value) -> Array[ipaddr]
+
+    def option_ip_families: (ip_family | _ToAry[ip_family] value) -> Array[ip_family]
+  end
+
+  type options = Options | Hash[Symbol, untyped]
+end

data/sig/parser/http1.rbs

@@ -0,0 +1,59 @@
+module HTTPX
+  module Parser
+    class Error < HTTPX::Error
+    end
+
+    type parsed_headers = Hash[String, Array[String]]
+
+    interface _HTTP1Events
+
+      def on_start: () -> void
+      def on_headers: (parsed_headers headers) -> void
+      def on_trailers: (parsed_headers trailers) -> void
+      def on_data: (String data) -> void
+      def on_complete: () -> void
+    end
+
+    class HTTP1
+      VERSIONS: Array[String]
+
+      attr_reader status_code: Integer
+      attr_reader http_version: [Integer, Integer]
+      attr_reader headers: parsed_headers
+
+      @observer: _HTTP1Events
+      @state: Symbol
+      @buffer: String
+      @content_type: String?
+      @content_length: Integer
+      @_has_trailers: bool
+      @upgrade: bool
+
+      def <<: (string chunk) -> void
+
+      def reset!: () -> void
+
+      def upgrade?: () -> bool
+
+      def upgrade_data: () -> String
+
+      private
+
+      def initialize: (_HTTP1Events observer) -> untyped
+
+      def nextstate: (Symbol state) -> void
+
+      def no_more_data?: () -> bool
+
+      def parse: () -> void
+
+      def parse_data: () -> void
+
+      def parse_headers: () -> void
+
+      def parse_headline: () -> void
+
+      def prepare_data: (parsed_headers headers) -> void
+    end
+  end
+end

data/sig/plugins/auth/basic.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Basic
+        @user: String
+        @password: String
+
+        def authenticate: (*untyped) -> String
+
+        private
+
+        def initialize: (string user, string password, *untyped) -> void
+
+      end
+    end
+  end
+end

data/sig/plugins/auth/digest.rbs

@@ -0,0 +1,25 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Digest
+        @user: String
+        @password: String
+        @hashed: bool
+
+        def can_authenticate?: (String? authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String
+
+        private
+
+        def generate_header: (String meth, String uri, String authenticate) -> String
+
+        def initialize: (string user, string password, ?hashed: bool, **untyped) -> void
+
+        def make_cnonce: () -> String
+
+        def next_nonce: () -> Integer
+      end
+    end
+  end
+end

data/sig/plugins/auth/ntlm.rbs

@@ -0,0 +1,20 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Ntlm
+        @user: String
+        @password: String
+        @domain: String?
+
+        def can_authenticate?: (String? authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String
+
+        private
+
+        def initialize: (string user, string password, ?domain: String?) -> void
+
+      end
+    end
+  end
+end

data/sig/plugins/auth/socks5.rbs

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      class Socks5
+        @user: String
+        @password: String
+
+        def can_authenticate?: (*untyped) -> boolish
+
+        def authenticate: (*untyped) -> String
+
+        private
+
+        def initialize: (string user, string password) -> void
+      end
+    end
+  end
+end

data/sig/plugins/auth.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module Authorization
+      module InstanceMethods
+        def authorization: (string token) -> instance
+
+        def bearer_auth: (string token) -> instance
+      end
+    end
+
+    type sessionAuthorization = Session & Authorization::InstanceMethods
+  end
+end

data/sig/plugins/aws_sdk_authentication.rbs

@@ -0,0 +1,43 @@
+module HTTPX
+  module Plugins
+    module AwsSdkAuthentication
+      class Configuration
+        attr_reader profile: String?
+
+        private
+
+        def initialize: (String? profile) -> void
+      end
+
+      class Credentials
+        @aws_credentials: untyped
+
+        include _SigV4Credentials
+
+        private
+
+        def initialize: (untyped aws_credentials) -> untyped
+      end
+
+      interface _AwsSdkOptions
+        def aws_profile: () -> String?
+      end
+
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.configure: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options & _AwsSdkOptions)
+
+      def self.credentials: (String? profile) -> Credentials
+
+      def self.region: (String? profile) -> String
+
+      module InstanceMethods
+        def aws_sdk_authentication: (?credentials: Credentials, ?region: String, **untyped) -> instance
+      end
+    end
+
+    type sessionAwsSdkAuthentication = awsSigV4Session & AwsSdkAuthentication::InstanceMethods
+  end
+end

data/sig/plugins/aws_sigv4.rbs

@@ -0,0 +1,78 @@
+module HTTPX
+  module Plugins
+
+    interface _SigV4Credentials
+      def username: () -> String
+      def password: () -> String
+      def security_token: () -> String?
+    end
+
+    module AWSSigV4
+
+      class Credentials < Struct[[String, String, String?]]
+        attr_reader username: String
+        attr_reader password: String
+        attr_reader security_token: String?
+      end
+
+
+      class Signer
+        @credentials: Object & _SigV4Credentials
+        @service: String
+        @region: String
+        @unsigned_headers: Set[String]
+        @apply_checksum_header: bool
+        @provider_prefix: String
+        @header_provider_field: String
+        @algorithm: String
+
+        def sign!: (Request & RequestMethods request) -> void
+
+        def self.new: (instance) -> instance
+                    | (**untyped params) -> instance
+        private
+
+        def initialize: (
+          service: String,
+          region: String,
+          ?credentials: _SigV4Credentials,
+          ?username: String,
+          ?password: String,
+          ?security_token: String,
+          ?provider_prefix: String,
+          ?header_provider_field: String,
+          ?unsigned_headers: Array[String],
+          ?apply_checksum_header: bool,
+          ?algorithm: String
+        ) -> untyped
+
+
+        def hexdigest: (Request::Body value) -> String
+
+        def hmac: (String key, String value) -> String
+
+        def hexhmac: (String key, String value) -> String
+      end
+
+
+      interface _SigV4Options
+        def sigv4_signer: () -> Signer?
+      end
+
+      def self.extra_options: (Options) -> (Options & _SigV4Options)
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def aws_sigv4_authentication: (**untyped) -> instance
+      end
+
+      module RequestMethods
+        def canonical_path: () -> String
+
+        def canonical_query: () -> String
+      end
+    end
+
+    type awsSigV4Session = Session & AWSSigV4::InstanceMethods
+  end
+end

data/sig/plugins/basic_auth.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  module Plugins
+    module BasicAuth
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.configure: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def basic_auth: (string user, string password) -> instance
+      end
+    end
+
+    type sessionBasicAuth = sessionAuthorization & BasicAuth::InstanceMethods
+  end
+end

data/sig/plugins/brotli.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins
+    module Brotli
+      def self?.load_dependencies: (singleton(Session)) -> void
+
+      def self?.encode: (body_encoder body) -> Deflater
+
+      def self?.decode: (HTTPX::Response response, ?bytesize: Integer) -> Transcoder::_Decoder
+
+      class Deflater < Transcoder::Deflater
+      end
+
+      module RequestBodyClassMethods
+        def initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+      end
+
+      module ResponseBodyClassMethods
+        def initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> (Transcoder::_Decoder | Transcoder::GZIP::Inflater)
+      end
+    end
+  end
+end

data/sig/plugins/callbacks.rbs

@@ -0,0 +1,38 @@
+module HTTPX
+  module Plugins
+    module Callbacks
+      class CallbackError < Exception
+      end
+
+      module InstanceMethods
+        include HTTPX::Callbacks
+
+        type socket = TCPSocket | OpenSSL::SSL::SSLSocket | UNIXSocket
+
+        def on_connection_opened: () { (http_uri origin, socket sock) -> void } -> self
+
+        def on_connection_closed: () { (http_uri origin) -> void } -> self
+
+        def on_request_error: () { (Request request, StandardError error) -> void } -> self
+
+        def on_request_started: () { (Request request) -> void } -> self
+
+        def on_request_body_chunk: () { (Request request, String chunk) -> void } -> self
+
+        def on_request_completed: () { (Request request) -> void } -> self
+
+        def on_response_started: () { (Request request, Response response) -> void } -> self
+
+        def on_response_body_chunk: () { (Request request, Response response, String chunk) -> void } -> self
+
+        def on_response_completed: () { (Request request, response response) -> void } -> self
+
+        private
+
+        def emit_or_callback_error: (*untyped) -> void
+      end
+    end
+
+    type sessionCallbacks = Session & Callbacks::InstanceMethods
+  end
+end