httpx-patched 1.6.2.1

data/sig/plugins/oauth.rbs

@@ -0,0 +1,68 @@
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/os85/httpx/wikis/OAuth
+    #
+    module OAuth
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      type grant_type = "client_credentials" | "refresh_token"
+
+      type token_auth_method = "client_secret_basic" | "client_secret_post"
+
+      SUPPORTED_GRANT_TYPES: ::Array[grant_type]
+
+      SUPPORTED_AUTH_METHODS: ::Array[token_auth_method]
+
+      class OAuthSession
+        attr_reader grant_type: grant_type
+
+        attr_reader client_id: String
+
+        attr_reader client_secret: String
+
+        attr_reader access_token: String?
+
+        attr_reader refresh_token: String?
+
+        attr_reader scope: Array[String]?
+
+        attr_reader audience: String?
+
+        def initialize: (
+          issuer: uri,
+          client_id: String,
+          client_secret: String,
+          ?access_token: String?,
+          ?refresh_token: String?,
+          ?scope: (Array[String] | String)?,
+          ?token_endpoint: String?,
+          ?response_type: String?,
+          ?grant_type: String?,
+          ?token_endpoint_auth_method: ::String,
+          ?audience: ::String
+        ) -> void
+
+        def token_endpoint: () -> String
+
+        def token_endpoint_auth_method: () -> token_auth_method
+
+        def load: (Session http) -> void
+
+        def merge: (instance | Hash[untyped, untyped] other) -> instance
+      end
+
+      interface _AwsSdkOptions
+        def oauth_session: () -> OAuthSession?
+      end
+
+      module InstanceMethods
+        def oauth_auth: (**untyped args) -> instance
+
+        def with_access_token: () -> instance
+      end
+    end
+
+    type sessionOAuth = Session & OAuth::InstanceMethods
+  end
+end

data/sig/plugins/persistent.rbs

@@ -0,0 +1,14 @@
+module HTTPX
+  module Plugins
+    module Persistent
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options)
+
+      module InstanceMethods
+      end
+    end
+
+    type sessionPersistent = sessionFiberConcurrency & Persistent::InstanceMethods
+  end
+end

data/sig/plugins/proxy/http.rbs

@@ -0,0 +1,30 @@
+module HTTPX
+  module Plugins
+    module Proxy
+      module HTTP
+
+        module InstanceMethods
+          def with_proxy_basic_auth: (Hash[Symbol, untyped] opts) -> instance
+
+          def with_proxy_digest_auth: (Hash[Symbol, untyped] opts) -> instance
+
+          def with_proxy_ntlm_auth: (Hash[Symbol, untyped] opts) -> instance
+        end
+
+        module ConnectionMethods
+          def __http_proxy_connect: (Connection::_Parser parser) ->  void
+          def __http_on_connect: (top, Response) ->  void
+        end
+
+        module ProxyParser
+        end
+
+        class ConnectRequest < Request
+          def initialize: (generic_uri uri, Options options) -> void
+        end
+      end
+    end
+
+    type httpProxy = Session & Proxy::HTTP::InstanceMethods
+  end
+end

data/sig/plugins/proxy/socks4.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  class Socks4Error < ProxyError
+  end
+
+  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 HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options 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,49 @@
+module HTTPX
+  class Socks5Error < ProxyError
+  end
+
+  module Plugins
+    module Proxy
+      module Socks5
+        VERSION: Integer
+        NOAUTH: Integer
+        PASSWD: Integer
+        NONE: Integer
+        CONNECT: Integer
+        IPV4: Integer
+        DOMAIN: Integer
+        IPV6: Integer
+        SUCCESS: Integer
+
+        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 HTTPX::Callbacks
+
+          @buffer: Buffer
+          @options: Options
+
+          def close: () -> void
+          def consume: (*untyped) -> void
+          def empty: () -> bool
+          def <<: (string) -> void
+
+          private
+
+          def initialize: (Buffer buffer, Options options) -> untyped
+        end
+
+        module Packet
+          def self?.negotiate: (Parameters parameters) -> String
+          def self?.authenticate: (Parameters parameters) -> String
+          def self?.connect: (uri 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 InstanceMethods
+          private
+
+          def build_gateway_socket: (int, http_uri, Options) ->  _ToIO
+        end
+      end
+    end
+
+
+    type sessionSSHProxy = Proxy::InstanceMethods & Proxy::SSH::InstanceMethods
+  end
+end

data/sig/plugins/proxy.rbs

@@ -0,0 +1,70 @@
+module HTTPX
+  class ProxyError < ConnectionError
+  end
+
+  class ProxySSL < SSL
+    attr_reader proxy_io: TCP | SSL
+  end
+
+  module Plugins
+    interface _Authenticator
+      def authenticate: (Request request, String authenticate) -> String
+    end
+
+    module Proxy
+      class ProxyConnectionError < ProxyError
+      end
+
+      PROXY_ERRORS: Array[singleton(StandardError)]
+
+      class Parameters
+        attr_reader uri: URI::Generic?
+        attr_reader username: String?
+        attr_reader password: String?
+        attr_reader scheme: String?
+        attr_reader no_proxy: Array[String]?
+
+        @uris: Array[URI::Generic | String]
+        @authenticator: _Authenticator
+
+        def shift: () -> void
+
+        def can_authenticate?: (*untyped) -> boolish
+
+        def authenticate: (*untyped) -> String?
+
+        def ==: (untyped) -> bool
+
+        private
+
+        def initialize: (?uri: generic_uri | Array[generic_uri], ?scheme: String, ?username: String, ?password: String, ?no_proxy: Array[generic_uri] | generic_uri, **untyped) -> void
+
+        def infer_default_auth_scheme: (URI::Generic uri) -> String?
+
+        def load_authenticator: (String scheme, String username, String password, **untyped) -> _Authenticator
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _ProxyOptions
+        def proxy: () -> Parameters?
+      end
+
+      def self.extra_options: (Options) -> (Options & _ProxyOptions)
+
+      module ConnectionMethods
+        @proxy_uri: generic_uri
+      end
+
+      module InstanceMethods
+        @__proxy_uris: Array[generic_uri]
+
+        private
+
+        def proxy_error?: (Request request, response, Options options) -> bool
+      end
+    end
+
+    type sessionProxy = Session & Proxy::InstanceMethods
+  end
+end

data/sig/plugins/push_promise.rbs

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

data/sig/plugins/query.rbs

@@ -0,0 +1,18 @@
+module HTTPX
+  module Plugins
+    module Query
+      def self.subplugins: () -> Hash[Symbol, Module]
+
+      module InstanceMethods
+        def query: (uri | [uri], **untyped) -> response
+                 | (_Each[uri | [uri, request_params]], **untyped) -> Array[response]
+      end
+
+      module QueryRetries
+        module InstanceMethods
+        end
+      end
+    end
+    type sessionQuery = Session & Query::InstanceMethods
+  end
+end

data/sig/plugins/rate_limiter.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module RateLimiter
+      RATE_LIMIT_CODES: Array[Integer]
+
+      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/response_cache/file_store.rbs

@@ -0,0 +1,19 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      class FileStore
+        @dir: Pathname
+
+        include _ResponseCacheStore
+
+        def initialize: (?path dir) -> void
+
+        private
+
+        def file_path: (cacheRequest request) -> Pathname
+
+        def read_from_file: (cacheRequest request, File f) -> cacheResponse?
+      end
+    end
+  end
+end

data/sig/plugins/response_cache/store.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      class Store
+        @store: Hash[String, cacheResponse]
+
+        @store_mutex: Thread::Mutex
+
+        include _ResponseCacheStore
+      end
+    end
+  end
+end

data/sig/plugins/response_cache.rbs

@@ -0,0 +1,86 @@
+module HTTPX
+  module Plugins
+    module ResponseCache
+      CACHEABLE_VERBS: Array[verb]
+      CACHEABLE_STATUS_CODES: Array[Integer]
+      SUPPORTED_VARY_HEADERS: Array[String]
+
+      def self?.cacheable_response?: (::HTTPX::ErrorResponse | cacheResponse response) -> bool
+
+      def self?.not_modified?: (response response) -> bool
+
+      interface _ResponseCacheOptions
+        def response_cache_store: () -> Store
+
+        def supported_vary_headers: () -> Array[String]
+      end
+
+      interface _ResponseCacheStore
+        def get: (cacheRequest request) -> cacheResponse?
+
+        def set: (cacheRequest request, cacheResponse response) -> void
+
+        def clear: () -> void
+      end
+
+      module InstanceMethods
+        @response_cache: Store
+
+        def clear_response_cache: () -> void
+
+        private
+
+        def prepare_cache: (cacheRequest request) -> void
+
+        def cacheable_request?: (cacheRequest request) -> bool
+
+        def match_by_vary?: (cacheRequest request, cacheResponse response) -> bool
+      end
+
+      module RequestMethods
+        attr_accessor cached_response: cacheResponse?
+
+        @response_cache_key: String
+
+        def response_cache_key: () -> String
+
+        def cacheable_verb?: () -> bool
+      end
+
+      module ResponseMethods
+        attr_writer original_request: cacheRequest
+
+        @cache: bool
+
+        def original_request: () -> cacheRequest?
+
+        def cached?: () -> bool
+
+        def mark_as_cached!: () -> void
+
+        def copy_from_cached!: () -> void
+
+        def fresh?: () -> bool
+
+        def cache_control: () -> Array[String]?
+
+        def vary: () -> Array[String]?
+
+        private
+
+        def age: () -> Integer
+
+        def date: () -> Time
+      end
+
+
+      type cacheOptions = Options & _ResponseCacheOptions
+
+      type cacheRequest = Request & RequestMethods
+
+      type cacheResponse = Response & ResponseMethods
+    end
+
+    type sessionResponseCache = Session & ResponseCache::InstanceMethods
+  end
+end

data/sig/plugins/retries.rbs

@@ -0,0 +1,66 @@
+module HTTPX
+  module Plugins
+    module Retries
+      MAX_RETRIES: Integer
+      IDEMPOTENT_METHODS: Array[String]
+      RECONNECTABLE_ERRORS: Array[singleton(StandardError)]
+      RETRYABLE_ERRORS: Array[singleton(StandardError)]
+      DEFAULT_JITTER: ^(Numeric) -> Numeric
+
+      interface _RetryCallback
+        def call: (response response) -> bool?
+      end
+
+      interface _RetriesOptions
+        def retry_after: () -> Numeric?
+
+        def retry_jitter: () -> ^(Numeric jitter) -> Numeric
+
+        def max_retries: () -> Integer
+
+        def retry_change_requests: () -> boolish
+
+        def retry_on: () -> _RetryCallback?
+      end
+
+      def self.extra_options: (Options options) -> retriesOptions
+
+      module InstanceMethods
+        def max_retries: (int) -> instance
+
+        private
+
+        def fetch_response: (retriesRequest request, Selector selector, retriesOptions options) -> (retriesResponse | ErrorResponse)?
+
+        def repeatable_request?: (retriesRequest request, retriesOptions options) -> boolish
+
+        def retryable_error?: (_Exception error) -> bool
+
+        def try_partial_retry: (retriesRequest request, (retriesResponse | ErrorResponse) response) -> void
+
+      end
+
+      module RequestMethods
+        @options: Options & _RetriesOptions
+
+        attr_accessor retries: Integer
+
+        attr_writer partial_response: Response?
+
+        def response=: (retriesResponse | ErrorResponse response) -> void
+      end
+
+      module ResponseMethods
+        def from_partial_response: (Response response) -> void
+      end
+
+      type retriesOptions = Options & _RetriesOptions
+
+      type retriesRequest = Request & RequestMethods
+
+      type retriesResponse = Response & ResponseMethods
+    end
+
+    type sessionRetries = Session & Retries::InstanceMethods
+  end
+end

data/sig/plugins/ssrf_filter.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  class ServerSideRequestForgeryError < Error
+  end
+
+  module Plugins
+    module SsrfFilter
+      IPV4_BLACKLIST: Array[IPAddr]
+
+      IPV6_BLACKLIST: Array[[IPAddr, IPAddr]]
+
+      def self?.unsafe_ip_address?: (Resolver::Entry ipaddr) -> bool
+
+      interface _Options
+        def allowed_schemes: () -> Array[String]
+      end
+
+      module InstanceMethods
+      end
+
+      module ConnectionMethods
+      end
+    end
+
+    type sessionSsrf = Session & SsrfFilter::InstanceMethods
+  end
+end

data/sig/plugins/stream.rbs

@@ -0,0 +1,54 @@
+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
+
+      module ResponseBodyMethods
+        @stream: StreamResponse?
+      end
+    end
+
+    type sessionStream = Session & Stream::InstanceMethods
+  end
+
+  class StreamResponse
+    include _ToS
+
+    type streamRequest = Request & Plugins::Stream::RequestMethods
+
+    attr_reader request: streamRequest
+    @options: Options
+
+    @session: Plugins::sessionStream
+    @response_enum: Enumerator[String]?
+    @buffered_chunks: Array[String]
+    @on_chunk: ^(String) -> void | nil
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def each_line: () { (String) -> void } -> void
+                 | () -> Enumerable[String]
+
+    def on_chunk: (string) -> void
+
+    def initialize: (streamRequest, Plugins::sessionStream) -> void
+
+    private
+
+    def response: () -> response
+  end
+end

data/sig/plugins/stream_bidi.rbs

@@ -0,0 +1,68 @@
+module HTTPX
+  module Plugins
+    module StreamBidi
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      def self.extra_options: (Options) -> (Options)
+
+      class HTTP2Bidi < Connection::HTTP2
+        @lock: Thread::Mutex
+
+        private
+
+        def handle_stream: (::HTTP2::Stream stream, Request & RequestMethods request) -> void
+
+        def end_stream?: (Request & RequestMethods request, String? next_chunk) -> void
+      end
+
+      class BidiBuffer < Buffer
+        @parent_thread: Thread
+        @oob_mutex: Thread::Mutex
+        @oob_buffer: String
+
+        def rebuffer: () -> void
+      end
+
+      class Signal
+        @closed: bool
+        @pipe_read: IO
+        @pipe_write: IO
+
+        include _Selectable
+
+        def wakeup: () -> void
+
+        def mergeable?: () -> bool
+
+        def terminate: () -> void
+      end
+
+      module InstanceMethods
+        @signal: Signal
+      end
+
+      module RequestMethods
+        attr_accessor headers_sent: bool
+
+        @closed: bool
+        @mutex: Thread::Mutex
+
+        def closed?: () -> bool
+      end
+
+      module RequestBodyMethods
+      end
+
+      module ConnectionMethods
+        @write_buffer: BidiBuffer
+
+        private
+
+        def parser_type: (String protocol) -> (singleton(Connection::HTTP1) | singleton(Connection::HTTP2) | singleton(HTTP2Bidi))
+      end
+
+    end
+
+    type sessionStreamBidi = Session & StreamBidi::InstanceMethods
+  end
+end

data/sig/plugins/upgrade/h2.rbs

@@ -0,0 +1,9 @@
+module HTTPX
+  module Plugins
+    module H2
+      module ConnectionMethods
+        def upgrade_to_h2: () -> void
+      end
+    end
+  end
+end