httpx 0.20.0 → 1.3.1

data/sig/plugins/proxy/socks4.rbs

@@ -1,20 +1,23 @@
 module HTTPX
-  Socks4Error: singleton(Error)
+  class Socks4Error < HTTPProxyError
+  end
 
   module Plugins
     module Proxy
       module Socks4
-      
+
         module ConnectionMethods
           def __socks4_proxy_connect: () ->  void
           def __socks4_on_packet: (String packet) ->  void
           def on_socks4_error: (string) -> void
         end
-        
+
         class SocksParser
-          include Callbacks
+          include HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
 
-          def timeout: () -> Integer
           def close: () -> void
           def consume: (*untyped) -> void
           def empty: () -> bool
@@ -22,7 +25,7 @@ module HTTPX
 
           private
 
-          def initialize: (Buffer buffer, Options) -> untyped
+          def initialize: (Buffer buffer, Options options) -> untyped
         end
 
         module Packet

data/sig/plugins/proxy/socks5.rbs

@@ -1,21 +1,25 @@
 module HTTPX
-  Socks5Error: singleton(Error)
+  class Socks5Error < HTTPProxyError
+  end
 
   module Plugins
     module Proxy
       module Socks5
-      
+        VERSION: Integer
+
         module ConnectionMethods
           def __socks5_proxy_connect: () ->  void
           def __socks5_on_packet: (String packet) ->  void
           def __socks5_check_version: (int) -> void
           def __on_socks5_error: (string) -> void
         end
-        
+
         class SocksParser
-          include Callbacks
+          include HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
 
-          def timeout: () -> Integer
           def close: () -> void
           def consume: (*untyped) -> void
           def empty: () -> bool
@@ -23,7 +27,7 @@ module HTTPX
 
           private
 
-          def initialize: (Buffer buffer, Options) -> untyped
+          def initialize: (Buffer buffer, Options options) -> untyped
         end
 
         module Packet

data/sig/plugins/proxy/ssh.rbs

@@ -7,7 +7,7 @@ module HTTPX
         module InstanceMethods
           private
 
-          def build_gateway_socket: (int, URI::HTTP | URI::HTTPS, Options) ->  _ToIO
+          def build_gateway_socket: (int, http_uri, Options) ->  _ToIO
         end
       end
     end

data/sig/plugins/proxy.rbs

@@ -1,5 +1,8 @@
 module HTTPX
-  class HTTPProxyError < Error
+  class HTTPProxyError < ConnectionError
+  end
+
+  class ProxySSL < SSL
   end
 
   module Plugins
@@ -21,7 +24,7 @@ module HTTPX
 
         private
 
-        def initialize: (uri: generic_uri, ?scheme: String, ?username: String, ?password: String, **extra) -> untyped
+        def initialize: (uri: generic_uri, ?scheme: String, ?username: String, ?password: String, **untyped) -> untyped
       end
 
       def self.configure: (singleton(Session)) -> void
@@ -35,11 +38,16 @@ module HTTPX
       def self.extra_options: (Options) -> (Options & _ProxyOptions)
 
       module InstanceMethods
+        @__proxy_uris: Array[generic_uri]
+
         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
+        def proxy_error?: (Request request, response) -> bool
+
+        def proxy_options: (http_uri request_uri, Options & _ProxyOptions options) -> (Options & _ProxyOptions)
+      end
+
+      module ConnectionMethods
       end
     end
 

data/sig/plugins/push_promise.rbs

@@ -9,9 +9,9 @@ module HTTPX
       module InstanceMethods
         private
 
-        def promise_headers: () -> Hash[HTTP2Next::Stream, Request]
-        def __on_promise_request: (Connection::HTTP2, HTTP2Next::Stream, headers_input) -> void
-        def __on_promise_response: (Connection::HTTP2, HTTP2Next::Stream, headers_input) -> void
+        def promise_headers: () -> Hash[::HTTP2::Stream, Request]
+        def __on_promise_request: (Connection::HTTP2, ::HTTP2::Stream, headers_input) -> void
+        def __on_promise_response: (Connection::HTTP2, ::HTTP2::Stream, headers_input) -> void
       end
     end
 

data/sig/plugins/rate_limiter.rbs

@@ -5,7 +5,7 @@ module HTTPX
 
       def self.retry_on_rate_limited_response: (_Response) -> bool
 
-      def self.retry_after_rate_limit: (untyped, _Response) -> Numeric?
+      def self.retry_after_rate_limit: (untyped, response) -> Numeric?
     end
   end
 end

data/sig/plugins/response_cache.rbs

@@ -1,22 +1,33 @@
 module HTTPX
   module Plugins
     module ResponseCache
-      CACHEABLE_VERBS: Array[Symbol]
+      CACHEABLE_VERBS: Array[verb]
+      CACHEABLE_STATUS_CODES: Array[Integer]
 
-      def self?.cacheable_request?: (Request request) -> bool
-      def self?.cacheable_response?: (response response) -> bool
+      def self?.cacheable_request?: (Request & RequestMethods request) -> bool
+      def self?.cacheable_response?: (::HTTPX::ErrorResponse | (Response & ResponseMethods) response) -> bool
       def self?.cached_response?: (response response) -> bool
 
       class Store
-        @store: Hash[URI::Generic, Response]
+        @store: Hash[String, Array[Response]]
 
-        def lookup: (URI::Generic uri) -> Response?
+        @store_mutex: Thread::Mutex
 
-        def cached?: (URI::Generic uri) -> bool
+        def lookup: (Request request) -> Response?
 
-        def cache: (URI::Generic uri, Response response) -> void
+        def cached?: (Request request) -> boolish
+
+        def cache: (Request request, Response response) -> void
 
         def prepare: (Request request) -> void
+
+        private
+
+        def match_by_vary?: (Request request, Response response) -> bool
+
+        def _get: (Request request) -> Array[Response]?
+
+        def _set: (Request request, Response response) -> void
       end
 
       module InstanceMethods
@@ -25,8 +36,26 @@ module HTTPX
         def clear_response_cache: () -> void
       end
 
+      module RequestMethods
+        @response_cache_key: String
+
+        def response_cache_key: () -> String
+      end
+
       module ResponseMethods
         def copy_from_cached: (Response other) -> void
+
+        def fresh?: () -> bool
+
+        def cache_control: () -> Array[String]?
+
+        def vary: () -> Array[String]?
+
+        private
+
+        def age: () -> Integer
+
+        def date: () -> Time
       end
     end
 

data/sig/plugins/retries.rbs

@@ -2,40 +2,62 @@ 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 fetch_response: (retriesRequest request, Array[Connection] connections, retriesOptions options) -> (retriesResponse | ErrorResponse)?
+
+        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/stream.rbs

@@ -1,21 +1,4 @@
 module HTTPX
-  class StreamResponse
-    include _ToS
-
-    def each: () { (String) -> void } -> void
-            | () -> Enumerable[String]
-
-    def each_line: () { (String) -> void } -> void
-                 | () -> Enumerable[String]
-
-    def on_chunk: (string) -> void
-
-    private
-
-    def response: () -> response
-    def initialize: (Request, Session, Array[Connection]) -> untyped
-  end
-
   module Plugins
     module Stream
       module InstanceMethods
@@ -37,4 +20,28 @@ module HTTPX
 
     type sessionStream = Session & Stream::InstanceMethods
   end
+
+  class StreamResponse
+    include _ToS
+
+    type streamRequest = Request & Plugins::Stream::RequestMethods
+
+    @request: streamRequest
+    @session: Plugins::sessionStream
+    @on_chunk: ^(String) -> void | nil
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def each_line: () { (String) -> void } -> void
+                 | () -> Enumerable[String]
+
+    def on_chunk: (string) -> void
+
+    def initialize: (streamRequest, Plugins::sessionStream) -> void
+
+    private
+
+    def response: () -> response
+  end
 end

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/pool.rbs

@@ -6,7 +6,8 @@ module HTTPX
     @timers: Timers
     @selector: Selector
     @connections: Array[Connection]
-    @connected_connections: Integer
+
+    def wrap: () { (instance) -> void } -> void
 
     def empty?: () -> void
 
@@ -18,11 +19,13 @@ module HTTPX
 
     def find_connection: (URI::Generic uri, Options options) -> Connection?
 
-    def deactivate: (*Array[Connection]) -> void
+    def deactivate: (*Connection connections) -> void
 
     private
 
-    def initialize: () -> untyped
+    def initialize: () -> void
+
+    def try_clone_connection: (Connection connection, Integer? family) -> Connection
 
     def resolve_connection: (Connection) -> void
 
@@ -34,15 +37,15 @@ module HTTPX
 
     def register_connection: (Connection) -> void
 
-    def unregister_connection: (Connection) -> void
+    def unregister_connection: (Connection, ?bool cleanup) -> void
 
-    def select_connection: (Resolver::Resolver | Connection connection) -> void
+    def select_connection: (Selector::selectable) -> void
 
-    def deselect_connection: (Resolver::Resolver | Connection connection) -> void
+    def deselect_connection: (Selector::selectable) -> Selector::selectable?
 
     def coalesce_connections: (Connection coalescable, Connection coalescing) -> void
 
-    def next_timeout: () -> (Integer | Float | nil)
+    def next_timeout: () -> Numeric?
 
     def find_resolver_for: (Connection) { (Resolver::Resolver resolver) -> void } -> resolver_manager
   end

data/sig/request/body.rbs

@@ -0,0 +1,38 @@
+module HTTPX
+  class Request::Body
+    @headers: Headers
+    @body: body_encoder?
+    @unbounded_body: bool
+
+    def initialize: (Headers headers, Options options, ?body: bodyIO, ?form: Transcoder::urlencoded_input?, ?json: _ToJson?, **untyped) -> void
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def rewind: () -> void
+
+    def empty?: () -> bool
+
+    def bytesize: () -> (Integer | Float)
+
+    def stream: (Transcoder::_Encoder) -> bodyIO
+
+    def unbounded_body?: () -> bool
+
+    def chunked?: () -> bool
+
+    def chunk!: () -> void
+
+    private
+
+    def self.initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+  end
+
+  class ProcIO
+    @block: ^(String) -> void
+
+    def initialize: (^(String) -> void) -> untyped
+
+    def write: (String data) -> Integer
+  end
+end

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: http_uri
     attr_reader headers: Headers
     attr_reader body: Body
     attr_reader state: Symbol
@@ -15,12 +15,17 @@ module HTTPX
     attr_reader response: response?
     attr_reader drain_error: StandardError?
 
+    attr_accessor peer_address: ipaddr?
+
+    attr_writer persistent: bool
+
+    @query_params: Hash[interned, untyped]?
     @trailers: Headers?
     @informational_status: Integer?
     @query: String?
     @drainer: Enumerator[String, void]?
 
-    def initialize: (Symbol | String, generic_uri, ?options) -> untyped
+    def initialize: (Symbol | String verb, generic_uri uri, Options options, ?request_params params) -> untyped
 
     def interests: () -> (:r | :w)
 
@@ -50,31 +55,17 @@ module HTTPX
 
     def trailers?: () -> boolish
 
-    class Body
-      @headers: Headers
-      @body: body_encoder?
-      @unbounded_body: bool
+    def persistent?: () -> bool
+
+    def read_timeout: () -> Numeric?
 
-      def initialize: (Headers, Options) -> untyped
-      def each: () { (String) -> void } -> void
-              | () -> Enumerable[String]
+    def write_timeout: () -> Numeric?
 
-      def rewind: () -> void
-      def empty?: () -> bool
-      def bytesize: () -> Numeric
-      def stream: (Transcoder::_Encoder) -> bodyIO
-      def unbounded_body?: () -> bool
-      def chunked?: () -> bool
-      def chunk!: () -> void
-      def inspect: () -> String
-    end
+    def request_timeout: () -> Numeric?
 
-    class ProcIO
-      @block: ^(String) -> void
+    private
 
-      def initialize: (^(String) -> void) -> untyped
+    def initialize_body: (Options options) -> Transcoder::_Encoder?
 
-      def write: (String data) -> Integer
-    end
   end
 end

data/sig/resolver/https.rbs

@@ -6,11 +6,12 @@ module HTTPX
       DEFAULTS: Hash[Symbol, untyped]
       FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
 
-      @family: ip_family
+      attr_reader family: ip_family
+
       @options: Options
       @requests: Hash[Request, String]
       @connections: Array[Connection]
-      @uri: URI::Generic
+      @uri: http_uri
       @uri_addresses: Array[String]?
       @resolver: Resolv::DNS
       @resolver_connection: Connection
@@ -31,9 +32,13 @@ module HTTPX
 
       def parse: (Request request, Response response) -> void
 
+      def parse_addresses: (Array[dns_result] answers, Request request) -> void
+
       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

@@ -7,15 +7,22 @@ module HTTPX
       DEFAULTS: Hash[Symbol, untyped]
       DNS_PORT: Integer
 
-      @family: ip_family
+      attr_reader family: ip_family
+
       @options: Options
       @ns_index: Integer
-      @nameserver: String
+      @nameserver: Array[String]
+      @socket_type: :udp | :tcp
+      @ndots: Integer
+      @start_timeout: Float?
+      @search: Array[String]
       @_timeouts: Array[Numeric]
       @timeouts: Hash[String, Array[Numeric]]
       @connections: Array[Connection]
       @read_buffer: String
       @write_buffer: Buffer
+      @large_packet: Buffer?
+      @io: UDP | TCP
 
       attr_reader state: Symbol
 
@@ -27,6 +34,8 @@ module HTTPX
 
       def timeout: () -> Numeric?
 
+      def handle_socket_timeout: (Numeric interval) -> void
+
       private
 
       def initialize: (ip_family family, options options) -> void
@@ -35,7 +44,7 @@ module HTTPX
 
       def consume: () -> void
 
-      def do_retry: () -> void
+      def do_retry: (?Numeric? loop_time) -> void
 
       def dread: (Integer) -> void
                | () -> void
@@ -48,11 +57,15 @@ module HTTPX
 
       def generate_candidates: (String) -> Array[String]
 
-      def build_socket: () -> void
+      def build_socket: () -> (UDP | TCP)
+
+      def downgrade_socket: () -> void
 
       def transition: (Symbol nextstate) -> void
 
       def handle_error: (NativeResolveError | StandardError) -> void
+
+      def reset_hostname: (String hostname, ?connection: Connection, ?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]
@@ -16,21 +14,25 @@ module HTTPX
 
       def close: () -> void
 
+      alias terminate close
+
       def closed?: () -> bool
 
       def empty?: () -> bool
 
-      def emit_addresses: (Connection connection, ip_family family, Array[IPAddr]) -> void
+      def emit_addresses: (Connection connection, ip_family family, Array[IPAddr], ?bool early_resolve) -> void
 
       private
 
-      def initialize: (ip_family? family, options options) -> void
+      def emit_resolved_connection: (Connection connection, Array[IPAddr] addresses, bool early_resolve) -> void
+
+      def initialize: (ip_family? family, Options options) -> void
 
-      def early_resolve: (Connection connection, ?hostname: String) -> void
+      def early_resolve: (Connection connection, ?hostname: String) -> boolish
 
       def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
 
-      def resolve_error: (String hostname, ?StandardError?) -> ResolveError
+      def resolve_error: (String hostname, ?StandardError?) -> (ResolveError | ResolveTimeoutError)
     end
   end
 end

data/sig/resolver/system.rbs

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