httpx 1.4.4 → 1.5.0

data/sig/buffer.rbs

@@ -14,7 +14,7 @@ module HTTPX
     def capacity: () -> Integer
 
     # delegated
-    def <<: (string data) -> String
+    def <<: (String data) -> String
     def empty?: () -> bool
     def bytesize: () -> (Integer | Float)
     def clear: () -> void

data/sig/chainable.rbs

@@ -21,14 +21,16 @@ module HTTPX
               | (:cookies, ?options) -> Plugins::sessionCookies
               | (:expect, ?options) -> Session
               | (:follow_redirects, ?options) -> Plugins::sessionFollowRedirects
-              | (:upgrade, ?options) -> Session
-              | (:h2c, ?options) -> Session
+              | (:upgrade, ?options) -> Plugins::sessionUpgrade
+              | (:h2c, ?options) -> Plugins::sessionUpgrade
+              | (:h2, ?options) -> Plugins::sessionUpgrade
               | (:persistent, ?options) -> Plugins::sessionPersistent
               | (:proxy, ?options) -> (Plugins::sessionProxy & Plugins::httpProxy)
               | (:push_promise, ?options) -> Plugins::sessionPushPromise
               | (:retries, ?options) -> Plugins::sessionRetries
               | (:rate_limiter, ?options) -> Session
               | (:stream, ?options) -> Plugins::sessionStream
+              | (:stream_bidi, ?options) -> Plugins::sessionStreamBidi
               | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
               | (:grpc, ?options) -> Plugins::grpcSession
               | (:response_cache, ?options) -> Plugins::sessionResponseCache
@@ -39,6 +41,7 @@ module HTTPX
               | (:ssrf_filter, ?options) -> Plugins::sessionSsrf
               | (:webdav, ?options) -> Plugins::sessionWebDav
               | (:xml, ?options) -> Plugins::sessionXML
+              | (:query, ?options) -> Plugins::sessionQuery
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/connection/http2.rbs

@@ -16,6 +16,8 @@ module HTTPX
     @drains: Hash[Request, String]
     @pings: Array[String]
     @buffer: Buffer
+    @handshake_completed: bool
+    @wait_for_handshake: bool
 
     def interests: () -> io_interests?
 
@@ -27,8 +29,6 @@ module HTTPX
 
     def <<: (string) -> void
 
-    def can_buffer_more_requests?: () -> bool
-
     def send: (Request request, ?bool head) -> bool
 
     def consume: () -> void
@@ -45,6 +45,8 @@ module HTTPX
 
     def initialize: (Buffer buffer, Options options) -> untyped
 
+    def can_buffer_more_requests?: () -> bool
+
     def send_pending: () -> void
 
     def set_protocol_headers: (Request) -> _Each[[String, String]]
@@ -63,6 +65,10 @@ module HTTPX
 
     def join_body: (::HTTP2::Stream stream, Request request) -> void
 
+    def send_chunk: (Request request, ::HTTP2::Stream stream, String chunk, String? next_chunk) -> void
+
+    def end_stream?: (Request request, String? next_chunk) -> void
+
     def on_stream_headers: (::HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
 
     def on_stream_trailers: (::HTTP2::Stream stream, Response response, Array[[String, String]] headers) -> void
@@ -92,12 +98,15 @@ module HTTPX
     def on_pong: (string ping) -> void
 
     class Error < ::HTTPX::Error
+      def initialize: (Integer id, Symbol | StandardError error) -> void
     end
 
     class GoawayError < Error
+      def initialize: () -> void
     end
 
     class PingError < Error
+      def initialize: () -> void
     end
   end
 end

data/sig/connection.rbs

@@ -20,6 +20,7 @@ module HTTPX
 
 
     attr_reader type: io_type
+    attr_reader io: TCP | SSL | UNIX | nil
     attr_reader origin: http_uri
     attr_reader origins: Array[String]
     attr_reader state: Symbol
@@ -39,7 +40,6 @@ module HTTPX
     @keep_alive_timeout: Numeric?
     @timeout: Numeric?
     @current_timeout: Numeric?
-    @io: TCP | SSL | UNIX
     @parser: Object & _Parser
     @connected_at: Float
     @response_received_at: Float
@@ -64,6 +64,8 @@ module HTTPX
 
     def mergeable?: (Connection connection) -> bool
 
+    def coalesce!: (instance connection) -> void
+
     def coalescable?: (Connection connection) -> bool
 
     def create_idle: (?Hash[Symbol, untyped] options) -> instance
@@ -104,8 +106,6 @@ module HTTPX
 
     def handle_socket_timeout: (Numeric interval) -> void
 
-    def coalesced_connection=: (instance connection) -> void
-
     def sibling=: (instance? connection) -> void
 
     def handle_connect_error: (StandardError error) -> void
@@ -164,6 +164,6 @@ module HTTPX
 
     def set_request_timeout: (Symbol label, Request request, Numeric timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
 
-    def self.parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
+    def parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end
 end

data/sig/errors.rbs

@@ -18,9 +18,6 @@ module HTTPX
   end
 
   class PoolTimeoutError < TimeoutError
-    attr_reader origin: String
-
-    def initialize: (String origin, Numeric timeout) -> void
   end
 
   class ConnectTimeoutError < TimeoutError

data/sig/headers.rbs

@@ -2,7 +2,7 @@ module HTTPX
   class Headers
     include _ToS
 
-    @headers: Hash[String, Array[String]]
+    @headers: Hash[String, Array[_ToS]]
 
     def self.new: (?untyped headers) -> instance
 
@@ -11,34 +11,39 @@ module HTTPX
     def []: (String field) -> String?
     def []=: (String field, headers_value value) -> void
 
-    def add: (String field, string value) -> void
-    def delete: (String field) -> Array[String]?
+    def add: (String field, String value) -> void
+    def delete: (String field) -> Array[_ToS]?
 
     def each: (?_Each[[String, String]]? extra_headers) { (String k, String v) -> void } -> void
             | (?_Each[[String, String]]? extra_headers) -> Enumerable[[String, String]]
 
-    def get: (String field) -> Array[String]
+    def get: (String field) -> Array[_ToS]
     def key?: (String downcased_key) -> bool
 
     def merge: (_Each[[String, headers_value]] other) -> Headers
 
-    def same_headers?: (untyped headers) -> bool
+    def empty?: () -> bool
 
     def to_a: () -> Array[[String, String]]
+
     def to_hash: () -> Hash[String, String]
+
     alias to_h to_hash
 
     def inspect: () -> String
 
     private
 
-    def initialize: (?headers?) -> untyped
-    def array_value: (headers_value) -> Array[String]
-    def downcased: (_ToS field) -> String
+    def initialize: (?(headers_input | instance)?) -> void
+
+    def array_value: (headers_value value) -> Array[_ToS]
+
+    def downcased: (header_field field) -> String
   end
 
+  type header_field = string | _ToS
   type headers_value = _ToS | Array[_ToS]
-  type headers_hash = Hash[_ToS, headers_value]
-  type headers_input = headers_hash | Array[[_ToS, string]]
+  type headers_hash = Hash[header_field, headers_value]
+  type headers_input = headers_hash | Array[[header_field, headers_value]]
   type headers = Headers | headers_input
 end

data/sig/httpx.rbs

@@ -2,6 +2,7 @@ module HTTPX
   extend Chainable
 
   EMPTY: Array[untyped]
+  EMPTY_HASH: Hash[untyped, untyped]
 
   VERSION: String
 
@@ -16,7 +17,10 @@ module HTTPX
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 
   module Plugins
-    def self?.load_plugin: (Symbol) -> Module
+    self.@plugins: Hash[Symbol, Module]
+    self.@plugins_mutex: Thread::Mutex
+
+    def self?.load_plugin: (Symbol name) -> Module
 
     def self?.register_plugin: (Symbol, Module) -> void
   end

data/sig/io/tcp.rbs

@@ -14,6 +14,12 @@ module HTTPX
 
     alias host ip
 
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
     # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
     def initialize: (URI::Generic origin, Array[ipaddr]? addresses, Options options) ?{ (instance) -> void } -> void
 

data/sig/loggable.rbs

@@ -11,5 +11,7 @@ module HTTPX
     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

@@ -13,6 +13,7 @@ module HTTPX
     KEEP_ALIVE_TIMEOUT: Integer
     SETTINGS_TIMEOUT: Integer
     CLOSE_HANDSHAKE_TIMEOUT: Integer
+    SET_TEMPORARY_NAME: ^(Module mod, ?Symbol pl) -> void
     DEFAULT_OPTIONS: Hash[Symbol, untyped]
     REQUEST_BODY_IVARS: Array[Symbol]
 
@@ -25,7 +26,7 @@ module HTTPX
     attr_reader uri: URI?
 
     # headers
-    attr_reader headers: Headers?
+    attr_reader headers: headers?
 
     # timeout
     attr_reader timeout: timeout
@@ -89,6 +90,8 @@ module HTTPX
 
     attr_reader response_body_class: singleton(Response::Body)
 
+    attr_reader options_class: singleton(Options)
+
     attr_reader resolver_class: Symbol | Class
 
     attr_reader ssl: Hash[Symbol, untyped]
@@ -109,6 +112,9 @@ module HTTPX
     # persistent
     attr_reader persistent: bool
 
+    # close_on_fork
+    attr_reader close_on_fork: bool
+
     # resolver_options
     attr_reader resolver_options: Hash[Symbol, untyped]
 

data/sig/plugins/cookies/cookie.rbs

@@ -1,7 +1,5 @@
 module HTTPX
   module Plugins::Cookies
-    type cookie_attributes = Hash[Symbol | String, top]
-
     class Cookie
       include Comparable
 
@@ -33,7 +31,7 @@ module HTTPX
       def cookie_value: () -> String
       alias to_s cookie_value
 
-      def valid_for_uri?: (uri) -> bool
+      def valid_for_uri?: (http_uri uri) -> bool
 
       def self.new: (Cookie) -> instance
                     | (cookie_attributes) -> instance

data/sig/plugins/cookies/jar.rbs

@@ -11,12 +11,12 @@ module HTTPX
 
       def add: (Cookie name, ?String path) -> void
 
-      def []: (uri) -> Array[Cookie]
+      def []: (http_uri) -> Array[Cookie]
 
-      def each: (?uri?) { (Cookie) -> void } -> void
-              | (?uri?) -> Enumerable[Cookie]
+      def each: (?http_uri?) { (Cookie) -> void } -> void
+              | (?http_uri?) -> Enumerable[Cookie]
 
-      def merge: (_Each[cookie] cookies) -> instance
+      def merge: (_Each[cookie] cookies) -> self
 
       private
 

data/sig/plugins/cookies/set_cookie_parser.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins::Cookies
+    module SetCookieParser
+      RE_WSP: Regexp
+
+      RE_NAME: Regexp
+
+      RE_BAD_CHAR: Regexp
+
+      RE_COOKIE_COMMA: Regexp
+
+      def self?.call: (String set_cookie) { (String name, String value, cookie_attributes attrs) -> void } -> void
+
+      def self?.scan_dquoted: (StringScanner scanner) -> String
+
+      def self?.scan_value: (StringScanner scanner, ?bool comma_as_separator) -> String
+
+      def self?.scan_name_value: (StringScanner scanner, ?bool comma_as_separator) -> [String?, String?]
+
+    end
+  end
+end

data/sig/plugins/cookies.rbs

@@ -1,6 +1,8 @@
 module HTTPX
   module Plugins
     module Cookies
+      type cookie_attributes = Hash[Symbol | String, top]
+
       type jar = Jar | _Each[Jar::cookie]
 
       interface _CookieOptions

data/sig/plugins/h2c.rbs

@@ -11,6 +11,10 @@ module HTTPX
         def upgrade: (Request, Response) -> void
       end
 
+      module RequestMethods
+        def valid_h2c_verb?: () -> bool
+      end
+
       module ConnectionMethods
         def upgrade_to_h2c: (Request, Response) -> void
       end

data/sig/plugins/proxy/http.rbs

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

data/sig/plugins/proxy.rbs

@@ -49,6 +49,10 @@ module HTTPX
 
       def self.extra_options: (Options) -> (Options & _ProxyOptions)
 
+      module ConnectionMethods
+        @proxy_uri: generic_uri
+      end
+
       module InstanceMethods
         @__proxy_uris: Array[generic_uri]
 

data/sig/plugins/query.rbs

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Query
+      def self.subplugins: () -> Hash[Symbol, Module]
+
+      module InstanceMethods
+        def query: (uri | [uri], **untyped) -> response
+                 | (_Each[uri | [uri, request_params]], **untyped) -> Array[response]
+      end
+
+      module QueryRetries
+        module InstanceMethods
+        end
+      end
+    end
+    type sessionQuery = Session & Query::InstanceMethods
+  end
+end

data/sig/plugins/response_cache/file_store.rbs

@@ -0,0 +1,19 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      class FileStore
+        @dir: Pathname
+
+        include _ResponseCacheStore
+
+        def initialize: (?path dir) -> void
+
+        private
+
+        def file_path: (cacheRequest request) -> Pathname
+
+        def read_from_file: (cacheRequest request, File f) -> cacheResponse?
+      end
+    end
+  end
+end

data/sig/plugins/response_cache/store.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      class Store
+        @store: Hash[String, cacheResponse]
+
+        @store_mutex: Thread::Mutex
+
+        include _ResponseCacheStore
+      end
+    end
+  end
+end

data/sig/plugins/response_cache.rbs

@@ -3,47 +3,62 @@ module HTTPX
     module ResponseCache
       CACHEABLE_VERBS: Array[verb]
       CACHEABLE_STATUS_CODES: Array[Integer]
+      SUPPORTED_VARY_HEADERS: Array[String]
 
-      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
+      def self?.cacheable_response?: (::HTTPX::ErrorResponse | cacheResponse response) -> bool
 
-      class Store
-        @store: Hash[String, Array[Response]]
+      def self?.not_modified?: (response response) -> bool
 
-        @store_mutex: Thread::Mutex
+      interface _ResponseCacheOptions
+        def response_cache_store: () -> Store
 
-        def lookup: (Request request) -> Response?
-
-        def cached?: (Request request) -> boolish
-
-        def cache: (Request request, Response response) -> void
-
-        def prepare: (Request request) -> void
-
-        private
+        def supported_vary_headers: () -> Array[String]
+      end
 
-        def match_by_vary?: (Request request, Response response) -> bool
+      interface _ResponseCacheStore
+        def get: (cacheRequest request) -> cacheResponse?
 
-        def _get: (Request request) -> Array[Response]?
+        def set: (cacheRequest request, cacheResponse response) -> void
 
-        def _set: (Request request, Response response) -> void
+        def clear: () -> void
       end
 
       module InstanceMethods
         @response_cache: Store
 
         def clear_response_cache: () -> void
+
+        private
+
+        def prepare_cache: (cacheRequest request) -> void
+
+        def cacheable_request?: (cacheRequest request) -> bool
+
+        def match_by_vary?: (cacheRequest request, cacheResponse response) -> bool
       end
 
       module RequestMethods
+        attr_accessor cached_response: cacheResponse?
+
         @response_cache_key: String
 
         def response_cache_key: () -> String
+
+        def cacheable_verb?: () -> bool
       end
 
       module ResponseMethods
-        def copy_from_cached: (Response other) -> void
+        attr_writer original_request: cacheRequest
+
+        @cache: bool
+
+        def original_request: () -> cacheRequest?
+
+        def cached?: () -> bool
+
+        def mark_as_cached!: () -> void
+
+        def copy_from_cached!: () -> void
 
         def fresh?: () -> bool
 
@@ -57,6 +72,13 @@ module HTTPX
 
         def date: () -> Time
       end
+
+
+      type cacheOptions = Options & _ResponseCacheOptions
+
+      type cacheRequest = Request & RequestMethods
+
+      type cacheResponse = Response & ResponseMethods
     end
 
     type sessionResponseCache = Session & ResponseCache::InstanceMethods

data/sig/plugins/retries.rbs

@@ -3,6 +3,7 @@ module HTTPX
     module Retries
       MAX_RETRIES: Integer
       IDEMPOTENT_METHODS: Array[String]
+      RECONNECTABLE_ERRORS: Array[singleton(StandardError)]
       RETRYABLE_ERRORS: Array[singleton(StandardError)]
       DEFAULT_JITTER: ^(Numeric) -> Numeric
 
@@ -31,11 +32,11 @@ module HTTPX
 
         def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> (retriesResponse | ErrorResponse)?
 
-        def __repeatable_request?: (retriesRequest request, retriesOptions options) -> boolish
+        def repeatable_request?: (retriesRequest request, retriesOptions options) -> boolish
 
-        def __retryable_error?: (_Exception error) -> bool
+        def retryable_error?: (_Exception error) -> bool
 
-        def __try_partial_retry: (retriesRequest request, (retriesResponse | ErrorResponse) response) -> void
+        def try_partial_retry: (retriesRequest request, (retriesResponse | ErrorResponse) response) -> void
 
       end
 

data/sig/plugins/stream.rbs

@@ -16,6 +16,9 @@ module HTTPX
         def stream: () -> StreamResponse?
       end
 
+      module ResponseBodyMethods
+        @stream: StreamResponse?
+      end
     end
 
     type sessionStream = Session & Stream::InstanceMethods
@@ -26,8 +29,9 @@ module HTTPX
 
     type streamRequest = Request & Plugins::Stream::RequestMethods
 
-    @request: streamRequest
+    attr_reader request: streamRequest
     @options: Options
+
     @session: Plugins::sessionStream
     @response_enum: Enumerator[String]?
     @buffered_chunks: Array[String]

data/sig/plugins/stream_bidi.rbs

@@ -0,0 +1,68 @@
+module HTTPX
+  module Plugins
+    module StreamBidi
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options)
+
+      class HTTP2Bidi < Connection::HTTP2
+        @lock: Thread::Mutex
+
+        private
+
+        def handle_stream: (::HTTP2::Stream stream, Request & RequestMethods request) -> void
+
+        def end_stream?: (Request & RequestMethods request, String? next_chunk) -> void
+      end
+
+      class BidiBuffer < Buffer
+        @parent_thread: Thread
+        @oob_mutex: Thread::Mutex
+        @oob_buffer: String
+
+        def rebuffer: () -> void
+      end
+
+      class Signal
+        @closed: bool
+        @pipe_read: ::IO
+        @pipe_write: ::IO
+
+        include _Selectable
+
+        def wakeup: () -> void
+
+        def mergeable?: () -> bool
+
+        def terminate: () -> void
+      end
+
+      module InstanceMethods
+        @signal: Signal
+      end
+
+      module RequestMethods
+        attr_accessor headers_sent: bool
+
+        @closed: bool
+        @mutex: Thread::Mutex
+
+        def closed?: () -> bool
+      end
+
+      module RequestBodyMethods
+      end
+
+      module ConnectionMethods
+        @write_buffer: BidiBuffer
+
+        private
+
+        def parser_type: (String protocol) -> (singleton(Connection::HTTP1) | singleton(Connection::HTTP2) | singleton(HTTP2Bidi))
+      end
+
+    end
+
+    type sessionStreamBidi = Session & StreamBidi::InstanceMethods
+  end
+end

data/sig/plugins/upgrade/h2.rbs

@@ -0,0 +1,9 @@
+module HTTPX
+  module Plugins
+    module H2
+      module ConnectionMethods
+        def upgrade_to_h2: () -> void
+      end
+    end
+  end
+end

data/sig/plugins/upgrade.rbs

@@ -13,6 +13,9 @@ module HTTPX
 
       def self.extra_options: (Options) -> (Options & _UpgradeOptions)
 
+      module InstanceMethods
+      end
+
       module ConnectionMethods
         attr_reader upgrade_protocol: String?
         attr_reader hijacked: boolish
@@ -20,5 +23,7 @@ module HTTPX
         def hijack_io: () -> void
       end
     end
+
+    type sessionUpgrade = Session & Upgrade::InstanceMethods
   end
 end