httpx 1.2.6 → 1.4.4

data/sig/plugins/content_digest.rbs

@@ -0,0 +1,51 @@
+module HTTPX
+  module Plugins
+    module ContentDigest
+      class Error < HTTPX::Error
+      end
+      class ValidationError < Error
+        attr_reader response: Response
+
+        def initialize: (String message, Response response) -> void
+      end
+      class MissingContentDigestError < ValidationError
+      end
+      class InvalidContentDigestError < ValidationError
+      end
+
+      SUPPORTED_ALGORITHMS: Hash[String, singleton(OpenSSL::Digest)]
+
+      interface _ContentDigestOptions
+        def digest_algorithm: () -> String
+        def encode_content_digest: () -> (bool | ^(Request) -> boolish)
+        def validate_content_digest: () -> (bool | ^(contentDigestResponse) -> boolish)
+      end
+
+      # def self.extra_options: (Options) -> contentDigestOptions
+
+      module InstanceMethods
+        private
+
+        def validate_content_digest: (Response response) -> void
+
+        def extract_content_digests: (String) -> Hash[String, String]
+
+        def base64digest: (Request::Body | contentDigestResponseBody body) -> String
+      end
+
+      module ResponseMethods
+        attr_reader body: contentDigestResponseBody
+      end
+
+      module ResponseBodyMethods
+        attr_reader content_digest_buffer: Response::Buffer?
+      end
+
+      type contentDigestOptions = Options & _ContentDigestOptions
+      type contentDigestResponse = Response & ResponseMethods
+      type contentDigestResponseBody = Response::Body & ResponseBodyMethods
+    end
+
+    type sessionContentDigest = Session & ContentDigest::InstanceMethods
+  end
+end

data/sig/plugins/cookies/cookie.rbs

@@ -17,6 +17,10 @@ module HTTPX
 
       attr_reader created_at: Time
 
+      @for_domain: bool
+
+      @domain_name: DomainName
+
       def path=: (string) -> void
 
       def domain=: (string) -> void
@@ -43,6 +47,11 @@ module HTTPX
                     | (_ToS, _ToS, ?cookie_attributes) -> untyped
 
       def acceptable_from_uri?: (uri) -> bool
+
+      module Scanner
+        RE_BAD_CHAR: Regexp
+        def self?.quote: (String s) -> String
+      end
     end
   end
 end

data/sig/plugins/follow_redirects.rbs

@@ -24,7 +24,7 @@ module HTTPX
       module InstanceMethods
         def max_redirects: (_ToI) -> instance
 
-        def redirect_request_headers: (http_uri original_uri, http_uri redirect_uri, Headers headers, Options & _FollowRedirectsOptions options) -> Headers
+        def handle_after_redirect_request: (http_uri original_uri, http_uri redirect_uri, Request request, Options & _FollowRedirectsOptions options) -> void
 
         def __get_location_from_response: (Response) -> http_uri
       end

data/sig/plugins/grpc/call.rbs

@@ -4,6 +4,10 @@ module HTTPX
       class Call
         attr_writer decoder: _Callable
 
+        @response: Response | StreamResponse
+        @consumed: bool
+        @grpc_response: Enumerator[String] | String
+
         def metadata: () -> headers
 
         def trailing_metadata: () -> headers?

data/sig/plugins/persistent.rbs

@@ -4,8 +4,11 @@ module HTTPX
       def self.load_dependencies: (singleton(Session)) -> void
 
       def self.extra_options: (Options) -> (Options)
+
+      module InstanceMethods
+      end
     end
 
-    type sessionPersistent = sessionFollowRedirects
+    type sessionPersistent = Session & Persistent::InstanceMethods
   end
 end

data/sig/plugins/proxy/http.rbs

@@ -16,6 +16,9 @@ module HTTPX
           def __http_on_connect: (top, Response) ->  void
         end
 
+        class ConnectRequest < Request
+          def initialize: (generic_uri uri, Options options) -> void
+        end
       end
     end
 

data/sig/plugins/proxy/socks5.rbs

@@ -6,6 +6,14 @@ module HTTPX
     module Proxy
       module Socks5
         VERSION: Integer
+        NOAUTH: Integer
+        PASSWD: Integer
+        NONE: Integer
+        CONNECT: Integer
+        IPV4: Integer
+        DOMAIN: Integer
+        IPV6: Integer
+        SUCCESS: Integer
 
         module ConnectionMethods
           def __socks5_proxy_connect: () ->  void
@@ -31,9 +39,9 @@ module HTTPX
         end
 
         module Packet
-          def self?.negotiate: (Parameters) -> String
-          def self?.authenticate: (Parameters) -> String
-          def self?.connect: (uri) -> String
+          def self?.negotiate: (Parameters parameters) -> String
+          def self?.authenticate: (Parameters parameters) -> String
+          def self?.connect: (uri uri) -> String
         end
       end
     end

data/sig/plugins/proxy.rbs

@@ -6,15 +6,25 @@ module HTTPX
   end
 
   module Plugins
+    interface _Authenticator
+      def authenticate: (Request request, String authenticate) -> String
+    end
+
     module Proxy
       Error: singleton(HTTPProxyError)
       PROXY_ERRORS: Array[singleton(StandardError)]
 
       class Parameters
-        attr_reader uri: URI::Generic
+        attr_reader uri: URI::Generic?
         attr_reader username: String?
         attr_reader password: String?
         attr_reader scheme: String?
+        attr_reader no_proxy: Array[String]?
+
+        @uris: Array[URI::Generic | String]
+        @authenticator: _Authenticator
+
+        def shift: () -> void
 
         def can_authenticate?: (*untyped) -> boolish
 
@@ -24,15 +34,17 @@ module HTTPX
 
         private
 
-        def initialize: (uri: generic_uri, ?scheme: String, ?username: String, ?password: String, **untyped) -> untyped
+        def initialize: (?uri: generic_uri | Array[generic_uri], ?scheme: String, ?username: String, ?password: String, ?no_proxy: Array[generic_uri] | generic_uri, **untyped) -> void
+
+        def infer_default_auth_scheme: (URI::Generic uri) -> String?
+
+        def load_authenticator: (String scheme, String username, String password, **untyped) -> _Authenticator
       end
 
       def self.configure: (singleton(Session)) -> void
 
-      type proxyParam = Parameters | Hash[Symbol, untyped]
-
       interface _ProxyOptions
-        def proxy: () -> proxyParam?
+        def proxy: () -> Parameters?
       end
 
       def self.extra_options: (Options) -> (Options & _ProxyOptions)
@@ -42,10 +54,7 @@ module HTTPX
 
         private
 
-        def proxy_error?: (Request request, response) -> bool
-      end
-
-      module ConnectionMethods
+        def proxy_error?: (Request request, response, Options options) -> bool
       end
     end
 

data/sig/plugins/push_promise.rbs

@@ -2,16 +2,19 @@ module HTTPX
   module Plugins
     module PushPromise
       module ResponseMethods
+        @__pushed: bool?
+
         def pushed?: () -> boolish
         def mark_as_pushed!: () -> void
       end
 
       module InstanceMethods
+        @promise_headers: Hash[::HTTP2::Stream, Request]?
         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

@@ -1,6 +1,8 @@
 module HTTPX
   module Plugins
     module RateLimiter
+      RATE_LIMIT_CODES: Array[Integer]
+
       def self.load_dependencies: (singleton(Session)) -> void
 
       def self.retry_on_rate_limited_response: (_Response) -> bool

data/sig/plugins/retries.rbs

@@ -29,7 +29,7 @@ module HTTPX
 
         private
 
-        def fetch_response: (retriesRequest request, Array[Connection] connections, retriesOptions options) -> (retriesResponse | ErrorResponse)?
+        def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> (retriesResponse | ErrorResponse)?
 
         def __repeatable_request?: (retriesRequest request, retriesOptions options) -> boolish
 

data/sig/plugins/ssrf_filter.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  class ServerSideRequestForgeryError < Error
+  end
+
+  module Plugins
+    module SsrfFilter
+      IPV4_BLACKLIST: Array[IPAddr]
+
+      IPV6_BLACKLIST: Array[[IPAddr, IPAddr]]
+
+      def self?.unsafe_ip_address?: (IPAddr) -> bool
+
+      interface _Options
+        def allowed_schemes: () -> Array[String]
+      end
+
+      module InstanceMethods
+      end
+
+      module ConnectionMethods
+      end
+    end
+
+    type sessionSsrf = Session & SsrfFilter::InstanceMethods
+  end
+end

data/sig/plugins/stream.rbs

@@ -27,7 +27,10 @@ module HTTPX
     type streamRequest = Request & Plugins::Stream::RequestMethods
 
     @request: streamRequest
+    @options: Options
     @session: Plugins::sessionStream
+    @response_enum: Enumerator[String]?
+    @buffered_chunks: Array[String]
     @on_chunk: ^(String) -> void | nil
 
     def each: () { (String) -> void } -> void

data/sig/plugins/webdav.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module WebDav
+      module InstanceMethods
+        def copy: (String src, String dst) -> (Response | ErrorResponse)
+
+        def move: (String src, String dst) -> (Response | ErrorResponse)
+
+        def lock: (String path, ?timeout: Numeric) ?{ (Response response) -> void } -> (Response | ErrorResponse)
+
+        def unlock: (String path, String? lock_token) -> (Response | ErrorResponse)
+
+        def mkcol: (String dir) -> Response
+
+        def propfind: (String path, ?(:acl | String) xml) -> Response
+
+        def proppatch: (String path, String xml) -> Response
+      end
+    end
+
+    type sessionWebDav = Session & WebDav::InstanceMethods
+  end
+end

data/sig/plugins/xml.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  module Plugins
+    module XML
+      MIME_TYPES: Regexp
+
+      module Transcoder
+        def self?.encode: (Nokogiri::XML::Node | String xml) -> Encoder
+        def self?.decode: (HTTPX::Response response) -> HTTPX::Transcoder::_Decoder
+
+        class Encoder
+          @raw: Nokogiri::XML::Node | String # can be nokogiri object
+
+          def content_type: () -> String
+
+          def bytesize: () -> (Integer | Float)
+
+          def to_s: () -> String
+
+          private
+
+          def initialize: (Nokogiri::XML::Node | String xml) -> void
+        end
+      end
+
+      module InstanceMethods
+      end
+
+      module ResponseMethods
+        def xml: () -> Nokogiri::XML::Node
+      end
+
+      module RequestBodyClassMethods
+      end
+    end
+    type sessionXML = Session & XML::InstanceMethods
+  end
+end

data/sig/pool.rbs

@@ -1,52 +1,46 @@
 module HTTPX
+  type pool_options = {
+    max_connections_per_origin: Integer?,
+    pool_timeout: Numeric?
+  }
+
   class Pool
+    POOL_TIMEOUT: Integer
+
     type resolver_manager = Resolver::Multi | Resolver::System
 
-    @resolvers: Hash[Class, resolver_manager]
-    @timers: Timers
-    @selector: Selector
-    @connections: Array[Connection]
+    @max_connections_per_origin: Integer
+    @pool_timeout: Numeric
+    @options: Options
+    @resolvers: Hash[Class, Array[resolver_manager]]
+    @resolver_mtx: Thread::Mutex
+    @connections: Hash[String, Array[Connection]]
+    @connection_mtx: Thread::Mutex
+    @origin_counters: Hash[String, Integer]
+    @origin_conds: Hash[String, ConditionVariable]
 
-    def wrap: () { (instance) -> void } -> void
+    def pop_connection: () -> Connection?
 
-    def empty?: () -> void
+    def checkout_connection: (http_uri uri, Options options) -> Connection
 
-    def next_tick: () -> void
+    def checkin_connection: (Connection connection) -> void
 
-    def close: (?Array[Connection] connections) -> void
+    def checkout_mergeable_connection: (Connection connection) -> Connection?
 
-    def init_connection: (Connection connection, Options options) -> void
+    def reset_resolvers: () -> void
 
-    def find_connection: (URI::Generic uri, Options options) -> Connection?
+    def checkout_resolver: (Options options) -> resolver_manager
 
-    def deactivate: (*Array[Connection]) -> void
+    def checkin_resolver: (Resolver::Resolver resolver) -> void
 
     private
 
-    def initialize: () -> void
-
-    def try_clone_connection: (Connection connection, Integer? family) -> Connection
-
-    def resolve_connection: (Connection) -> void
-
-    def on_resolver_connection: (Connection) -> void
-
-    def on_resolver_error: (Connection, StandardError) -> void
-
-    def on_resolver_close: (Resolver::Resolver) -> void
-
-    def register_connection: (Connection) -> void
-
-    def unregister_connection: (Connection, ?bool cleanup) -> void
-
-    def select_connection: (Selector::selectable) -> void
-
-    def deselect_connection: (Selector::selectable) -> Selector::selectable?
+    def initialize: (pool_options options) -> void
 
-    def coalesce_connections: (Connection coalescable, Connection coalescing) -> void
+    def acquire_connection: (http_uri uri, Options options) -> Connection?
 
-    def next_timeout: () -> Numeric?
+    def checkout_new_connection: (http_uri uri, Options options) -> Connection
 
-    def find_resolver_for: (Connection) { (Resolver::Resolver resolver) -> void } -> resolver_manager
+    def checkout_new_resolver: (Class resolver_type, Options options) -> resolver_manager
   end
 end

data/sig/request/body.rbs

@@ -1,10 +1,12 @@
 module HTTPX
   class Request::Body
+    attr_reader options: Options
+
     @headers: Headers
     @body: body_encoder?
     @unbounded_body: bool
 
-    def initialize: (Headers headers, Options options) -> void
+    def initialize: (Headers h, Options options, **untyped) -> void
 
     def each: () { (String) -> void } -> void
             | () -> Enumerable[String]
@@ -25,16 +27,8 @@ module HTTPX
 
     private
 
-    def initialize_body: (Options options) -> void
+    def self.initialize_body: (Hash[Symbol, untyped] params) -> body_encoder?
 
     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

@@ -14,17 +14,28 @@ module HTTPX
     attr_reader options: Options
     attr_reader response: response?
     attr_reader drain_error: StandardError?
+    attr_reader active_timeouts: Array[Symbol]
 
     attr_accessor peer_address: ipaddr?
 
     attr_writer persistent: bool
 
+    @ping: 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 ping?: () -> bool
+
+    def ping!: () -> void
+
+    def empty?: () -> bool
+
+    def close: () -> void
 
     def interests: () -> (:r | :w)
 
@@ -62,6 +73,8 @@ module HTTPX
 
     def request_timeout: () -> Numeric?
 
+    def set_timeout_callback: (Symbol event) { (*untyped) -> void } -> void
+
     private
 
     def initialize_body: (Options options) -> Transcoder::_Encoder?

data/sig/resolver/multi.rbs

@@ -1,7 +1,32 @@
 module HTTPX
   module Resolver
     class Multi
-      def early_resolve: (Connection connection, ?hostname: String) -> void
+      attr_reader resolvers: Array[Native | HTTPS]
+
+      attr_reader options: Options
+
+      @current_selector: Selector?
+      @current_session: Session?
+      @resolver_options: Hash[Symbol, untyped]
+      # @errors: Hash[Symbol, untyped]
+
+      def current_selector=: (Selector s) -> void
+
+      def current_session=: (Session s) -> void
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def timeout: () -> Numeric?
+
+      def close: () -> void
+
+      def connections: () -> Array[Connection]
+
+      def early_resolve: (Connection connection) -> bool
+
+      def lazy_resolve: (Connection connection) -> void
     end
   end
 end

data/sig/resolver/native.rbs

@@ -7,8 +7,6 @@ module HTTPX
       DEFAULTS: Hash[Symbol, untyped]
       DNS_PORT: Integer
 
-      attr_reader family: ip_family
-
       @options: Options
       @ns_index: Integer
       @nameserver: Array[String]
@@ -23,6 +21,7 @@ module HTTPX
       @write_buffer: Buffer
       @large_packet: Buffer?
       @io: UDP | TCP
+      @name: String?
 
       attr_reader state: Symbol
 
@@ -44,7 +43,9 @@ module HTTPX
 
       def consume: () -> void
 
-      def do_retry: (?Numeric? loop_time) -> void
+      def schedule_retry: () -> void
+
+      def do_retry: (String host, Connection connection, Numeric interval) -> void
 
       def dread: (Integer) -> void
                | () -> void
@@ -66,6 +67,8 @@ module HTTPX
       def handle_error: (NativeResolveError | StandardError) -> void
 
       def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
+
+      def close_or_resolve: () -> void
     end
   end
 end

data/sig/resolver/resolver.rbs

@@ -6,8 +6,17 @@ module HTTPX
 
       RECORD_TYPES: Hash[Integer, singleton(Resolv::DNS::Resource)]
 
+      attr_reader family: ip_family
+
+      attr_reader options: Options
+
+      attr_writer current_selector: Selector?
+
+      attr_writer current_session: Session?
+
+      attr_accessor multi: Multi?
+
       @record_type: singleton(Resolv::DNS::Resource)
-      @options: Options
       @resolver_options: Hash[Symbol, untyped]
       @queries: Hash[String, Connection]
       @system_resolver: Resolv::Hosts
@@ -20,15 +29,25 @@ module HTTPX
 
       def empty?: () -> bool
 
+      def each_connection: () { (Connection connection) -> void } -> void
+
       def emit_addresses: (Connection connection, ip_family family, Array[IPAddr], ?bool early_resolve) -> void
 
       private
 
       def emit_resolved_connection: (Connection connection, Array[IPAddr] addresses, bool early_resolve) -> void
 
-      def initialize: (ip_family? family, options options) -> void
+      def initialize: (ip_family? family, Options options) -> void
+
+      def early_resolve: (Connection connection, ?hostname: String) -> bool
+
+      def set_resolver_callbacks: () -> void
+
+      def resolve_connection: (Connection connection) -> void
+
+      def emit_connection_error: (Connection connection, StandardError error) -> void
 
-      def early_resolve: (Connection connection, ?hostname: String) -> void
+      def close_resolver: (Resolver resolver) -> void
 
       def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
 

data/sig/resolver.rbs

@@ -28,12 +28,16 @@ module HTTPX
 
     def self?.cached_lookup_set: (String hostname, ip_family family, Array[dns_result] addresses) -> void
 
-    def self?.lookup: (String hostname, Numeric ttl) -> Array[IPAddr]?
+    def self?.lookup: (String hostname, Hash[String, Array[dns_result]] lookups, Numeric ttl) -> Array[IPAddr]?
 
     def self?.generate_id: () -> Integer
 
     def self?.encode_dns_query: (String hostname, ?type: dns_resource, ?message_id: Integer) -> String
 
     def self?.decode_dns_answer: (String) -> dns_decoding_response
+
+    def self?.lookup_synchronize: [U] () { (Hash[String, Array[dns_result]] lookups) -> U } -> U
+
+    def self?.id_synchronize: () { () -> void } -> void
   end
 end

data/sig/response/body.rbs

@@ -4,8 +4,8 @@ module HTTPX
     include _ToS
     include _ToStr
 
-    attr_reader encoding: Encoding | String
-    attr_reader encodings: Array[Encoding | String]
+    attr_reader encoding: Encoding
+    attr_reader encodings: Array[String]
 
     @response: Response
     @headers: Headers

data/sig/response/buffer.rbs

@@ -5,11 +5,11 @@ module HTTPX
     @encoding: Encoding
     @buffer: StringIO | Tempfile
 
-    def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding | String) -> void
+    def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding) -> void
 
     def size: () -> Integer
 
-    def write: (String) -> void
+    def write: (String chunk) -> Integer
 
     def to_s: () -> String