httpx 0.22.4 → 0.23.0

data/sig/connection.rbs

@@ -17,9 +17,7 @@ module HTTPX
     extend Forwardable
     include Loggable
     include Callbacks
-    include HTTPX::Registry[String, Class]
 
-    BUFFER_SIZE: Integer
 
     attr_reader type: io_type
     attr_reader origin: URI::Generic
@@ -36,7 +34,13 @@ module HTTPX
     @write_buffer: Buffer
     @inflight: Integer
     @keep_alive_timeout: Numeric?
+    @timeout: Numeric?
+    @current_timeout: Numeric?
     @total_timeout: Numeric?
+    @io: TCP | SSL | UNIX
+    @parser: HTTP1 | HTTP2 | _Parser
+    @connected_at: Float
+    @response_received_at: Float
 
     def addresses: () -> Array[ipaddr]?
 
@@ -77,6 +81,8 @@ module HTTPX
 
     def deactivate: () -> void
 
+    def open?: () -> bool
+
     def raise_timeout_error: (Numeric interval) -> void
 
     private
@@ -91,17 +97,20 @@ module HTTPX
 
     def send_pending: () -> void
 
-    def parser: () -> _Parser
+    def parser: () -> (HTTP1 | HTTP2 | _Parser)
 
     def send_request_to_parser: (Request request) -> void
 
-    def build_parser: () -> _Parser
-                    | (String) -> _Parser
+    def build_parser: (?String protocol) -> (HTTP1 | HTTP2)
 
-    def set_parser_callbacks: (_Parser) -> void
+    def set_parser_callbacks: (HTTP1 | HTTP2 parser) -> void
 
     def transition: (Symbol) -> void
 
+    def handle_transition: (Symbol) -> void
+
+    def build_socket: (?Array[ipaddr]? addrs) -> (TCP | SSL | UNIX)
+
     def on_error: (HTTPX::TimeoutError | Error | StandardError) -> void
 
     def handle_error: (StandardError) -> void
@@ -113,5 +122,7 @@ module HTTPX
     def write_timeout_callback: (Request request, Numeric write_timeout) -> void
 
     def read_timeout_callback: (Request request, Numeric read_timeout, ?singleton(RequestTimeoutError) error_type) -> void
+
+    def self.parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end
 end

data/sig/errors.rbs

@@ -2,6 +2,12 @@ module HTTPX
   class Error < StandardError
   end
 
+  class UnsupportedSchemeError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
   class TimeoutError < Error
     attr_reader timeout: Numeric
 
@@ -55,4 +61,7 @@ module HTTPX
 
     def initialize: (Connection connection, String hostname, ?String message) -> untyped
   end
+
+  class MisdirectedRequestError < HTTPError
+  end
 end

data/sig/httpx.rbs

@@ -8,9 +8,9 @@ module HTTPX
   type uri = URI::HTTP | URI::HTTPS | string
   type generic_uri = String | URI::Generic
 
-  type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
-              :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
-              :acl | :report | :patch | :search
+  type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |
+              "PROPFIND" | "PROPPATCH" | "MKCOL" | "COPY" | "MOVE" | "LOCK" | "UNLOCK" | "ORDERPATCH" |
+              "ACL" | "REPORT" | "PATCH" | "SEARCH"
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 

data/sig/io/ssl.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  IPRegex: Regexp
+
+  class TLSError < OpenSSL::SSL::SSLError
+  end
+
+  class SSL < TCP
+    TLS_OPTIONS: Hash[Symbol, untyped]
+
+    def can_verify_peer?: () -> bool
+
+    def verify_hostname: (String host) -> bool
+
+    # :nocov:
+    def try_ssl_connect: () -> void
+  end
+end

data/sig/io/tcp.rbs

@@ -0,0 +1,57 @@
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader ip: IPAddr?
+
+    attr_reader port: Integer
+
+    attr_reader addresses: Array[ipaddr]
+
+    attr_reader state: Symbol
+
+    attr_reader interests: io_interests
+
+    alias host ip
+
+    def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) -> void
+
+    def add_addresses: (Array[ipaddr] addrs) -> void
+
+    def to_io: () -> ::IO
+
+    def protocol: () -> String
+
+    def connect: () -> void
+
+    private
+
+    # :nocov:
+    def try_connect: () -> void
+
+    public
+
+    def read: (Integer size, ?(Buffer | String) buffer) -> (0 | nil | untyped)
+
+    def write: (Buffer buffer) -> Integer?
+
+    def close: () -> void
+
+    def connected?: () -> bool
+
+    def closed?: () -> bool
+
+    # :nocov:
+    def inspect: () -> ::String
+
+    private
+
+    def build_socket: () -> Socket
+
+    def transition: (Symbol nextstate) -> void
+
+    def do_transition: (Symbol nextstate) -> void
+
+    def log_transition_state: (Symbol nextstate) -> void
+  end
+end

data/sig/io/udp.rbs

@@ -0,0 +1,20 @@
+module HTTPX
+  class UDP
+    include Loggable
+
+    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, ?(Buffer | String) buffer) -> Integer?
+
+    def write: (Buffer buffer) -> Integer?
+  end
+end

data/sig/io/unix.rbs

@@ -0,0 +1,10 @@
+module HTTPX
+  class UNIX < TCP
+
+    attr_reader path: String
+
+    alias host path
+
+    def initialize: (URI::HTTP | URI::HTTPS origin, Array[String]? addresses, options options) -> void
+  end
+end

data/sig/options.rbs

@@ -2,6 +2,7 @@ module HTTPX
   class Options
     # include _ToHash
 
+    BUFFER_SIZE: Integer
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
     CONNECT_TIMEOUT: Integer
@@ -38,11 +39,14 @@ module HTTPX
     # 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: String?
+    attr_reader transport: "unix" | nil
 
     # transport_options
     attr_reader transport_options: Hash[untyped, untyped]?

data/sig/plugins/compression.rbs

@@ -1,7 +1,6 @@
 module HTTPX
   module Plugins
     module Compression
-      type encodings_registry = Registry[Symbol, Class]
 
       type deflatable = _Reader | _ToS
 
@@ -16,12 +15,17 @@ module HTTPX
         def initialize: (Integer | Float bytesize) -> untyped
       end
 
+      interface _Compressor
+        def deflater: () -> _Deflater
+        def inflater: (Integer | Float bytesize) -> _Inflater
+      end
+
       def self.configure: (singleton(Session)) -> void
 
       interface _CompressionOptions
         def compression_threshold_size: () -> Integer?
 
-        def encodings: () -> encodings_registry?
+        def encodings: () -> Hash[String, _Compressor]
       end
 
       def self.extra_options: (Options) -> (Options & _CompressionOptions)

data/sig/plugins/cookies/jar.rbs

@@ -13,8 +13,8 @@ module HTTPX
 
       def []: (uri) -> Array[Cookie]
 
-      def each: (?uri) { (Cookie) -> void } -> void
-              | (?uri) -> Enumerable[Cookie]
+      def each: (?uri?) { (Cookie) -> void } -> void
+              | (?uri?) -> Enumerable[Cookie]
 
       def merge: (_Each[cookie] cookies) -> instance
 

data/sig/plugins/grpc.rbs

@@ -39,8 +39,8 @@ module HTTPX
 
         def self?.encode: (String bytes, ?deflater: Compression::_Deflater?) -> String
 
-        def self?.decode: (String message, encodings: Array[String], encoders: Compression::encodings_registry) -> String
-                        | (String message, encodings: Array[String], encoders: Compression::encodings_registry) { (String) -> void } -> void
+        def self?.decode: (String message, encodings: Array[String], encoders: Hash[String, Compression::_Compressor]) -> String
+                        | (String message, encodings: Array[String], encoders: Hash[String, Compression::_Compressor]) { (String) -> void } -> void
 
         def self?.cancel: (Request) -> void
 
@@ -65,7 +65,7 @@ module HTTPX
       module ResponseMethods
         def merge_headers: (headers_input trailers) -> void
 
-        def encoders: () -> Compression::encodings_registry
+        def encoders: () -> Hash[String, Compression::_Compressor]
       end
 
       module InstanceMethods

data/sig/plugins/h2c.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module H2C
-      VALID_H2C_VERBS: Array[Symbol]
+      VALID_H2C_VERBS: Array[verb]
 
       def self.load_dependencies: (*untyped) -> void
       def self.configure: (singleton(Session)) -> void

data/sig/plugins/proxy.rbs

@@ -35,11 +35,7 @@ module HTTPX
       def self.extra_options: (Options) -> (Options & _ProxyOptions)
 
       module InstanceMethods
-        private
-
-        def proxy_uris: (generic_uri, Options & _ProxyOptions) -> { uri: generic_uri, username: String, password: String }
-                      | (generic_uri, Options & _ProxyOptions) -> { uri: generic_uri }
-                      | (generic_uri, Options & _ProxyOptions) -> nil
+        @__proxy_uris: Array[generic_uri]
       end
     end
 

data/sig/plugins/response_cache.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module ResponseCache
-      CACHEABLE_VERBS: Array[Symbol]
+      CACHEABLE_VERBS: Array[verb]
 
       def self?.cacheable_request?: (Request request) -> bool
       def self?.cacheable_response?: (response response) -> bool

data/sig/plugins/retries.rbs

@@ -2,40 +2,60 @@ module HTTPX
   module Plugins
     module Retries
       MAX_RETRIES: Integer
-      IDEMPOTENT_METHODS: Array[verb]
+      IDEMPOTENT_METHODS: Array[String]
       RETRYABLE_ERRORS: Array[singleton(StandardError)]
       DEFAULT_JITTER: ^(Numeric) -> Numeric
 
       interface _RetryCallback
-        def call: (response) -> bool?
+        def call: (response response) -> bool?
       end
 
       interface _RetriesOptions
         def retry_after: () -> Numeric?
 
-        def retry_jitter: () -> ^(Numeric) -> Numeric
+        def retry_jitter: () -> ^(Numeric jitter) -> Numeric
 
-        def max_retries: () -> Integer?
+        def max_retries: () -> Integer
 
         def retry_change_requests: () -> boolish
 
         def retry_on: () -> _RetryCallback?
       end
 
-      def self.extra_options: (Options) -> (Options & _RetriesOptions)
+      def self.extra_options: (Options options) -> retriesOptions
 
       module InstanceMethods
         def max_retries: (int) -> instance
 
         private
 
-        def __repeatable_request?: (Request, Options) -> boolish
-        def __retryable_error?: (_Exception) -> bool
+        def __repeatable_request?: (retriesRequest request, retriesOptions options) -> boolish
+
+        def __retryable_error?: (_Exception error) -> bool
+
+        def __try_partial_retry: (retriesRequest request, (retriesResponse | ErrorResponse) response) -> void
+
       end
 
       module RequestMethods
-      	def retries: () -> Integer
+        @options: Options & _RetriesOptions
+
+        attr_accessor retries: Integer
+
+        attr_writer partial_response: Response?
+
+        def response=: (retriesResponse | ErrorResponse response) -> void
       end
+
+      module ResponseMethods
+        def from_partial_response: (Response response) -> void
+      end
+
+      type retriesOptions = Options & _RetriesOptions
+
+      type retriesRequest = Request & RequestMethods
+
+      type retriesResponse = Response & ResponseMethods
     end
 
     type sessionRetries = Session & Retries::InstanceMethods

data/sig/plugins/upgrade.rbs

@@ -1,18 +1,20 @@
 module HTTPX
   module Plugins
     module Upgrade
-      type handlers_registry = Registry[Symbol, Class]
+      interface _Upgrader
+        def call: (Connection connection, Request request, Response response) -> void
+      end
 
       def self.configure: (singleton(Session)) -> void
 
       interface _UpgradeOptions
-        def upgrade_handlers: () -> handlers_registry?
+        def upgrade_handlers: () -> Hash[String, _Upgrader]
       end
 
       def self.extra_options: (Options) -> (Options & _UpgradeOptions)
 
       module ConnectionMethods
-        attr_reader upgrade_protocol: Symbol?
+        attr_reader upgrade_protocol: String?
         attr_reader hijacked: boolish
 
         def hijack_io: () -> void

data/sig/request.rbs

@@ -6,8 +6,8 @@ module HTTPX
     METHODS: Array[Symbol]
     USER_AGENT: String
 
-    attr_reader verb: Symbol
-    attr_reader uri: URI::Generic
+    attr_reader verb: verb
+    attr_reader uri: URI::HTTP | URI::HTTPS
     attr_reader headers: Headers
     attr_reader body: Body
     attr_reader state: Symbol
@@ -56,6 +56,10 @@ module HTTPX
 
     def request_timeout: () -> Numeric
 
+    private
+
+    def initialize_body: (Options options) -> Transcoder::_Encoder?
+
     class Body
       @headers: Headers
       @body: body_encoder?

data/sig/resolver/https.rbs

@@ -34,7 +34,9 @@ module HTTPX
 
       def build_request: (String hostname) -> Request
 
-      def decode_response_body: (Response) -> Array[dns_result]?
+      def decode_response_body: (Response) -> dns_decoding_response
+
+      def reset_hostname: (String hostname, ?reset_candidates: bool) -> Connection?
     end
   end
 end

data/sig/resolver/native.rbs

@@ -11,7 +11,8 @@ module HTTPX
 
       @options: Options
       @ns_index: Integer
-      @nameserver: Array[String]?
+      @nameserver: Array[String]
+      @socket_type: :udp | :tcp
       @ndots: Integer
       @start_timeout: Float?
       @search: Array[String]
@@ -20,6 +21,8 @@ module HTTPX
       @connections: Array[Connection]
       @read_buffer: String
       @write_buffer: Buffer
+      @large_packet: Buffer?
+      @io: UDP | TCP
 
       attr_reader state: Symbol
 
@@ -54,11 +57,13 @@ module HTTPX
 
       def generate_candidates: (String) -> Array[String]
 
-      def build_socket: () -> void
+      def build_socket: () -> (UDP | TCP)
 
       def transition: (Symbol nextstate) -> void
 
       def handle_error: (NativeResolveError | StandardError) -> void
+
+      def reset_hostname: (String hostname, ?reset_candidates: bool) -> void
     end
   end
 end

data/sig/resolver/resolver.rbs

@@ -6,8 +6,6 @@ module HTTPX
 
       RECORD_TYPES: Hash[Integer, singleton(Resolv::DNS::Resource)]
 
-      attr_reader family: ip_family?
-
       @record_type: singleton(Resolv::DNS::Resource)
       @options: Options
       @resolver_options: Hash[Symbol, untyped]

data/sig/resolver/system.rbs

@@ -5,6 +5,8 @@ module HTTPX
 
       @resolver: Resolv::DNS
 
+      attr_reader family: nil
+
       def <<: (Connection) -> void
 
       private

data/sig/resolver.rbs

@@ -2,8 +2,6 @@ module HTTPX
   type ipaddr = IPAddr | String
 
   module Resolver
-    extend Registry[Symbol, Class]
-
     RESOLVE_TIMEOUT: Integer | Float
 
     @lookup_mutex: Thread::Mutex
@@ -13,6 +11,7 @@ module HTTPX
     type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
                     | { "name" => String, "TTL" => Numeric, "data" => String }
 
+    type dns_decoding_response = [:ok, Array[dns_result]] | [:decode_error, Resolv::DNS::DecodeError] | [:dns_error, Integer] | Symbol
 
     def nolookup_resolve: (String hostname) -> Array[IPAddr]
 
@@ -20,6 +19,11 @@ module HTTPX
 
     def system_resolve: (String hostname) -> Array[IPAddr]?
 
+    def self?.resolver_for: (:native resolver_type) -> singleton(Native) |
+                            (:system resolver_type) -> singleton(System) |
+                            (:https resolver_type) -> singleton(HTTPS) |
+                            [U] (U resolver_type) -> U
+
     def self?.cached_lookup: (String hostname) -> Array[IPAddr]?
 
     def self?.cached_lookup_set: (String hostname, ip_family family, Array[dns_result] addresses) -> void
@@ -28,8 +32,8 @@ module HTTPX
 
     def self?.generate_id: () -> Integer
 
-    def self?.encode_dns_query: (String hostname, ?type: dns_resource) -> String
+    def self?.encode_dns_query: (String hostname, ?type: dns_resource, ?message_id: Integer) -> String
 
-    def self?.decode_dns_answer: (String) -> Array[dns_result]?
+    def self?.decode_dns_answer: (String) -> dns_decoding_response
   end
 end

data/sig/response.rbs

@@ -41,14 +41,14 @@ module HTTPX
     def initialize: (Request request, String | Integer status, String version, headers?) -> untyped
     def no_data?: () -> bool
 
-    def decode:(String format, ?untyped options) -> untyped
+    def decode:(Transcoder::_Decode transcoder, ?untyped options) -> untyped
 
     class Body
       include _Reader
       include _ToS
       include _ToStr
 
-      attr_reader encoding: String
+      attr_reader encoding: Encoding | String
 
       @response: Response
       @headers: Headers
@@ -108,10 +108,14 @@ module HTTPX
 
     attr_reader request: Request
 
+    attr_reader response: Response?
+
     def status: () -> (Integer | _ToS)
 
     def uri: () -> URI::Generic
 
+    def close: () -> void
+
     private
 
     def initialize: (Request, Exception, options) -> untyped

data/sig/session.rbs

@@ -11,13 +11,11 @@ module HTTPX
 
     def self.plugin: (Symbol | Module plugin, ?options? options) ?{ (Class) -> void } -> singleton(Session)
 
-    def self.default_options: -> Options
-
     def wrap: () { (instance) -> void } -> void
 
     def close: (*untyped) -> void
 
-    def build_request: (String | verb, generic_uri, ?options) -> Request
+    def build_request: (verb, generic_uri, ?options) -> Request
 
     private
 
@@ -27,7 +25,7 @@ module HTTPX
     def pool: -> Pool
     def on_response: (Request, response) -> void
     def on_promise: (untyped, untyped) -> void
-    def fetch_response: (Request request, untyped, untyped) -> response?
+    def fetch_response: (Request request, Array[Connection] connections, untyped options) -> response?
 
     def find_connection: (Request, Array[Connection] connections, Options options) -> Connection
 
@@ -35,18 +33,20 @@ module HTTPX
 
     def build_altsvc_connection: (Connection existing_connection, Array[Connection] connections, URI::Generic alt_origin, String origin, Hash[String, String] alt_params, Options options) -> Connection?
 
-    def build_requests: (verb | string, uri, options) -> Array[Request]
-                      | (Array[[verb | string, uri, options]], options) -> Array[Request]
-                      | (Array[[verb | string, uri]], options) -> Array[Request]
-                      | (verb | string, _Each[[uri, options]], Options) -> Array[Request]
-                      | (verb | string, _Each[uri], options) -> Array[Request]
+    def build_requests: (verb, uri, options) -> Array[Request]
+                      | (Array[[verb, uri, options]], options) -> Array[Request]
+                      | (Array[[verb, uri]], options) -> Array[Request]
+                      | (verb, _Each[[uri, options]], Options) -> Array[Request]
+                      | (verb, _Each[uri], options) -> Array[Request]
 
-    def build_connection: (URI::Generic, Options) -> Connection
+    def build_connection: (URI::HTTP | URI::HTTPS uri, Options options) -> Connection
 
     def send_requests: (*Request) -> Array[response]
 
     def _send_requests: (Array[Request]) -> Array[Connection]
 
     def receive_requests: (Array[Request], Array[Connection]) -> Array[response]
+
+    attr_reader self.default_options: Options
   end
 end

data/sig/transcoder/xml.rbs

@@ -1,5 +1,5 @@
 module HTTPX::Transcoder
-  module XML
+  module Xml
 
     def self?.encode: (untyped xml) -> Encoder
     def self?.decode: (HTTPX::Response response) -> _Decoder

data/sig/transcoder.rbs

@@ -4,11 +4,6 @@ module HTTPX
   type body_encoder = Transcoder::_Encoder | _Each[String]
 
   module Transcoder
-    def self?.registry: (String tag) -> _Encode
-                   | () -> Hash[String, _Encode]
-
-    def self?.register: (String tag, _Encode handler) -> void
-
     def self?.normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value, ?(^(untyped value) -> bool | nil) cond) { (String, ?untyped) -> U } -> U
 
     def self?.normalize_query: (Hash[String, untyped] params, String name, String v, Integer depth) -> void
@@ -17,6 +12,10 @@ module HTTPX
       def encode: (untyped payload) -> body_encoder
     end
 
+    interface _Decode
+      def decode: (HTTPX::Response response) -> _Decoder
+    end
+
     interface _Encoder
       def bytesize: () -> (Integer | Float)
     end