httpx 0.7.0 → 0.10.0

data/sig/plugins/expect.rbs

@@ -0,0 +1,19 @@
+module HTTPX
+  module Plugins
+    module Expect
+      EXPECT_TIMEOUT: Integer
+      
+      interface _ExpectOptions
+        def expect_timeout: () -> Integer?
+        def expect_timeout=: (int) -> Integer
+        def with_expect_timeout: (int) -> instance
+
+        def expect_threshold_size: () -> Integer?
+        def expect_threshold_size=: (int) -> Integer
+        def with_expect_threshold_size: (int) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _ExpectOptions)
+    end
+  end
+end

data/sig/plugins/follow_redirects.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  InsecureRedirectError: singleton(Error)
+
+  module Plugins
+    module FollowRedirects
+      MAX_REDIRECTS: Integer
+      REDIRECT_STATUS: Range[Integer]
+      
+      interface _FollowRedirectsOptions
+        def max_redirects: () -> Integer?
+        def max_redirects=: (int) -> Integer
+        def with_max_redirects: (int) -> instance
+
+        def follow_insecure_redirects: () -> bool?
+        def follow_insecure_redirects=: (bool) -> bool
+        def with_follow_insecure_redirects: (bool) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _FollowRedirectsOptions)
+
+      module InstanceMethods
+        def max_redirects: (_ToI) -> instance
+
+        def build_redirect_request: (Request, Response, Options) -> Request
+        def __get_location_from_response: (Response) -> (URI::HTTP | URI::HTTPS)
+      end
+
+      module RequestMethods
+        def redirect_request: () -> Request
+        def redirect_request=: (Request) -> void
+        def max_redirects: () -> Integer
+      end
+    end
+
+    type sessionFollowRedirects = Session & Plugins::Authentication::InstanceMethods
+  end
+end

data/sig/plugins/h2c.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  module Plugins
+    module H2C
+      # def self.load_dependencies: (singleton(Session)) -> void
+      
+      module InstanceMethods
+        VALID_H2C_METHODS: Array[Symbol]
+        
+        private
+
+        def valid_h2c_upgrade_request: (Request) -> bool
+        def valid_h2c_upgrade?: (Request, Response, Options) -> bool
+      end
+
+      class H2CParser < Connection::HTTP2
+        def upgrade: (Request, Response) -> void
+      end
+
+      module ConnectionMethods
+        def upgrade: (Request, Response) -> void
+      end
+    end
+
+    type sessionH2C = Session & Plugins::H2C::InstanceMethods
+  end
+end

data/sig/plugins/multipart.rbs

@@ -0,0 +1,19 @@
+module HTTPX
+  module Plugins
+    module Multipart
+      # def self.load_dependencies: (singleton(Session)) -> void
+      def self.configure: (*untyped) -> void
+      def self?.encode: (untyped) -> Encoder
+
+      class Encoder
+        include Transcoder::_Encoder
+        include _ToS
+        include _Reader
+
+        private
+
+        def initalize: (Hash[Symbol | string, HTTP::FormData::Part | string] multipart_data) -> untyped
+      end
+    end
+  end
+end

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: 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,2 @@
+class HTTPX::Pool
+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?: () -> bool
+
+    class Body
+      def initialize: (Headers, Options) -> untyped
+      def each: () { (String) -> void } -> void
+              | () -> Enumerable[String]
+
+      def empty?: () -> bool
+      def bytesize: () -> Integer
+      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