httpx 0.15.4 → 0.18.0

data/sig/connection/http2.rbs

@@ -3,10 +3,13 @@ module HTTPX
     include Callbacks
     include Loggable
 
+    MAX_CONCURRENT_REQUESTS: Integer
+
     attr_reader streams: Hash[Request, HTTP2Next::Stream]
     attr_reader pending: Array[Request]
 
     @options: Options
+    @settings: Hash[Symbol, Integer | bool]
     @max_concurrent_requests: Integer
     @max_requests: Integer
     @drains: Hash[Request, String]
@@ -23,7 +26,7 @@ module HTTPX
 
     def <<: (String) -> void
 
-    def can_buffer_more_requests: () -> bool
+    def can_buffer_more_requests?: () -> bool
 
     def send: (Request) -> void
 
@@ -35,7 +38,7 @@ module HTTPX
 
     alias reset init_connection
 
-    def timeout: () -> Integer
+    def timeout: () -> Numeric
 
     private
 
@@ -45,7 +48,7 @@ module HTTPX
 
     def headline_uri: (Request) -> String
 
-    def set_protocol_headers: (Request) -> _Each[headers_key, String]
+    def set_protocol_headers: (Request) -> _Each[[String, String]]
 
     def handle: (Request request, HTTP2Next::Stream stream) -> void
 
@@ -61,9 +64,11 @@ module HTTPX
 
     def on_stream_headers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
 
-    def on_stream_trailers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
+    def on_stream_trailers: (HTTP2Next::Stream stream, Response response, Array[[String, String]] headers) -> void
+
+    def on_stream_data: (HTTP2Next::Stream stream, Request request, String data) -> void
 
-    def on_stream_data: (HTTP2Next::Stream stream, Request request, string data) -> void
+    def on_stream_refuse: (HTTP2Next::Stream stream, Request request, StandardError error) -> void
 
     def on_stream_close: (HTTP2Next::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
@@ -74,12 +79,18 @@ module HTTPX
     def on_close: (Integer last_frame, Symbol? error, String? payload) -> void
 
     def on_frame_sent: (HTTP2Next::frame) -> void
+
     def on_frame_received: (HTTP2Next::frame) -> void
 
+    def on_altsvc: (String origin, HTTP2Next::frame) -> void
+
     def on_promise: (HTTP2Next::Stream) -> void
 
     def on_origin: (String) -> void
 
     def on_pong: (string ping) -> void
+
+    class Error < ::HTTPX::Error
+    end
   end
 end

data/sig/connection.rbs

@@ -4,45 +4,62 @@ module HTTPX
 
       def on: (Symbol) { (*untyped) -> void } -> void
       def empty?: () -> bool
+      # def exhausted?: () -> bool
       def close: () -> void
       def consume: () -> void
       def <<: (string) -> void
+      # def send: (Request) -> void
+      # def ping: () -> void
+      # def timeout: () -> (Integer | Float)
+
     end
 
+    extend Forwardable
     include Loggable
     include Callbacks
-    extend HTTPX::Registry[String, Class]
+    include HTTPX::Registry[String, Class]
+
+    BUFFER_SIZE: Integer
 
-    attr_reader origin: generic_uri 
+    attr_reader origin: URI::Generic
     attr_reader state: Symbol
     attr_reader pending: Array[Request]
-    attr_reader options: options
+    attr_reader options: Options
+    attr_writer timers: Timers
+
+    @origins: Array[URI::Generic]
+    @window_size: Integer
+    @read_buffer: Buffer
+    @write_buffer: Buffer
+    @inflight: Integer
+    @keep_alive_timeout: Numeric?
+    @total_timeout: Numeric?
 
     def addresses: () -> Array[ipaddr]?
 
     def addresses=: (Array[ipaddr]) -> void
 
-    def match?: (generic_uri, options) -> bool
+    def match?: (URI::Generic, options) -> bool
 
     def mergeable?: (Connection) -> bool
 
     def coalescable?: (Connection) -> bool
 
-    def create_idle: (options) -> Connection
-                   | () -> Connection
+    def create_idle: (?Hash[Symbol, untyped] options) -> Connection
 
     def merge: (Connection) -> void
 
     def purge_pending: () { (Request) -> void } -> void
 
-    def match_altsvcs?: (generic_uri) -> bool
+    def match_altsvcs?: (URI::Generic uri) -> bool
 
     def connecting?: () -> bool
+
     def inflight?: () -> boolish
 
     def interests: () -> io_interests?
 
-    def to_io: () -> _ToIO
+    def to_io: () -> IO
 
     def call: () -> void
 
@@ -53,9 +70,10 @@ module HTTPX
 
     def timeout: () -> Numeric?
 
+    def deactivate: () -> void
     private
 
-    def initialize: (String, generic_uri, options) -> untyped
+    def initialize: (String, URI::Generic, options) -> untyped
 
     def connect: () -> void
 
@@ -67,6 +85,8 @@ module HTTPX
 
     def parser: () -> _Parser
 
+    def send_request_to_parser: (Request request) -> void
+
     def build_parser: () -> _Parser
                     | (String) -> _Parser
 
@@ -74,12 +94,10 @@ module HTTPX
 
     def transition: (Symbol) -> void
 
-    def handle_response: () -> void
-
-    def on_error: (StandardError) -> void
+    def on_error: (HTTPX::TimeoutError | Error | StandardError) -> void
 
     def handle_error: (StandardError) -> void
 
-    def total_timeout: () -> Timers::Timer?
+    def purge_after_closed: () -> void
   end
 end

data/sig/errors.rbs

@@ -1,3 +1,37 @@
 module HTTPX
-  Error: singleton(StandardError)
+  class Error < StandardError
+  end
+
+  class TimeoutError < Error
+    attr_reader timeout: Numeric
+
+    def to_connection_error: () -> ConnectTimeoutError
+    private
+
+    def initialize: (Numeric timeout, String message) -> untyped
+  end
+
+  class TotalTimeoutError < TimeoutError
+  end
+
+  class ConnectTimeoutError < TimeoutError
+  end
+
+  class SettingsTimeoutError < TimeoutError
+  end
+
+  class ResolveTimeoutError < TimeoutError
+  end
+
+  class ResolveError < Error
+  end
+
+  class NativeResolveError < ResolveError
+    attr_reader connection: Connection
+    attr_reader host: String
+
+    private
+
+    def initialize: (Connection connection, String hostname, ?String message) -> untyped
+  end
 end

data/sig/headers.rbs

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

data/sig/httpx.rbs

@@ -4,12 +4,15 @@ module HTTPX
   VERSION: String
 
   type uri = URI::HTTP | URI::HTTPS | string
-  type generic_uri = uri | URI::Generic
+  type generic_uri = String | URI::Generic
 
   type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
               :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
               :acl | :report | :patch | :search
 
   module Plugins
+    def self?.load_plugin: (Symbol) -> Module
+
+    def self?.register_plugin: (Symbol, Module) -> void
   end
 end

data/sig/loggable.rbs

@@ -4,8 +4,10 @@ module HTTPX
   end
 
   module Loggable
+    COLORS: Hash[Symbol, Integer]
+
     def log: (?level: Integer?, ?color: Symbol?) { () -> String } -> void
 
-    def log_exception: (StandardError, **untyped) -> void
+    def log_exception: (Exception error, ?level: Integer, ?color: Symbol) -> void
   end
 end

data/sig/options.rbs

@@ -4,109 +4,120 @@ module HTTPX
 
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
+    CONNECT_TIMEOUT: Integer
+    OPERATION_TIMEOUT: Integer
+    KEEP_ALIVE_TIMEOUT: Integer
+    SETTINGS_TIMEOUT: Integer
+    DEFAULT_OPTIONS: Hash[Symbol, untyped]
 
     type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout
-    type timeout = Hash[timeout_type, Numeric?]
+    type timeout = Hash[timeout_type, Numeric]
 
-    def self.new: (options) -> instance
-                | () -> instance
+    def self.new: (?options) -> instance
 
+    def self.def_option: (Symbol, ?String) -> void
+                       | (Symbol) { (*nil) -> untyped } -> void
     # headers
     attr_reader uri: URI?
-    def uri=: (uri) -> void
 
     # headers
     attr_reader headers: Headers?
-    def headers=: (headers) -> void
 
     # timeout
     attr_reader timeout: timeout
-    def timeout=: (timeout) -> void
+
+    # http2_settings
+    attr_reader http2_settings: Hash[Symbol, Integer | bool]
 
     # max_concurrent_requests
     attr_reader max_concurrent_requests: Integer?
-    def max_concurrent_requests=: (Integer) -> void
 
     # max_requests
     attr_reader max_requests: Integer?
-    def max_requests=: (Integer) -> void
 
     # window_size
-    attr_reader window_size: int?
-    def window_size=: (int) -> void
+    attr_reader window_size: Integer
 
     # body_threshold_size
-    attr_reader body_threshold_size: int?
-    def body_threshold_size=: (int) -> void
+    attr_reader body_threshold_size: Integer
 
     # transport
-    attr_reader transport: _ToS?
-    def transport=: (_ToS) -> void
+    attr_reader transport: String?
 
     # transport_options
     attr_reader transport_options: Hash[untyped, untyped]?
-    def transport_options=: (Hash[untyped, untyped]) -> void
 
     # addresses
-    attr_reader addresses: _ToAry[untyped]?
-    def addresses=: (_ToAry[untyped]) -> void
+    attr_reader addresses: Array[ipaddr]?
 
     # params
     attr_reader params: Transcoder::urlencoded_input?
-    def params=: (Transcoder::urlencoded_input) -> void
 
     # form
     attr_reader form: Transcoder::urlencoded_input?
-    def form=: (Transcoder::urlencoded_input) -> void
 
     # json
     attr_reader json: _ToJson?
-    def json=: (_ToJson) -> void
 
     # body
     attr_reader body: bodyIO?
-    def body=: (bodyIO) -> void
+
+    # body
+    attr_reader origin: URI::Generic?
 
     # ssl
 
     # http2_settings
 
+
+    # classes
+    attr_reader connection_class: singleton(Connection)
+
+    attr_reader request_class: singleton(Request)
+
+    attr_reader response_class: singleton(Response)
+
+    attr_reader headers_class: singleton(Headers)
+
+    attr_reader request_body_class: singleton(Request::Body)
+
+    attr_reader response_body_class: singleton(Response::Body)
+
+    attr_reader ssl: Hash[Symbol, untyped]
+
     # request_class response_class headers_class request_body_class
     # response_body_class connection_class
     # resolver_class resolver_options
 
-    # request_class
-    attr_reader request_class: singleton(Request)
-    def request_class=: (singleton(Request)) -> void
-
     # io
     type io_option = _ToIO | Hash[String, _ToIO]
     attr_reader io: io_option?
-    def io=: (io_option) -> void
 
     # fallback_protocol
     attr_reader fallback_protocol: String?
-    def fallback_protocol=: (String) -> void
 
     # debug
     attr_reader debug: _IOLogger?
-    def debug=: (_IOLogger) -> void
 
     # debug_level
-    attr_reader debug_level: Integer?
-    def debug_level=: (Integer) -> void
+    attr_reader debug_level: Integer
 
     # persistent
     attr_reader persistent: bool?
-    def persistent=: (bool) -> void
+
+    # resolver_options
+    attr_reader resolver_options: Hash[Symbol, untyped]?
 
     def ==: (untyped other) -> bool
-    def merge: (_ToHash other) -> instance
+    def merge: (_ToHash[Symbol, untyped] other) -> instance
+    def to_hash: () -> Hash[Symbol, untyped]
 
     private
 
-    def initialize: (options) -> untyped
+    REQUEST_IVARS: Array[Symbol]
+
+    def initialize: (?options options) -> untyped
   end
 
-  type options = Options | Hash[Symbol | String, untyped]
+  type options = Options | Hash[Symbol, untyped]
 end

data/sig/parser/http1.rbs

@@ -5,9 +5,9 @@ module HTTPX
     interface _HTTP1Events
 
       def on_start: () -> void
-      def on_headers: (parsed_headers) -> void
-      def on_trailers: (parsed_headers) -> void
-      def on_data: (String) -> void
+      def on_headers: (parsed_headers headers) -> void
+      def on_trailers: (parsed_headers trailers) -> void
+      def on_data: (String data) -> void
       def on_complete: () -> void
     end
 

data/sig/plugins/authentication.rbs

@@ -6,6 +6,6 @@ module HTTPX
       end
     end
 
-    type sessionAuthentication = Session & Plugins::Authentication::InstanceMethods
+    type sessionAuthentication = Session & Authentication::InstanceMethods
   end
 end

data/sig/plugins/aws_sdk_authentication.rbs

@@ -1,21 +1,43 @@
 module HTTPX
   module Plugins
     module AwsSdkAuthentication
+      class Configuration
+        attr_reader profile: String?
+
+        private
+
+        def initialize: (String? profile) -> void
+      end
+
       class Credentials
+        @aws_credentials: untyped
+
         include _SigV4Credentials
+
+        private
+
+        def initialize: (untyped aws_credentials) -> untyped
+      end
+
+      interface _AwsSdkOptions
+        def aws_profile: () -> String?
       end
 
       def self.load_dependencies: (singleton(Session)) -> void
 
       def self.configure: (singleton(Session)) -> void
 
-      def self.extra_options: (Options) -> (Options)
+      def self.extra_options: (Options) -> (Options & _AwsSdkOptions)
+
+      def self.credentials: (String? profile) -> Credentials
+
+      def self.region: (String? profile) -> String
 
       module InstanceMethods
-        def aws_sdk_authentication: (**untyped) -> instance
+        def aws_sdk_authentication: (?credentials: Credentials, ?region: String, **untyped) -> instance
       end
     end
 
-    type sessionAwsSdkAuthentication = Session & Plugins::AwsSdkAuthentication::InstanceMethods
+    type sessionAwsSdkAuthentication = awsSigV4Session & AwsSdkAuthentication::InstanceMethods
   end
 end

data/sig/plugins/aws_sigv4.rbs

@@ -9,13 +9,21 @@ module HTTPX
 
     module AWSSigV4
 
-      Credentials: _SigV4Credentials
+      class Credentials < Struct[[String, String, String?]]
+        attr_reader username: String
+        attr_reader password: String
+        attr_reader security_token: String?
+      end
 
 
       class Signer
 
-        def sign!: (Request) -> void
+        @unsigned_headers: Set[String]
+
+        def sign!: (Request & RequestMethods request) -> void
 
+        def self.new: (instance) -> instance
+                    | (**untyped params) -> instance
         private
 
         def initialize: (
@@ -33,16 +41,16 @@ module HTTPX
         ) -> untyped
 
 
-        def sha256_hexdigest: (bodyIO value) -> String
+        def hexdigest: (bodyIO value) -> String
 
         def hmac: (String key, String value) -> String
+
         def hexhmac: (String key, String value) -> String
       end
 
 
       interface _SigV4Options
         def sigv4_signer: () -> Signer?
-        def sigv4_signer=: (Signer) -> Signer
       end
 
       def self.extra_options: (Options) -> (Options & _SigV4Options)
@@ -59,6 +67,6 @@ module HTTPX
       end
     end
 
-    type awsSigV4Session = Session & Plugins::AWSSigV4::InstanceMethods
+    type awsSigV4Session = Session & AWSSigV4::InstanceMethods
   end
 end

data/sig/plugins/basic_authentication.rbs

@@ -10,6 +10,6 @@ module HTTPX
       end
     end
 
-    type sessionBasicAuthentication = Plugins::sessionAuthentication & Plugins::BasicAuthentication::InstanceMethods
+    type sessionBasicAuthentication = sessionAuthentication & Authentication::InstanceMethods & BasicAuthentication::InstanceMethods
   end
 end

data/sig/plugins/compression.rbs

@@ -15,23 +15,21 @@ module HTTPX
 
         def initialize: (Numeric bytesize) -> untyped
       end
-       
+
       def self.configure: (singleton(Session)) -> void
 
       interface _CompressionOptions
-        def compression_threshold_size: () -> _Integer?
-        def compression_threshold_size=: (int) -> int
+        def compression_threshold_size: () -> Integer?
 
         def encodings: () -> encodings_registry?
-        def encodings=: (encodings_registry) -> encodings_registry
       end
- 
+
       def self.extra_options: (Options) -> (Options & _CompressionOptions)
 
 
       module ResponseBodyMethods
         @encodings: Array[String]
-        @_deflaters: Array[_Decoder]
+        @_deflaters: Array[_Deflater]
 
         private
 

data/sig/plugins/cookies/cookie.rbs

@@ -31,19 +31,17 @@ module HTTPX
 
       def valid_for_uri?: (uri) -> bool
 
-      def self.new: (Cookie) -> untyped
-                    | (cookie_attributes) -> untyped
-                    | (String, String) -> untyped
-                    | (String, String, cookie_attributes) -> untyped
+      def self.new: (Cookie) -> instance
+                    | (cookie_attributes) -> instance
+                    | (_ToS, _ToS, ?cookie_attributes) -> instance
 
       def self.path_match?: (String, String) -> bool
 
       private
 
       def initialize: (cookie_attributes) -> untyped
-                    | (String, String) -> untyped
-                    | (String, String, cookie_attributes?) -> untyped
-      
+                    | (_ToS, _ToS, ?cookie_attributes) -> untyped
+
       def acceptable_from_uri?: (uri) -> bool
     end
   end