httpx 1.4.3 → 1.5.0

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/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,12 @@ 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]
     @on_chunk: ^(String) -> void | nil
 
     def each: () { (String) -> void } -> void

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

data/sig/pool.rbs

@@ -9,6 +9,7 @@ module HTTPX
 
     type resolver_manager = Resolver::Multi | Resolver::System
 
+    @max_connections: Integer
     @max_connections_per_origin: Integer
     @pool_timeout: Numeric
     @options: Options
@@ -16,6 +17,8 @@ module HTTPX
     @resolver_mtx: Thread::Mutex
     @connections: Hash[String, Array[Connection]]
     @connection_mtx: Thread::Mutex
+    @connections_counter: Integer
+    @max_connections_cond: ConditionVariable
     @origin_counters: Hash[String, Integer]
     @origin_conds: Hash[String, ConditionVariable]
 
@@ -42,5 +45,7 @@ module HTTPX
     def checkout_new_connection: (http_uri uri, Options options) -> Connection
 
     def checkout_new_resolver: (Class resolver_type, Options options) -> resolver_manager
+
+    def drop_connection: (?Connection connection) -> Connection?
   end
 end

data/sig/punycode.rbs

@@ -0,0 +1,5 @@
+module HTTPX
+  module Punycode
+    def self?.encode_hostname: (String) -> String
+  end
+end

data/sig/request.rbs

@@ -20,6 +20,7 @@ module HTTPX
 
     attr_writer persistent: bool
 
+    @ping: bool
     @query_params: Hash[interned, untyped]?
     @trailers: Headers?
     @informational_status: Integer?
@@ -28,12 +29,18 @@ module HTTPX
 
     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)
 
+    def can_buffer? : () -> bool
+
     def merge_headers: (_Each[[String, headers_value]]) -> void
 
     def scheme: () -> String

data/sig/resolver/https.rbs

@@ -1,6 +1,8 @@
 module HTTPX
   module Resolver
     class HTTPS < Resolver
+      extend Forwardable
+
       NAMESERVER: String
 
       DEFAULTS: Hash[Symbol, untyped]
@@ -9,6 +11,7 @@ module HTTPX
       attr_reader family: ip_family
 
       @options: Options
+      @queries: Hash[String, Connection]
       @requests: Hash[Request, String]
       @connections: Array[Connection]
       @uri: http_uri
@@ -26,8 +29,6 @@ module HTTPX
 
       def resolver_connection: () -> Connection
 
-      def resolve: (?Connection connection, ?String? hostname) -> void
-
       def on_response: (Request, response) -> void
 
       def parse: (Request request, Response response) -> void

data/sig/resolver/native.rbs

@@ -16,6 +16,7 @@ module HTTPX
       @search: Array[String]
       @_timeouts: Array[Numeric]
       @timeouts: Hash[String, Array[Numeric]]
+      @queries: Hash[String, Connection]
       @connections: Array[Connection]
       @read_buffer: String
       @write_buffer: Buffer
@@ -54,8 +55,6 @@ module HTTPX
 
       def parse: (String) -> void
 
-      def resolve: (?Connection connection, ?String hostname) -> void
-
       def generate_candidates: (String) -> Array[String]
 
       def build_socket: () -> (UDP | TCP)

data/sig/resolver/resolver.rbs

@@ -4,7 +4,11 @@ module HTTPX
       include Callbacks
       include Loggable
 
-      RECORD_TYPES: Hash[Integer, singleton(Resolv::DNS::Resource)]
+      include _Selectable
+
+      RECORD_TYPES: Hash[ip_family, singleton(Resolv::DNS::Resource)]
+
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
 
       attr_reader family: ip_family
 
@@ -18,8 +22,8 @@ module HTTPX
 
       @record_type: singleton(Resolv::DNS::Resource)
       @resolver_options: Hash[Symbol, untyped]
-      @queries: Hash[String, Connection]
       @system_resolver: Resolv::Hosts
+      @connections: Array[Connection]
 
       def close: () -> void
 
@@ -33,11 +37,15 @@ module HTTPX
 
       def emit_addresses: (Connection connection, ip_family family, Array[IPAddr], ?bool early_resolve) -> void
 
+      def self.multi?: () -> bool
+
       private
 
+      def resolve: (?Connection connection, ?String hostname) -> void
+
       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
 

data/sig/resolver/system.rbs

@@ -2,16 +2,33 @@ module HTTPX
   module Resolver
     class System < Resolver
       RESOLV_ERRORS: Array[singleton(StandardError)] # ResolvError
+      DONE: 1
+      ERROR: 2
 
       @resolver: Resolv::DNS
+      @_timeouts: Array[Numeric]
+      @timeouts: Hash[String, Array[Numeric]]
+      @queries: Array[[ip_family, Connection]]
+      @ips: Array[[ip_family, Connection, (Array[Addrinfo] | StandardError)]]
+      @pipe_mutex: Thread::Mutex
+      @pipe_read: ::IO
+      @pipe_write: ::IO
 
-      attr_reader family: nil
+      attr_reader state: Symbol
 
       def <<: (Connection) -> void
 
       private
 
-      def initialize: (options options) -> void
+      def transition: (Symbol nextstate) -> void
+
+      def consume: () -> void
+
+      def async_resolve: (Connection connection, String hostname, String scheme) -> void
+
+      def __addrinfo_resolve: (String host, String scheme) -> Array[Addrinfo]
+
+      def initialize: (Options options) -> void
     end
   end
 end

data/sig/resolver.rbs

@@ -2,22 +2,26 @@ module HTTPX
   type ipaddr = IPAddr | String
 
   module Resolver
-    RESOLVE_TIMEOUT: Array[Integer]
-
-    @lookup_mutex: Thread::Mutex
-
     type dns_resource = singleton(Resolv::DNS::Resource)
 
     type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
                     | { "name" => String, "TTL" => Numeric, "data" => String }
 
+    RESOLVE_TIMEOUT: Array[Integer]
+
+    self.@lookup_mutex: Thread::Mutex
+    self.@lookups: Hash[String, Array[dns_result]]
+    self.@identifier_mutex: Thread::Mutex
+    self.@identifier: Integer
+    self.@system_resolver: Resolv::Hosts
+
     type dns_decoding_response = [:ok, Array[dns_result]] | [:decode_error, Resolv::DNS::DecodeError] | [:dns_error, Integer] | Symbol
 
-    def nolookup_resolve: (String hostname) -> Array[IPAddr]
+    def self?.nolookup_resolve: (String hostname) -> Array[IPAddr]?
 
-    def ip_resolve: (String hostname) -> Array[IPAddr]?
+    def self?.ip_resolve: (String hostname) -> Array[IPAddr]?
 
-    def system_resolve: (String hostname) -> Array[IPAddr]?
+    def self?.system_resolve: (String hostname) -> Array[IPAddr]?
 
     def self?.resolver_for: (:native resolver_type) -> singleton(Native) |
                             (:system resolver_type) -> singleton(System) |

data/sig/response/body.rbs

@@ -7,14 +7,15 @@ module HTTPX
     attr_reader encoding: Encoding
     attr_reader encodings: Array[String]
 
+    attr_reader buffer: Response::Buffer?
+
     @response: Response
     @headers: Headers
     @options: Options
     @state: :idle | :memory | :buffer | :closed
     @window_size: Integer
     @length: Integer
-    @buffer: StringIO | Tempfile | nil
-    @reader: StringIO | Tempfile | nil
+    @reader: Response::Buffer?
     @inflaters: Array[Transcoder::_Inflater]
 
     def initialize: (Response, Options) -> void
@@ -47,7 +48,5 @@ module HTTPX
     def decode_chunk: (String chunk) -> String
 
     def transition: (Symbol nextstate) -> void
-
-    def _with_same_buffer_pos: [A] () { () -> A } -> A
   end
 end

data/sig/response/buffer.rbs

@@ -1,9 +1,10 @@
 module HTTPX
   class Response::Buffer
+    attr_reader buffer: StringIO | Tempfile
+
     @threshold_size: Integer
     @bytesize: Integer
     @encoding: Encoding
-    @buffer: StringIO | Tempfile
 
     def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding) -> void
 
@@ -18,7 +19,5 @@ module HTTPX
     private
 
     def try_upgrade_buffer: () -> void
-
-    def _with_same_buffer_pos: () { () -> void } -> void
   end
 end

data/sig/response.rbs

@@ -4,6 +4,8 @@ module HTTPX
 
     def finished?: () -> bool
 
+    def finish!: () -> void
+
     def raise_for_status: () -> self
 
     def error: () -> StandardError?
@@ -41,8 +43,6 @@ module HTTPX
 
     def content_type: () -> ContentType
 
-    def finish!: () -> void
-
     def complete?: () -> bool
 
     def json: (?JSON::options opts) -> untyped

data/sig/selector.rbs

@@ -1,15 +1,27 @@
 module HTTPX
-  type selectable = Connection | Resolver::Native
+  interface _Selectable
+    def state: () -> Symbol
+
+    def to_io: () -> ::IO
+
+    def call: () -> void
+
+    def interests: () -> io_interests?
+
+    def timeout: () -> Numeric?
+
+    def handle_socket_timeout: (Numeric interval) -> void
+  end
 
   class Selector
-    include _Each[selectable]
+    include _Each[_Selectable]
 
     READABLE: Array[Symbol]
     WRITABLE: Array[Symbol]
 
     @timers: Timers
 
-    @selectables: Array[selectable]
+    @selectables: Array[_Selectable]
     @is_timer_interval: bool
 
     def next_tick: () -> void
@@ -27,23 +39,21 @@ module HTTPX
 
     def empty?: () -> bool
 
-    def register: (selectable io) -> void
+    def register: (_Selectable io) -> void
 
-    def deregister: (selectable io) -> selectable?
+    def deregister: (_Selectable io) -> _Selectable?
 
     private
 
     def initialize: () -> void
 
-    def select: (Numeric? interval) { (selectable) -> void } -> void
+    def select: (Numeric? interval) { (_Selectable) -> void } -> void
 
-    def select_many: (Numeric? interval) { (selectable) -> void } -> void
+    def select_many: (Numeric? interval) { (_Selectable) -> void } -> void
 
-    def select_one: (Numeric? interval) { (selectable) -> void } -> void
+    def select_one: (Numeric? interval) { (_Selectable) -> void } -> void
 
     def next_timeout: () -> Numeric?
-
-    def emit_error: (StandardError e) -> void
   end
 
   type io_interests = :r | :w | :rw