httpx 0.21.0 → 1.2.1

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 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 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

data/sig/resolver.rbs

@@ -2,9 +2,7 @@ module HTTPX
   type ipaddr = IPAddr | String
 
   module Resolver
-    extend Registry[Symbol, Class]
-
-    RESOLVE_TIMEOUT: Integer | Float
+    RESOLVE_TIMEOUT: Array[Integer]
 
     @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/body.rbs

@@ -0,0 +1,53 @@
+module HTTPX
+  class Response::Body
+    include _Reader
+    include _ToS
+    include _ToStr
+
+    attr_reader encoding: Encoding | String
+    attr_reader encodings: Array[Encoding | String]
+
+    @response: Response
+    @headers: Headers
+    @options: Options
+    @state: :idle | :memory | :buffer | :closed
+    @window_size: Integer
+    @length: Integer
+    @buffer: StringIO | Tempfile | nil
+    @reader: StringIO | Tempfile | nil
+    @inflaters: Array[Transcoder::_Inflater]
+
+    def initialize: (Response, Options) -> void
+
+    def closed?: () -> bool
+
+    def write:(String chunk) -> Integer?
+
+    def filename: () -> String?
+
+    def bytesize: () -> Integer
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def empty?: () -> bool
+
+    def copy_to: (String | File | _Writer destination) -> void
+
+    def close: () -> void
+
+    def rewind: () -> void
+
+    private
+
+    def initialize_inflaters: () -> void
+
+    def self.initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> Transcoder::GZIP::Inflater
+
+    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

@@ -0,0 +1,24 @@
+module HTTPX
+  class Response::Buffer
+    @threshold_size: Integer
+    @bytesize: Integer
+    @encoding: Encoding
+    @buffer: StringIO | Tempfile
+
+    def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding | String) -> void
+
+    def size: () -> Integer
+
+    def write: (String) -> void
+
+    def to_s: () -> String
+
+    def close: () -> void
+
+    private
+
+    def try_upgrade_buffer: () -> void
+
+    def _with_same_buffer_pos: () { () -> void } -> void
+  end
+end

data/sig/response.rbs

@@ -9,6 +9,7 @@ module HTTPX
 
   class Response
     extend Forwardable
+    include Callbacks
 
     include _Response
     include _ToS
@@ -24,58 +25,30 @@ module HTTPX
     @content_type: ContentType
 
     def copy_to: (_ToPath | _Writer destination) -> void
+
     def close: () -> void
+
     def uri: () -> URI::Generic
 
+    def peer_address: () -> ipaddr?
+
     def merge_headers: (_Each[[String, headers_value]]) -> void
+
     def bodyless?: () -> bool
+
     def content_type: () -> ContentType
+
     def complete?: () -> bool
 
     def json: (?json_options opts) -> untyped
 
     def form: () -> Hash[String, untyped]
 
-    private
-
-    def initialize: (Request request, String | Integer status, String version, headers?) -> untyped
-    def no_data?: () -> bool
-
-    def decode:(String format, ?untyped options) -> untyped
-
-    class Body
-      include _Reader
-      include _ToS
-      include _ToStr
+    def initialize: (Request request, String | Integer status, String version, headers?) -> void
 
-      @response: Response
-      @headers: Headers
-      @options: Options
-      @state: :idle | :memory | :buffer | :closed
-      @threshold_size: Integer
-      @window_size: Integer
-      @encoding: String
-      @length: Integer
-      @buffer: StringIO | Tempfile | nil
-
-      def write:(String chunk) -> Integer?
-
-      def each: () { (String) -> void } -> void
-              | () -> Enumerable[String]
-
-      def bytesize: () -> (Integer | Float)
-      def empty?: () -> bool
-      def copy_to: (String | File | _Writer destination) -> void
-      def close: () -> void
-      def closed?: () -> bool
-
-      private
+    private
 
-      def initialize: (Response, Options) -> untyped
-      def rewind: () -> void
-      def transition: () -> void
-      def _with_same_buffer_pos: [A] () { () -> A } -> A
-    end
+    def decode:(Transcoder::_Decode transcoder, ?untyped options) -> untyped
   end
 
   class ContentType
@@ -105,10 +78,16 @@ module HTTPX
 
     attr_reader request: Request
 
+    attr_reader response: Response?
+
     def status: () -> (Integer | _ToS)
 
     def uri: () -> URI::Generic
 
+    def peer_address: () -> ipaddr?
+
+    def close: () -> void
+
     private
 
     def initialize: (Request, Exception, options) -> untyped

data/sig/session.rbs

@@ -11,42 +11,48 @@ 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
+    def initialize: (?options) { (self) -> void } -> void
+                  | (?options) -> void
 
-    def initialize: (?options) { (self) -> void } -> untyped
-                  | (?options) -> untyped
+    private
 
     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 request, Array[Connection] connections, Options options) -> Connection
 
-    def find_connection: (Request, Array[Connection] connections, Options options) -> Connection
+    def send_request: (Request request, Array[Connection] connections, ?Options options) -> void
 
-    def set_connection_callbacks: (Connection, Array[Connection], Options) -> void
+    def set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options) -> void
 
-    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 set_request_callbacks: (Request request) -> void
 
-    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_altsvc_connection: (Connection existing_connection, Array[Connection] connections, URI::Generic alt_origin, String origin, Hash[String, String] alt_params, Options options) -> (Connection & AltSvc::ConnectionMixin)?
 
-    def build_connection: (URI::Generic, Options) -> Connection
+    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 init_connection: (URI::HTTP | URI::HTTP uri, Options options) -> Connection
 
     def send_requests: (*Request) -> Array[response]
 
-    def _send_requests: (Array[Request]) -> Array[Connection]
+    def _send_requests: (Array[Request] requests) -> Array[Connection]
+
+    def receive_requests: (Array[Request] requests, Array[Connection] connections) -> Array[response]
 
-    def receive_requests: (Array[Request], Array[Connection]) -> Array[response]
+    attr_reader self.default_options: Options
   end
+
+  OriginalSession: singleton(Session)
 end

data/sig/timers.rbs

@@ -3,30 +3,40 @@ module HTTPX
     @intervals: Array[Interval]
     @next_interval_at: Float
 
-    def after: (Numeric interval_in_secs) { () -> void } -> void
+    def after: (Numeric interval_in_secs, ^() -> void) -> Interval
+             | (Numeric interval_in_secs) { () -> void } -> Interval
 
     def wait_interval: () -> Numeric?
 
     def fire: (?TimeoutError error) -> void
 
-    def cancel: () -> void
-
-    private
-
     def initialize: () -> void
 
     class Interval
       include Comparable
 
+      type callback = ^() -> void
+
       attr_reader interval: Numeric
 
-      @callbacks: Array[^() -> void]
+      @callbacks: Array[callback]
+      @on_empty: callback?
+
+
+      def on_empty: () { () -> void } -> void
 
       def to_f: () -> Float
 
-      def <<: (^() -> void) -> void
+      def <<: (callback) -> void
+
+      def delete: (callback) -> void
 
       def elapse: (Numeric elapsed) -> Numeric
+
+      def elapsed?: () -> bool
+
+      def no_callbacks?: () -> bool
+
       private
 
       def initialize: (Numeric interval) -> void

data/sig/transcoder/body.rbs

@@ -7,13 +7,14 @@ module HTTPX
       class Encoder
         extend Forwardable
 
-        include _Encoder
-        include _ToS
-
         @raw: bodyIO
 
+        def bytesize: () -> (Integer | Float)
+
         def content_type: () -> String
 
+        def to_s: () -> String
+
         private
 
         def initialize: (untyped body) -> untyped

data/sig/transcoder/deflate.rbs

@@ -0,0 +1,11 @@
+module HTTPX
+  module Transcoder
+    module Deflate
+      def self?.encode: (_Encoder body) -> Deflater
+      def self?.decode: (Response body, ?bytesize: Integer) -> GZIP::Inflater
+
+      class Deflater < Transcoder::Deflater
+      end
+    end
+  end
+end

data/sig/transcoder/form.rbs

@@ -3,17 +3,19 @@ module HTTPX::Transcoder
 
   type form_nested_value = form_value | _ToAry[form_value] | _ToHash[string, form_value]
 
-  type urlencoded_input = Enumerable[[_ToS, form_nested_value]]
+  type urlencoded_input = Enumerable[[_ToS, form_nested_value | Multipart::multipart_nested_value]]
 
   module Form
-    def self?.encode: (urlencoded_input form) -> Encoder
+    def self?.encode: (urlencoded_input form) -> (Encoder | Multipart::Encoder)
     def self?.decode: (HTTPX::Response response) -> _Decoder
+    def self?.multipart?: (form_nested_value | Multipart::multipart_nested_value data) -> bool
 
     class Encoder
       extend Forwardable
-      include _Encoder
       include _ToS
 
+      def bytesize: () -> Integer
+
       def content_type: () -> String
 
       private

data/sig/transcoder/gzip.rbs

@@ -0,0 +1,24 @@
+module HTTPX
+  module Transcoder
+    module GZIP
+      def self?.encode: (_Encoder body) -> Deflater
+      def self?.decode: (Response response, ?bytesize: Integer) -> Inflater
+
+      class Deflater < Transcoder::Deflater
+        @compressed_chunk: String
+
+        private
+
+        def write: (String chunk) -> void
+
+        def compressed_chunk: () -> String
+      end
+
+      class Inflater
+        def initialize: (Integer | Float bytesize) -> void
+
+        def call: (String chunk) -> String
+      end
+    end
+  end
+end

data/sig/transcoder/json.rbs

@@ -10,14 +10,16 @@ module HTTPX::Transcoder
 
     class Encoder
       extend Forwardable
-      include _Encoder
-      include _ToS
 
       @raw: String
       @charset: String
 
+      def bytesize: () -> Integer
+
       def content_type: () -> String
 
+      def to_s: () -> String
+
       private
 
       def initialize: (_ToJson json) -> void

data/sig/{plugins → transcoder}/multipart.rbs

@@ -1,5 +1,5 @@
 module HTTPX
-  module Plugins
+  module Transcoder
     module Multipart
       interface _MultipartInput
         def filename: () -> String
@@ -9,13 +9,6 @@ module HTTPX
 
       MULTIPART_VALUE_COND: ^(_Reader | record_multipart_value value) -> bool
 
-      def self.load_dependencies: (singleton(Session)) -> void
-      def self.configure: (*untyped) -> void
-      def self?.encode: (untyped) -> (Encoder | Transcoder::Form::Encoder)
-      def self?.decode: (HTTPX::Response response) -> Transcoder::_Decoder
-
-      def self?.normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value) { (String, ?untyped) -> U } -> U
-
       type multipart_value = string | Pathname | File | _Reader
 
       type record_multipart_value = { content_type: String, filename: String, body: multipart_value } |
@@ -24,8 +17,6 @@ module HTTPX
       type multipart_nested_value = multipart_value | _ToAry[multipart_value] | _ToHash[string, multipart_value]
 
       class Encoder
-        include Transcoder::_Encoder
-
         @boundary: String
         @part_index: Integer
         @buffer: String
@@ -33,6 +24,8 @@ module HTTPX
         @form: Enumerable[[Symbol | string, multipart_nested_value]]
         @parts: Array[_Reader]
 
+        def bytesize: () -> Integer
+
         def content_type: () -> String
 
         def read: (?int? length, ?string? buffer) -> String?
@@ -68,8 +61,6 @@ module HTTPX
         def initialize: (Response response) -> void
 
         def parse: () -> void
-
-        def get_filename: (String head) -> String?
       end
 
       class FilePart #  < SimpleDelegator

data/sig/transcoder/utils/body_reader.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  module Transcoder
+    class BodyReader
+      @body: _Reader | _Each[String]
+
+      def initialize: (bodyIO body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string outbuf) -> String?
+
+      def close: () -> void
+    end
+  end
+end

data/sig/transcoder/utils/deflater.rbs

@@ -0,0 +1,29 @@
+module HTTPX
+  module Transcoder
+    class Deflater
+      extend Forwardable
+
+      @body: BodyReader
+      @buffer: Response::Buffer?
+      @body: _Encoder | StringIO
+      @closed: bool
+
+      attr_reader content_type: String
+
+      def initialize: (_Encoder body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string outbuf) -> String?
+
+      def close: () -> void
+
+      def deflate: (String? chunk) -> String?
+
+      private
+
+      def buffer_deflate!: () -> void
+
+    end
+  end
+end

data/sig/transcoder/utils/inflater.rbs

@@ -0,0 +1,12 @@
+module HTTPX
+  module Transcoder
+    class Inflater
+      @inflater: Zlib::Inflate
+      @bytesize: Integer
+
+      def initialize: (Integer | Float bytesize) -> void
+
+      def call: (String chunk) -> String
+    end
+  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

@@ -1,14 +1,9 @@
 module HTTPX
-  type bodyIO = _Reader | _Each[[String, untyped]] | _ToS
+  type bodyIO = _Reader | _Each[String] | _ToS
 
-  type body_encoder = Transcoder::_Encoder | _Each[String]
+  type body_encoder = (Transcoder::_Encoder & _ToS) | (Transcoder::_Encoder & _Reader) | (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,12 +12,32 @@ module HTTPX
       def encode: (untyped payload) -> body_encoder
     end
 
+    interface _Decode
+      def decode: (HTTPX::Response response) -> _Decoder
+    end
+
     interface _Encoder
       def bytesize: () -> (Integer | Float)
+
+      def content_type: () -> String
     end
 
     interface _Decoder
       def call: (Response response, *untyped) -> untyped
     end
+
+    interface _Inflater
+      def initialize: (Integer | Float bytesize) -> void
+
+      def call: (String chunk) -> String
+    end
+
+    interface _Deflater
+      def initialize: (Response body) -> void
+
+      def deflate: () -> void
+
+      def call: (StringIO | File buffer, ?chunk_size: Integer) ?{ (String chunk) -> void } -> void
+    end
   end
 end

data/sig/utils.rbs

@@ -9,5 +9,7 @@ module HTTPX
     def self?.elapsed_time: (Integer | Float monotonic_time) -> Float
 
     def self?.to_uri: (generic_uri uri) -> URI::Generic
+
+    def self?.get_filename: (String header) -> String?
   end
 end