httpx-patched 1.6.2.1

data/sig/plugins/circuit_breaker.rbs

@@ -0,0 +1,71 @@
+module HTTPX
+  module Plugins
+    module CircuitBreaker
+
+      class CircuitStore
+        @circuits: Hash[String, Circuit]
+
+        @circuits_mutex: Thread::Mutex
+
+        def try_open: (uri uri, response response) -> response?
+
+        def try_respond: (Request request) -> response?
+
+        def try_close: (http_uri uri) -> void
+
+        private
+
+        def get_circuit_for_uri: (uri uri) -> Circuit
+
+        def initialize: (Options & _CircuitOptions options) -> void
+      end
+
+      class Circuit
+        @state: :closed | :open | :half_open
+        @max_attempts: Integer
+        @reset_attempts_in: Float
+        @break_in: Float
+        @circuit_breaker_half_open_drip_rate: Float
+        @attempts: Integer
+        @real_attempts: Integer
+        @drip_factor: Integer
+
+        @response: response?
+        @opened_at: Float?
+        @attempted_at: Float?
+
+        def respond: () -> response?
+
+        def try_open: (response) -> response?
+
+        def try_close: () -> void
+
+        private
+
+        def initialize: (Integer max_attempts, Float reset_attempts_in, Float break_in, Float circuit_breaker_half_open_drip_rate) -> void
+      end
+
+      interface _CircuitOptions
+        def circuit_breaker_max_attempts: () -> Integer
+        def circuit_breaker_reset_attempts_in: () -> Float
+        def circuit_breaker_break_in: () -> Float
+        def circuit_breaker_half_open_drip_rate: () -> Float
+        def circuit_breaker_break_on: () -> (^(Response) -> boolish | nil)
+      end
+
+      def self.load_dependencies: (singleton(Session)) -> void
+      def self.extra_options: (Options) -> (Options & _CircuitOptions)
+
+      module InstanceMethods
+        @circuit_store: CircuitStore
+
+        private
+
+        def try_circuit_open: (Request request, response response) -> response?
+      end
+
+    end
+
+    type sessionCircuitBreaker = Session & CircuitBreaker::InstanceMethods
+  end
+end

data/sig/plugins/compression.rbs

@@ -0,0 +1,57 @@
+module HTTPX
+  module Plugins
+    module Compression
+
+      type deflatable = _Reader | _ToS
+
+      interface _Deflater
+        def deflate: (deflatable, ?_Writer, ?chunk_size: Integer) -> _ToS
+                   | (deflatable, ?_Writer, ?chunk_size: Integer) { (String) -> void } -> _ToS
+      end
+
+      interface _Inflater
+        def inflate: (string) -> String
+
+        def initialize: (Integer | Float bytesize) -> untyped
+      end
+
+      interface _Compressor
+        def deflater: () -> _Deflater
+        def inflater: (Integer | Float bytesize) -> _Inflater
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _CompressionOptions
+        def encodings: () -> Hash[String, _Compressor]
+      end
+
+      def self.extra_options: (Options) -> (Options & _CompressionOptions)
+
+
+      module ResponseBodyMethods
+        @encodings: Array[String]
+        @_deflaters: Array[_Deflater]
+
+        private
+
+        def decompress: (string) -> String
+      end
+
+      class Encoder
+        include Transcoder::_Encoder
+        include _ToS
+        include _Each[String]
+
+        def close: () -> void
+
+      	private
+
+        def initialize: (deflatable body, _Deflater deflater) -> untyped
+        def deflate: () -> void
+                   | () { (String) -> void } -> void
+      end
+
+    end
+  end
+end

data/sig/plugins/content_digest.rbs

@@ -0,0 +1,51 @@
+module HTTPX
+  module Plugins
+    module ContentDigest
+      class Error < HTTPX::Error
+      end
+      class ValidationError < Error
+        attr_reader response: Response
+
+        def initialize: (String message, Response response) -> void
+      end
+      class MissingContentDigestError < ValidationError
+      end
+      class InvalidContentDigestError < ValidationError
+      end
+
+      SUPPORTED_ALGORITHMS: Hash[String, singleton(OpenSSL::Digest)]
+
+      interface _ContentDigestOptions
+        def digest_algorithm: () -> String
+        def encode_content_digest: () -> (bool | ^(Request) -> boolish)
+        def validate_content_digest: () -> (bool | ^(contentDigestResponse) -> boolish)
+      end
+
+      # def self.extra_options: (Options) -> contentDigestOptions
+
+      module InstanceMethods
+        private
+
+        def validate_content_digest: (Response response) -> void
+
+        def extract_content_digests: (String) -> Hash[String, String]
+
+        def base64digest: (Request::Body | contentDigestResponseBody body) -> String
+      end
+
+      module ResponseMethods
+        attr_reader body: contentDigestResponseBody
+      end
+
+      module ResponseBodyMethods
+        attr_reader content_digest_buffer: Response::Buffer?
+      end
+
+      type contentDigestOptions = Options & _ContentDigestOptions
+      type contentDigestResponse = Response & ResponseMethods
+      type contentDigestResponseBody = Response::Body & ResponseBodyMethods
+    end
+
+    type sessionContentDigest = Session & ContentDigest::InstanceMethods
+  end
+end

data/sig/plugins/cookies/cookie.rbs

@@ -0,0 +1,55 @@
+module HTTPX
+  module Plugins::Cookies
+    class Cookie
+      include Comparable
+
+      MAX_LENGTH: Integer
+
+      attr_reader domain: DomainName?
+
+      attr_reader path: String
+
+      attr_reader name: String
+
+      attr_reader value: String?
+
+      attr_reader created_at: Time
+
+      @for_domain: bool
+
+      @domain_name: DomainName
+
+      def path=: (string) -> void
+
+      def domain=: (string) -> void
+
+      def expires: () -> Time?
+
+      def expired?: () -> bool
+                  | (Time) -> bool
+
+      def cookie_value: () -> String
+      alias to_s cookie_value
+
+      def valid_for_uri?: (http_uri uri) -> bool
+
+      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
+                    | (_ToS, _ToS, ?cookie_attributes) -> untyped
+
+      def acceptable_from_uri?: (uri) -> bool
+
+      module Scanner
+        RE_BAD_CHAR: Regexp
+        def self?.quote: (String s) -> String
+      end
+    end
+  end
+end

data/sig/plugins/cookies/jar.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  module Plugins::Cookies
+    class Jar
+      type cookie = Cookie | Array[[String, String, cookie_attributes]] | Array[[String, String]] | cookie_attributes
+
+      include Enumerable[Cookie]
+
+      @cookies: Array[Cookie]
+
+      def parse: (String set_cookie) -> void
+
+      def add: (Cookie name, ?String path) -> void
+
+      def []: (http_uri) -> Array[Cookie]
+
+      def each: (?http_uri?) { (Cookie) -> void } -> void
+              | (?http_uri?) -> Enumerable[Cookie]
+
+      def merge: (_Each[cookie] cookies) -> self
+
+      private
+
+      def initialize: (?_Each[cookie] cookies) -> untyped
+    end
+  end
+end

data/sig/plugins/cookies/set_cookie_parser.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins::Cookies
+    module SetCookieParser
+      RE_WSP: Regexp
+
+      RE_NAME: Regexp
+
+      RE_BAD_CHAR: Regexp
+
+      RE_COOKIE_COMMA: Regexp
+
+      def self?.call: (String set_cookie) { (String name, String value, cookie_attributes attrs) -> void } -> void
+
+      def self?.scan_dquoted: (StringScanner scanner) -> String
+
+      def self?.scan_value: (StringScanner scanner, ?bool comma_as_separator) -> String
+
+      def self?.scan_name_value: (StringScanner scanner, ?bool comma_as_separator) -> [String?, String?]
+
+    end
+  end
+end

data/sig/plugins/cookies.rbs

@@ -0,0 +1,28 @@
+module HTTPX
+  module Plugins
+    module Cookies
+      type cookie_attributes = Hash[Symbol | String, top]
+
+      type jar = Jar | _Each[Jar::cookie]
+
+      interface _CookieOptions
+        def cookies: () -> Jar?
+
+        def merge_cookie_in_jar: (Array[String] cookies, Jar jar) -> void
+      end
+
+      def self.extra_options: (Options) -> (Options & _CookieOptions)
+
+      module InstanceMethods
+        def cookies: () -> Jar
+      end
+
+      module HeadersMethods
+        def set_cookie: (Array[Cookie]) -> void
+      end
+    end
+
+    type sessionCookies = Session & Cookies::InstanceMethods
+    type headersCookies = Headers & Cookies::HeadersMethods
+  end
+end

data/sig/plugins/digest_auth.rbs

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module DigestAuth
+      DigestError: singleton(Error)
+
+      interface _DigestOptions
+        def digest: () -> Authentication::Digest?
+      end
+
+      def self.extra_options: (Options) -> (Options & _DigestOptions)
+
+      def self.load_dependencies: (*untyped) -> void
+
+      module InstanceMethods
+        def digest_auth: (string user, string password, ?hashed: bool) -> instance
+      end
+    end
+
+    type sessionDigestAuth = sessionAuthorization & DigestAuth::InstanceMethods
+  end
+end

data/sig/plugins/expect.rbs

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

data/sig/plugins/fiber_concurrency.rbs

@@ -0,0 +1,51 @@
+module HTTPX
+  module Plugins
+    module FiberConcurrency
+      module InstanceMethods
+      end
+
+      module RequestMethods
+        attr_reader context: Fiber?
+
+        def set_context!: () -> void
+
+        def current_context?: () -> bool
+      end
+
+      module ConnectionMethods
+
+        def current_context?: () -> bool
+
+        def send: (request request) -> void
+      end
+
+      module HTTP1Methods
+      end
+
+      module HTTP2Methods
+        @contexts: Hash[Fiber, Set[Request]]
+
+        private
+
+        def add_to_context: (request request) -> void
+
+        def clear_from_context: (request request) -> void
+      end
+
+      module NativeResolverMethods
+      end
+
+      module SystemResolverMethods
+      end
+
+      module FiberConcurrencyH2C
+        module HTTP2Methods
+        end
+      end
+
+      type request = Request & RequestMethods
+    end
+
+    type sessionFiberConcurrency = Session & FiberConcurrency::InstanceMethods
+  end
+end

data/sig/plugins/follow_redirects.rbs

@@ -0,0 +1,47 @@
+module HTTPX
+  InsecureRedirectError: singleton(Error)
+
+  module Plugins
+    module FollowRedirects
+      MAX_REDIRECTS: Integer
+      REDIRECT_STATUS: Range[Integer]
+      REQUEST_BODY_HEADERS: Array[String]
+
+      type redirect_request = Request & RequestMethods
+
+      interface _FollowRedirectsOptions
+        def max_redirects: () -> Integer?
+
+        def follow_insecure_redirects: () -> bool?
+
+        def allow_auth_to_other_origins: () -> bool?
+
+        def redirect_on: () -> (^(http_uri) -> boolish | nil)
+      end
+
+      def self.extra_options: (Options) -> (Options & _FollowRedirectsOptions)
+
+      module InstanceMethods
+        def max_redirects: (_ToI) -> instance
+
+        def handle_after_redirect_request: (http_uri original_uri, http_uri redirect_uri, Request request, Options & _FollowRedirectsOptions options) -> void
+
+        def __get_location_from_response: (Response) -> http_uri
+      end
+
+      module RequestMethods
+        attr_accessor root_request: instance?
+
+        @redirect_request: redirect_request
+
+        def redirect_request: () -> redirect_request
+
+        def redirect_request=: (redirect_request req) -> void
+
+        def max_redirects: () -> Integer
+      end
+    end
+
+    type sessionFollowRedirects = Session & FollowRedirects::InstanceMethods
+  end
+end

data/sig/plugins/grpc/call.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module GRPC
+      class Call
+        attr_writer decoder: _Callable
+
+        @response: Response | StreamResponse
+        @consumed: bool
+        @grpc_response: Enumerator[String] | String
+
+        def metadata: () -> headers
+
+        def trailing_metadata: () -> headers?
+
+        private
+
+        def initialize: (Response | StreamResponse response) -> untyped
+
+        def grpc_response: () -> grpc_response
+      end
+    end
+  end
+end

data/sig/plugins/grpc/grpc_encoding.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  module Transcoder
+    module GRPCEncoding
+
+      def self?.encode: (body_encoder body, compressed: bool) -> Deflater
+
+      def self?.decode: (Response | StreamResponse response) -> Inflater
+
+      class Deflater
+        attr_reader content_type: String
+
+        @body: BodyReader
+        @compressed: bool
+
+        def initialize: (body_encoder body, compressed: bool) -> void
+
+        def bytesize: () -> (Integer | Float)
+
+        def read: (?int? length, ?string outbuf) -> String?
+      end
+
+      class Inflater
+        @response: Response
+        @grpc_encodings: Array[String]
+
+        def initialize: (Response | StreamResponse response) -> void
+
+        def call: (String message) ?{ (String) -> void } -> String
+
+        private
+
+        def grpc_encodings: () -> Array[String]
+      end
+
+    end
+  end
+end

data/sig/plugins/grpc/message.rbs

@@ -0,0 +1,17 @@
+
+module HTTPX
+  module Plugins
+    module GRPC
+      module Message
+        def self?.unary: (response) -> grpc_message
+
+        def self?.stream: (StreamResponse) { (String) -> void } -> void
+                        | (StreamResponse) -> Enumerable[String]
+
+        def self?.cancel: (Request) -> void
+
+        def self?.verify_status: (StreamResponse | response) -> void
+      end
+    end
+  end
+end

data/sig/plugins/grpc.rbs

@@ -0,0 +1,65 @@
+module HTTPX
+  class GRPCError < Error
+    attr_reader status: Integer
+    attr_reader details: String
+    attr_reader metadata: headers
+  end
+
+  module Plugins
+    module GRPC
+      DEADLINE: Integer
+      MARSHAL_METHOD: Symbol
+      UNMARSHAL_METHOD: Symbol
+      HEADERS: Hash[String, String]
+
+      type compression_option = bool | String
+      type rpc_def = [String, untyped, untyped, Hash[Symbol, untyped]]
+
+      type grpc_message = String | _Each[String]
+
+      type grpc_request = untyped | _Each[untyped]
+      type grpc_response = untyped | _Each[untyped]
+
+      type credentials = Proc
+
+      interface _GRPCOptions
+        def grpc_service: () -> String?
+
+        def grpc_compression: () -> compression_option?
+
+        def grpc_rpcs: () -> Hash[String, rpc_def]?
+
+        def grpc_deadline: () -> Integer?
+
+        def call_credentials: () -> credentials?
+      end
+
+      def self.extra_options: (Options) -> (Options & _GRPCOptions)
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module ResponseMethods
+        attr_reader trailing_metadata: Hash[String, untyped]
+
+        def encoders: () -> Array[String | Encoding]
+      end
+
+      module InstanceMethods
+        def with_channel_credentials: (String ca_path, ?String? key, ?String? cert, **untyped) -> instance
+
+        def rpc: (_ToS rpc_name, untyped input, untyped output, **untyped) -> instance
+
+        def build_stub: (string origin, ?service: _ToS, ?compression: compression_option) -> instance
+
+        def execute:  (_ToS rpc_method, grpc_message input, ?deadline: Integer, ?metadata: headers_input, **untyped) -> Call
+
+        private
+
+        def rpc_execute: (_ToS rpc_method, grpc_request input, **untyped) -> Call
+
+        def build_grpc_request: (string rpc_method, grpc_message input, ?deadline: Integer, ?metadata?: headers_input, **untyped) -> Request
+      end
+    end
+
+    type grpcSession = Session & GRPC::InstanceMethods
+  end
+end

data/sig/plugins/h2c.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+  module Plugins
+    module H2C
+      VALID_H2C_VERBS: Array[verb]
+
+      def self.load_dependencies: (*untyped) -> void
+      def self.configure: (singleton(Session)) -> void
+      def self.call: (Connection, Request, response) -> void
+
+      interface _H2COptions
+        def h2c_class: () -> (singleton(Connection::HTTP2) & H2CParser)
+      end
+
+      module H2CParser
+        def upgrade: (Request, Response) -> void
+      end
+
+      module RequestMethods
+        def valid_h2c_verb?: () -> bool
+      end
+
+      module ConnectionMethods
+        def upgrade_to_h2c: (Request, Response) -> void
+      end
+    end
+  end
+end

data/sig/plugins/ntlm_auth.rbs

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module NTLMAuth
+
+      interface _NTLMOptions
+        def ntlm: () -> Authentication::Ntlm?
+      end
+
+      def self.extra_options: (Options) -> (Options & _NTLMOptions)
+
+      def self.load_dependencies: (*untyped) -> void
+
+      module InstanceMethods
+        def ntlm_auth: (string user, string password, ?string? domain) -> instance
+      end
+
+    end
+
+    type sessionNTLMAuth = sessionAuthorization & NTLMAuth::InstanceMethods
+  end
+end