httpx 0.9.0 → 0.11.1

data/sig/plugins/persistent.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  module Plugins
+    module Persistent
+      def self.load_dependencies: (singleton(Session)) -> void
+      
+      interface _PersistentOptions
+        def persistent: () -> bool?
+        def persistent=: (bool) -> bool
+        def with_persistent: (bool) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _PersistentOptions)
+    end
+    
+    type sessionPersistent = sessionFollowRedirects
+  end
+end

data/sig/plugins/proxy.rbs

@@ -0,0 +1,47 @@
+module HTTPX
+  HTTPProxyError: singleton(Error)
+
+  module Plugins
+    module Proxy
+      Error: singleton(HTTPProxyError)
+      PROXY_ERRORS: Array[singleton(StandardError)]
+
+      class Parameters
+        attr_reader uri: URI::Generic
+        attr_reader username: string?
+        attr_reader password: string?
+
+        def authenticated?: () -> boolish
+        def token_authentication: () -> String?
+
+        def ==: (untyped) -> bool
+
+        private
+
+        def initialize: (uri: generic_uri, ?username: string, ?password: string) -> untyped
+      end
+
+      def self.configure: (singleton(Session)) -> void
+      
+      type proxyParam = Parameters | Hash
+      
+      interface _ProxyOptions
+        def proxy: () -> proxyParam?
+        def proxy=: (Parameters | _ToHash) -> proxyParam
+        def with_proxy: (Parameters | _ToHash) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _ProxyOptions)
+
+      module InstanceMethods
+        private
+
+        def proxy_uris: (uri, Options & _ProxyOptions) -> { uri: (URI | string), username: string, password: string }
+                      | (uri, Options & _ProxyOptions) -> { uri: (URI | string) }
+                      | (uri, Options & _ProxyOptions) -> nil
+      end
+    end
+
+    type sessionProxy = Session & Plugins::Proxy::InstanceMethods
+  end
+end

data/sig/plugins/proxy/http.rbs

@@ -0,0 +1,14 @@
+module HTTPX
+  module Plugins
+    module Proxy
+      module HTTP
+      
+        module ConnectionMethods
+          def __http_proxy_connect: () ->  void
+          def __http_on_connect: (top, Response) ->  void
+        end
+        
+      end
+    end
+  end
+end

data/sig/plugins/proxy/socks4.rbs

@@ -0,0 +1,33 @@
+module HTTPX
+  Socks4Error: singleton(Error)
+
+  module Plugins
+    module Proxy
+      module Socks4
+      
+        module ConnectionMethods
+          def __socks4_proxy_connect: () ->  void
+          def __socks4_on_packet: (String packet) ->  void
+          def on_socks4_error: (string) -> void
+        end
+        
+        class SocksParser
+          include Callbacks
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options) -> untyped
+        end
+
+        module Packet
+          def self?.connect: (Parameters, uri) -> String
+        end
+      end
+    end
+  end
+end

data/sig/plugins/proxy/socks5.rbs

@@ -0,0 +1,36 @@
+module HTTPX
+  Socks5Error: singleton(Error)
+
+  module Plugins
+    module Proxy
+      module Socks5
+      
+        module ConnectionMethods
+          def __socks5_proxy_connect: () ->  void
+          def __socks5_on_packet: (String packet) ->  void
+          def __socks5_check_version: (int) -> void
+          def __on_socks5_error: (string) -> void
+        end
+        
+        class SocksParser
+          include Callbacks
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options) -> untyped
+        end
+
+        module Packet
+          def self?.negotiate: (Parameters) -> String
+          def self?.authenticate: (Parameters) -> String
+          def self?.connect: (uri) -> String
+        end
+      end
+    end
+  end
+end

data/sig/plugins/proxy/ssh.rbs

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Proxy
+      module SSH
+        def self.load_dependencies: (singleton(Session)) -> void
+      
+        module InstancenMethods
+          private
+
+          def build_gateway_socket: (int, URI::HTTPS | URI::HTTPS, Options) ->  IO
+        end
+      end
+    end
+
+
+    type sessionSSHProxy = Plugins::Proxy::InstanceMethods & Plugins::Proxy::SSH::InstanceMethods
+  end
+end

data/sig/plugins/push_promise.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins
+    module PushPromise
+      def self.extra_options: (Options) -> Options
+
+      module ResponseMethods
+        def pushed?: () -> boolish
+        def mark_as_pushed!: () -> void
+      end
+
+      module InstanceMethods
+        private
+
+        def promise_headers:  () -> Hash[HTTP2Next::Stream, Request]
+        def __on_promise_request: (Connection::HTTP2, HTTP2Next::Stream, headers_input) -> void
+        def __on_promise_response: (Connection::HTTP2, HTTP2Next::Stream, headers_input) -> void
+      end
+    end
+
+    type sessionPushPromise = Session & PushPromise::InstanceMethods
+  end
+end

data/sig/plugins/rate_limiter.rbs

@@ -0,0 +1,11 @@
+module HTTPX
+  module Plugins
+    module RateLimiter
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.retry_on_rate_limited_response: (_Response) -> bool
+
+      def self.retry_after_rate_limit: (untyped, _Response) -> Numeric?
+    end
+  end
+end

data/sig/plugins/retries.rbs

@@ -0,0 +1,48 @@
+module HTTPX
+  module Plugins
+    module Retries
+      MAX_RETRIES: Integer
+      IDEMPOTENT_METHODS: Array[verb]
+      RETRYABLE_ERRORS: Array[singleton(StandardError)]
+      
+      interface _RetryCallback
+        def call: (response) -> bool?
+      end
+
+      interface _RetriesOptions
+        def retry_after: () -> Numeric?
+        def retry_after=: (Numeric) -> Numeric
+        def with_retry_after: (Numeric) -> instance
+
+        def max_retries: () -> Integer?
+        def max_retries=: (int) -> Integer
+        def with_max_retries: (int) -> instance
+
+        def retry_change_requests: () -> bool?
+        def retry_change_requests=: (bool) -> bool
+        def with_retry_change_requests: (bool) -> instance
+
+        def retry_on: () -> _RetryCallback?
+        def retry_on=: (_RetryCallback) -> _RetryCallback
+        def with_retry_on: (_RetryCallback) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _RetriesOptions)
+
+      module InstanceMethods
+        def max_retries: (int) -> instance
+
+        private
+
+        def __repeatable_request?: (Request, Options) -> boolish
+        def __retryable_error?: (_Exception) -> bool
+      end
+
+      module RequestMethods
+      	def retries: () -> Integer
+      end
+    end
+
+    type sessionRetries = Session & Plugins::Retries::InstanceMethods
+  end
+end

data/sig/plugins/stream.rbs

@@ -0,0 +1,39 @@
+module HTTPX
+  module Plugins
+    module Stream
+      module InstanceMethods
+        private
+
+        def request: (*Request, ?stream: bool, **untyped?) -> (response | Array[response] | StreamResponse)
+                   | (*untyped, ?stream: bool, **untyped?) -> (response | Array[response] | StreamResponse)
+      end
+
+      module RequestMethods
+        attr_accessor stream: StreamResponse?
+      end
+
+      module ResponseMethods
+        def stream: () -> StreamResponse?
+      end
+
+      class StreamResponse
+        include _ToS
+
+        def each: () { (String) -> void } -> void
+                | () -> Enumerable[String]
+
+        def each_line: () { (String) -> void } -> void
+                     | () -> Enumerable[String]
+
+        def on_chunk: (string) -> void
+
+        private
+
+        def response: () -> response
+        def initialize: (Request, Session) -> untyped
+      end
+    end
+
+    type sessionStream = Session & Plugins::Stream::InstanceMethods
+  end
+end

data/sig/pool.rbs

@@ -0,0 +1,36 @@
+module HTTPX
+  class Pool
+    def empty?: () -> void
+
+    def next_tick: () -> void
+
+    def close: (Array[Connection]) -> void
+             | () -> void
+
+    def init_connection: (Connection, Options) -> void
+
+    def find_connection: (generic_uri, Options) -> Connection?
+
+    private
+
+    def initialize: () -> untyped
+
+    def resolve_connection: (Connection) -> void
+
+    def on_resolver_connection: (Connection) -> void
+
+    def on_resolver_error: (Connection, StandardError) -> void
+
+    def on_resolver_close: (resolver) -> void
+
+    def register_connection: (Connection) -> void
+
+    def unregister_connection: (Connection) -> void
+
+    def coalesce_connections: (Connection, Connection) -> void
+
+    def next_timeout: () -> Numeric?
+
+    def find_resolver_for: (Connection) -> resolver
+  end
+end

data/sig/registry.rbs

@@ -0,0 +1,9 @@
+module HTTPX::Registry[T, V]
+  # type registrable = Symbol | String | Class
+
+  def self.registry: (T tag) -> Class
+                   | () -> Hash[K, V]
+  def self.register: (T tag,  V handler) -> void
+
+  def registry: (?T tag) -> V
+end

data/sig/request.rbs

@@ -0,0 +1,61 @@
+module HTTPX
+  class Request
+    include Callbacks
+
+    METHODS: Array[verb]
+    USER_AGENT: String
+
+    attr_reader verb: verb
+    attr_reader uri: URI::HTTP | URI::HTTPS
+    attr_reader headers: Headers
+    attr_reader body: Body
+    attr_reader state: Symbol
+    attr_reader options: Options
+    attr_reader response: Response?
+
+    def initialize: (verb | String, uri, ?options?) -> untyped
+
+    def interests: () -> (:r | :w)
+
+    def merge_headers: (Headers | Hash) -> void
+
+    def scheme: () -> ("http" | "https")
+
+    def response=: (Response response) -> void
+
+    def path: () -> String
+
+    def authority: () -> String
+
+    def origin: () -> String
+
+    def query: () -> String
+
+    def drain_body: () -> String?
+
+    def inspect: () -> String
+
+    def transition: (Symbol) -> void
+
+    def expects?: () -> boolish
+
+    class Body
+      def initialize: (Headers, Options) -> untyped
+      def each: () { (String) -> void } -> void
+              | () -> Enumerable[String]
+
+      def empty?: () -> bool
+      def bytesize: () -> Numeric
+      def stream: (Transcoder::_Encoder) -> bodyIO
+      def unbounded_body?: () -> bool
+      def chunked?: () -> bool
+      def chunk!: () -> void
+      def inspect: () -> String
+    end
+
+    class ProcIO
+      include _Writer
+      def initialize: (^(_ToS) -> void) -> untyped
+    end
+  end
+end

data/sig/resolver.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  type ipaddr = IPAddr | String
+
+  type resolver = Resolver::System | Resolver::Native | Resolver::HTTPS
+
+  module Resolver
+    type dns_resource = singleton(Resolv::DNS::Resource)
+
+    type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
+                    | { "name" => String, "TTL" => Numeric, "data" => String }
+
+    def self?.cached_lookup: (String hostname) -> Array[String]?
+
+    def self?.cached_lookup_set: (String hostname, Array[dns_result] addresses) -> void
+
+    def self?.uncache: (String hostname) -> void
+
+    def self?.lookup: (String hostname, Numeric ttl) -> Array[String]?
+
+    def self?.generate_id: () -> Integer
+
+    def self?.encode_dns_query: (String hostname, ?type: dns_resource) -> String
+
+    def self?.decode_dns_answer: (String) -> Array[dns_result]
+  end
+end

data/sig/resolver/https.rbs

@@ -0,0 +1,51 @@
+module HTTPX
+  module Resolver
+    class HTTPS
+      include ResolverMixin
+      include _ToIO
+
+      @options: Options
+      @resolver_options: Hash[Symbol, untyped]
+      @_record_types: Hash[String, Hash["A" | "AAAA", dns_resource]]
+      @queries: Hash[String, Connection]
+      @requests: Hash[Request, Connection]
+      @connections: Array[Connection]
+      @uri: URI::HTTPS
+      @uri_addresses: Array[String]?
+
+      def <<: (Connection) -> void
+
+      def timeout: () -> Numeric?
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def close: () -> void
+
+      def call: () -> void
+
+      def interests: () -> io_interests?
+
+      private
+
+      def initialize: (options) -> untyped
+
+      def pool: () -> Pool
+
+      def resolver_connection: () -> Connection
+
+      def resolve: (Connection, String hostname) -> void
+                 | (Connection) -> void
+                 | () -> void
+
+      def on_response: (Request, response) -> void
+
+      def response: (Response) -> void
+
+      def build_request: (String hostname, "A" | "AAAA") -> Request
+
+      def decode_response_body: (Response) -> Array[dns_result]
+    end
+  end
+end