httpx 0.20.0 → 1.3.1

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

@@ -1,5 +1,7 @@
 module HTTPX
   interface _Response
+    def finished?: () -> bool
+
     def raise_for_status: () -> self
 
     def error: () -> StandardError?
@@ -7,6 +9,7 @@ module HTTPX
 
   class Response
     extend Forwardable
+    include Callbacks
 
     include _Response
     include _ToS
@@ -22,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
-
-      @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 initialize: (Request request, String | Integer status, String version, headers?) -> void
 
-      def write:(String chunk) -> Integer?
-
-      def each: () { (String) -> void } -> void
-              | () -> Enumerable[String]
-
-      def bytesize: () -> Numeric
-      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
@@ -95,18 +70,28 @@ module HTTPX
 
   class ErrorResponse
     include _Response
+    include _Reader
     include Loggable
+    extend Forwardable
 
     @options: Options
     @error: Exception
 
     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
+    def initialize: (Request, Exception) -> untyped
   end
 
   type response = Response | ErrorResponse

data/sig/selector.rbs

@@ -7,7 +7,7 @@ module HTTPX
     @selectables: Array[selectable]
 
     def register: (selectable io) -> void
-    def deregister: (selectable io) -> void
+    def deregister: (selectable io) -> selectable?
 
     def select: (Numeric? interval) { (selectable) -> void } -> void
 

data/sig/session.rbs

@@ -11,42 +11,53 @@ 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 verb, generic_uri uri, ?request_params params, ?Options 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 find_connection: (Request, Array[Connection] connections, Options options) -> Connection
+    def fetch_response: (Request request, Array[Connection] connections, untyped options) -> response?
+
+    def find_connection: (Request request, Array[Connection] connections, Options options) -> Connection
 
-    def set_connection_callbacks: (Connection, Array[Connection], Options) -> void
+    def deactivate_connection: (Request request, 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 send_request: (Request request, Array[Connection] connections, ?Options options) -> 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 set_connection_callbacks: (Connection connection, Array[Connection] connections, Options options, ?cloned: bool) -> void
 
-    def build_connection: (URI::Generic, Options) -> Connection
+    def set_request_callbacks: (Request request) -> 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 & AltSvc::ConnectionMixin)?
+
+    def build_requests: (verb, uri, request_params) -> Array[Request]
+                      | (Array[[verb, uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
+                      | (Array[[verb, uri]], request_params) -> Array[Request]
+                      | (verb, _Each[[uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
+                      | (verb, _Each[uri], request_params) -> Array[Request]
+
+    def init_connection: (http_uri 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], Array[Connection]) -> Array[response]
+    def receive_requests: (Array[Request] requests, Array[Connection] connections) -> Array[response]
+
+    attr_reader self.default_options: Options
   end
+
+  OriginalSession: singleton(Session)
 end

data/sig/timers.rbs

@@ -1,32 +1,42 @@
 module HTTPX
   class Timers
     @intervals: Array[Interval]
-    @next_interval_at: Numeric
+    @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

@@ -5,19 +5,24 @@ module HTTPX::Transcoder
     def self?.encode: (_ToJson json) -> Encoder
     def self?.decode: (HTTPX::Response response) -> _Decoder
 
+    def self?.json_load: (string source, ?json_options) -> untyped
+    def self?.json_dump: (_ToJson obj, *untyped) -> String
+
     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) -> untyped
+      def initialize: (_ToJson json) -> void
     end
   end
 end

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,14 +17,14 @@ 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
 
-        @form: Enumerable[[Symbol | string, multipart_nested_value]]
-        @parts: Array[_Reader]
+        @form: Enumerable[[Symbol | string, Object & multipart_nested_value]]
+        @parts: Array[Object & _Reader]
+
+        def bytesize: () -> Integer
 
         def content_type: () -> String
 
@@ -47,13 +40,18 @@ module HTTPX
 
         def header_part: (string key, String content_type, String? filename) -> StringIO
 
-        def read_chunks: (String buffer, ?Integer? length) -> void
+        def read_chunks: (String buffer, ?int? length) -> void
 
-        def read_from_part: (?Integer? max_length) -> String?
+        def read_from_part: (?int? max_length) -> String?
       end
 
       class Decoder
+        CRLF: String
         BOUNDARY_RE: Regexp
+        MULTIPART_CONTENT_TYPE: Regexp
+        MULTIPART_CONTENT_DISPOSITION: Regexp
+        MULTIPART_CONTENT_ID: Regexp
+        WINDOW_SIZE: Integer
 
         @state: :idle | :part_header | :part_body | :parse_boundary | :done
         @buffer: String
@@ -61,15 +59,13 @@ module HTTPX
         @boundary: String
         @intermediate_boundary: String
 
-        def call: (Response response, untyped) -> Hash[String, untyped]
+        def call: (Response response, *untyped) -> Hash[String, untyped]
 
         private
 
         def initialize: (Response response) -> void
 
         def parse: () -> void
-
-        def get_filename: (String head) -> String?
       end
 
       class FilePart #  < SimpleDelegator
@@ -84,8 +80,8 @@ module HTTPX
       end
 
       module Part
-        def self?.call: [U] (_MultipartInput multipart_input) -> [U, String, String]
-                      | (multipart_nested_value input) -> ([StringIO, String, String?] | [File, String, String])
+        def self?.call: [U] (Object & _MultipartInput multipart_input) -> [U, String, String]
+                      | (Object & multipart_nested_value input) -> ([StringIO, String, String?] | [File, String, String])
       end
 
       module MimeTypeDetector

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

@@ -0,0 +1,22 @@
+module HTTPX::Transcoder
+  module Xml
+    MIME_TYPES: Regexp
+
+    def self?.encode: (untyped xml) -> Encoder
+    def self?.decode: (HTTPX::Response response) -> _Decoder
+
+    class Encoder
+      @raw: untyped # can be nokogiri object
+
+      def content_type: () -> String
+
+      def bytesize: () -> (Integer | Float)
+
+      def to_s: () -> String
+
+      private
+
+      def initialize: (String xml) -> void
+    end
+  end
+end