httpx-patched 1.6.2.1

data/sig/plugins/upgrade.rbs

@@ -0,0 +1,29 @@
+module HTTPX
+  module Plugins
+    module Upgrade
+      interface _Upgrader
+        def call: (Connection connection, Request request, Response response) -> void
+      end
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _UpgradeOptions
+        def upgrade_handlers: () -> Hash[String, _Upgrader]
+      end
+
+      def self.extra_options: (Options) -> (Options & _UpgradeOptions)
+
+      module InstanceMethods
+      end
+
+      module ConnectionMethods
+        attr_reader upgrade_protocol: String?
+        attr_reader hijacked: boolish
+
+        def hijack_io: () -> void
+      end
+    end
+
+    type sessionUpgrade = Session & Upgrade::InstanceMethods
+  end
+end

data/sig/plugins/webdav.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module WebDav
+      module InstanceMethods
+        def copy: (String src, String dst) -> (Response | ErrorResponse)
+
+        def move: (String src, String dst) -> (Response | ErrorResponse)
+
+        def lock: (String path, ?timeout: Numeric) ?{ (Response response) -> void } -> (Response | ErrorResponse)
+
+        def unlock: (String path, String? lock_token) -> (Response | ErrorResponse)
+
+        def mkcol: (String dir) -> Response
+
+        def propfind: (String path, ?(:acl | String) xml) -> Response
+
+        def proppatch: (String path, String xml) -> Response
+      end
+    end
+
+    type sessionWebDav = Session & WebDav::InstanceMethods
+  end
+end

data/sig/plugins/xml.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  module Plugins
+    module XML
+      MIME_TYPES: Regexp
+
+      module Transcoder
+        def self?.encode: (Nokogiri::XML::Node | String xml) -> Encoder
+        def self?.decode: (HTTPX::Response response) -> HTTPX::Transcoder::_Decoder
+
+        class Encoder
+          @raw: Nokogiri::XML::Node | String # can be nokogiri object
+
+          def content_type: () -> String
+
+          def bytesize: () -> (Integer | Float)
+
+          def to_s: () -> String
+
+          private
+
+          def initialize: (Nokogiri::XML::Node | String xml) -> void
+        end
+      end
+
+      module InstanceMethods
+      end
+
+      module ResponseMethods
+        def xml: () -> Nokogiri::XML::Node
+      end
+
+      module RequestBodyClassMethods
+      end
+    end
+    type sessionXML = Session & XML::InstanceMethods
+  end
+end

data/sig/pool.rbs

@@ -0,0 +1,51 @@
+module HTTPX
+  type pool_options = {
+    max_connections_per_origin: Integer?,
+    pool_timeout: Numeric?
+  }
+
+  class Pool
+    POOL_TIMEOUT: Integer
+
+    type resolver_manager = Resolver::Multi | Resolver::System
+
+    @max_connections: Integer
+    @max_connections_per_origin: Integer
+    @pool_timeout: Numeric
+    @options: Options
+    @resolvers: Hash[Class, Array[resolver_manager]]
+    @resolver_mtx: Thread::Mutex
+    @connections: Hash[String, Array[Connection]]
+    @connection_mtx: Thread::Mutex
+    @connections_counter: Integer
+    @max_connections_cond: ConditionVariable
+    @origin_counters: Hash[String, Integer]
+    @origin_conds: Hash[String, ConditionVariable]
+
+    def pop_connection: () -> Connection?
+
+    def checkout_connection: (http_uri uri, Options options) -> Connection
+
+    def checkin_connection: (Connection connection) -> void
+
+    def checkout_mergeable_connection: (Connection connection) -> Connection?
+
+    def reset_resolvers: () -> void
+
+    def checkout_resolver: (Options options) -> resolver_manager
+
+    def checkin_resolver: (Resolver::Resolver resolver) -> void
+
+    private
+
+    def initialize: (pool_options options) -> void
+
+    def acquire_connection: (http_uri uri, Options options) -> Connection?
+
+    def checkout_new_connection: (http_uri uri, Options options) -> Connection
+
+    def checkout_new_resolver: (Class resolver_type, Options options) -> resolver_manager
+
+    def drop_connection: (?Connection connection) -> Connection?
+  end
+end

data/sig/punycode.rbs

@@ -0,0 +1,5 @@
+module HTTPX
+  module Punycode
+    def self?.encode_hostname: (String) -> String
+  end
+end

data/sig/request/body.rbs

@@ -0,0 +1,34 @@
+module HTTPX
+  class Request::Body
+    attr_reader options: Options
+
+    @headers: Headers
+    @body: body_encoder?
+    @unbounded_body: bool
+
+    def initialize: (Headers h, Options options, **untyped) -> void
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def rewind: () -> void
+
+    def empty?: () -> bool
+
+    def bytesize: () -> (Integer | Float)
+
+    def stream: (Transcoder::_Encoder) -> bodyIO
+
+    def unbounded_body?: () -> bool
+
+    def chunked?: () -> bool
+
+    def chunk!: () -> void
+
+    private
+
+    def self.initialize_body: (Hash[Symbol, untyped] params) -> body_encoder?
+
+    def self.initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+  end
+end

data/sig/request.rbs

@@ -0,0 +1,88 @@
+module HTTPX
+  class Request
+    extend Forwardable
+    include Loggable
+    include Callbacks
+
+    METHODS: Array[Symbol]
+    USER_AGENT: String
+
+    attr_reader verb: verb
+    attr_reader uri: http_uri
+    attr_reader headers: Headers
+    attr_reader body: Body
+    attr_reader state: Symbol
+    attr_reader options: Options
+    attr_reader response: response?
+    attr_reader drain_error: StandardError?
+    attr_reader active_timeouts: Array[Symbol]
+
+    attr_accessor peer_address: (String | IPAddr)?
+
+    attr_writer persistent: bool
+
+    @ping: bool
+    @query_params: Hash[interned, untyped]?
+    @trailers: Headers?
+    @informational_status: Integer?
+    @query: String?
+    @drainer: Enumerator[String, void]?
+
+    def initialize: (Symbol | String verb, generic_uri uri, Options options, ?request_params params) -> untyped
+
+    def complete!: (?response response) -> void
+
+    def ping?: () -> bool
+
+    def ping!: () -> void
+
+    def empty?: () -> bool
+
+    def close: () -> void
+
+    def interests: () -> (:r | :w)
+
+    def can_buffer? : () -> bool
+
+    def merge_headers: (_Each[[String, headers_value]]) -> void
+
+    def scheme: () -> String
+
+    def 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
+
+    def trailers: () -> Headers
+
+    def trailers?: () -> boolish
+
+    def persistent?: () -> bool
+
+    def read_timeout: () -> Numeric?
+
+    def write_timeout: () -> Numeric?
+
+    def request_timeout: () -> Numeric?
+
+    def set_timeout_callback: (Symbol event) { (*untyped) -> void } -> void
+
+    private
+
+    def initialize_body: (Options options) -> Transcoder::_Encoder?
+
+  end
+end

data/sig/resolver/entry.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  class Resolver::Entry
+    attr_reader address: IPAddr | String
+
+    @expires_in: Numeric
+
+    def initialize: (IPAddr | _ToS address, ?Numeric expires_in, ?rescue_on_convert: boolish) -> void
+
+    def expired?: () -> bool
+
+    def self.convert: (IPAddr | _ToS address) -> Resolver::Entry
+  end
+end

data/sig/resolver/https.rbs

@@ -0,0 +1,45 @@
+module HTTPX
+  module Resolver
+    class HTTPS < Resolver
+      extend Forwardable
+
+      NAMESERVER: String
+
+      DEFAULTS: Hash[Symbol, untyped]
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
+
+      attr_reader family: ip_family
+
+      @options: Options
+      @queries: Hash[String, Connection]
+      @requests: Hash[Request, String]
+      @connections: Array[Connection]
+      @uri: http_uri
+      @uri_addresses: Array[String]?
+      @resolver: Resolv::DNS
+      @resolver_connection: Connection
+
+      attr_writer pool: Pool
+
+      def <<: (Connection) -> void
+
+      private
+
+      def initialize: (ip_family family, options options) -> void
+
+      def resolver_connection: () -> Connection
+
+      def on_response: (Request, response) -> void
+
+      def parse: (Request request, Response response) -> void
+
+      def parse_addresses: (Array[dns_result] answers, Request request) -> void
+
+      def build_request: (String hostname) -> Request
+
+      def decode_response_body: (Response) -> dns_decoding_response
+
+      def reset_hostname: (String hostname, ?reset_candidates: bool) -> Connection?
+    end
+  end
+end

data/sig/resolver/multi.rbs

@@ -0,0 +1,32 @@
+module HTTPX
+  module Resolver
+    class Multi
+      attr_reader resolvers: Array[Native | HTTPS]
+
+      attr_reader options: Options
+
+      @current_selector: Selector?
+      @current_session: Session?
+      @resolver_options: Hash[Symbol, untyped]
+      # @errors: Hash[Symbol, untyped]
+
+      def current_selector=: (Selector s) -> void
+
+      def current_session=: (Session s) -> void
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def timeout: () -> Numeric?
+
+      def close: () -> void
+
+      def connections: () -> Array[Connection]
+
+      def early_resolve: (Connection connection) -> bool
+
+      def lazy_resolve: (Connection connection) -> void
+    end
+  end
+end

data/sig/resolver/native.rbs

@@ -0,0 +1,74 @@
+module HTTPX
+  module Resolver
+    class Native < Resolver
+      extend Forwardable
+      include _ToIO
+
+      DEFAULTS: Hash[Symbol, untyped]
+      DNS_PORT: Integer
+
+      @options: Options
+      @ns_index: Integer
+      @nameserver: Array[String]
+      @socket_type: :udp | :tcp
+      @ndots: Integer
+      @start_timeout: Float?
+      @search: Array[String]
+      @_timeouts: Array[Numeric]
+      @timeouts: Hash[String, Array[Numeric]]
+      @queries: Hash[String, Connection]
+      @connections: Array[Connection]
+      @read_buffer: String
+      @write_buffer: Buffer
+      @large_packet: Buffer?
+      @io: UDP | TCP
+      @name: String?
+      @timer: Timers::Timer?
+
+      attr_reader state: Symbol
+
+      def call: () -> void
+
+      def interests: () -> (:r | :w | nil)
+
+      def <<: (Connection) -> void
+
+      def timeout: () -> Numeric?
+
+      def handle_socket_timeout: (Numeric interval) -> void
+
+      private
+
+      def initialize: (ip_family family, options options) -> void
+
+      def calculate_interests: () -> (:r | :w | nil)
+
+      def consume: () -> void
+
+      def schedule_retry: () -> void
+
+      def do_retry: (String host, Connection connection, Numeric interval) -> void
+
+      def dread: (Integer) -> void
+               | () -> void
+
+      def dwrite: () -> void
+
+      def parse: (String) -> void
+
+      def generate_candidates: (String) -> Array[String]
+
+      def build_socket: () -> (UDP | TCP)
+
+      def downgrade_socket: () -> void
+
+      def transition: (Symbol nextstate) -> void
+
+      def handle_error: (NativeResolveError | StandardError) -> void
+
+      def reset_hostname: (String hostname, ?connection: Connection, ?reset_candidates: bool) -> void
+
+      def close_or_resolve: () -> void
+    end
+  end
+end

data/sig/resolver/resolver.rbs

@@ -0,0 +1,64 @@
+module HTTPX
+  module Resolver
+    class Resolver
+      include Callbacks
+      include Loggable
+
+      include _Selectable
+
+      RECORD_TYPES: Hash[ip_family, singleton(Resolv::DNS::Resource)]
+
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
+
+      attr_reader family: ip_family
+
+      attr_reader options: Options
+
+      attr_writer current_selector: Selector?
+
+      attr_writer current_session: Session?
+
+      attr_accessor multi: Multi?
+
+      @record_type: singleton(Resolv::DNS::Resource)
+      @resolver_options: Hash[Symbol, untyped]
+      @connections: Array[Connection]
+
+      def close: () -> void
+
+      alias terminate close
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def each_connection: () { (Connection connection) -> void } -> void
+
+      def emit_addresses: (Connection connection, ip_family family, Array[ipaddr], ?bool early_resolve) -> void
+
+      def self.multi?: () -> bool
+
+      private
+
+      def resolve: (?Connection connection, ?String hostname) -> void
+
+      def emit_resolved_connection: (Connection connection, Array[ipaddr] addresses, bool early_resolve) -> void
+
+      def initialize: (ip_family family, Options options) -> void
+
+      def early_resolve: (Connection connection, ?hostname: String) -> bool
+
+      def set_resolver_callbacks: () -> void
+
+      def resolve_connection: (Connection connection) -> void
+
+      def emit_connection_error: (Connection connection, StandardError error) -> void
+
+      def close_resolver: (Resolver resolver) -> void
+
+      def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
+
+      def resolve_error: (String hostname, ?StandardError?) -> (ResolveError | ResolveTimeoutError)
+    end
+  end
+end

data/sig/resolver/system.rbs

@@ -0,0 +1,34 @@
+module HTTPX
+  module Resolver
+    class System < Resolver
+      RESOLV_ERRORS: Array[singleton(StandardError)] # ResolvError
+      DONE: 1
+      ERROR: 2
+
+      @resolver: Resolv::DNS
+      @_timeouts: Array[Numeric]
+      @timeouts: Hash[String, Array[Numeric]]
+      @queries: Array[[ip_family, Connection]]
+      @ips: Array[[ip_family, Connection, (Array[Addrinfo] | StandardError)]]
+      @pipe_mutex: Thread::Mutex
+      @pipe_read: IO
+      @pipe_write: IO
+
+      attr_reader state: Symbol
+
+      def <<: (Connection) -> void
+
+      private
+
+      def transition: (Symbol nextstate) -> void
+
+      def consume: () -> void
+
+      def async_resolve: (Connection connection, String hostname, String scheme) -> void
+
+      def __addrinfo_resolve: (String host, String scheme) -> Array[Addrinfo]
+
+      def initialize: (Options options) -> void
+    end
+  end
+end

data/sig/resolver.rbs

@@ -0,0 +1,48 @@
+module HTTPX
+  type ipaddr = String | IPAddr | Resolv::IPv4 | Resolver::Entry
+
+  module Resolver
+    type dns_resource = singleton(Resolv::DNS::Resource)
+
+    type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
+                    | { "name" => String, "TTL" => Numeric, "data" => String }
+
+    RESOLVE_TIMEOUT: Array[Integer]
+
+    self.@lookup_mutex: Thread::Mutex
+    self.@lookups: Hash[String, Array[dns_result]]
+    self.@identifier_mutex: Thread::Mutex
+    self.@identifier: Integer
+    self.@hosts_resolver: Resolv::Hosts
+
+    type dns_decoding_response = [:ok, Array[dns_result]] | [:decode_error, Resolv::DNS::DecodeError] | [:dns_error, Integer] | Symbol
+
+    def self?.nolookup_resolve: (String hostname) -> Array[Entry]?
+
+    def self?.ip_resolve: (String hostname) -> Array[Entry]?
+
+    def self?.hosts_resolve: (String hostname) -> Array[Entry]?
+
+    def self?.supported_ip_families: () -> Array[ip_family]
+
+    def self?.resolver_for: (Symbol | singleton(Resolver) resolver_type, Options options) -> singleton(Resolver)
+
+    def self?.cached_lookup: (String hostname) -> Array[Entry]?
+
+    def self?.cached_lookup_set: (String hostname, ip_family family, Array[dns_result] addresses) -> void
+
+    def self?.cached_lookup_evict: (String hostname, _ToS ip) -> void
+
+    def self?.lookup: (String hostname, Hash[String, Array[dns_result]] lookups, Numeric ttl) -> Array[Entry]?
+
+    def self?.generate_id: () -> Integer
+
+    def self?.encode_dns_query: (String hostname, ?type: dns_resource, ?message_id: Integer) -> String
+
+    def self?.decode_dns_answer: (String) -> dns_decoding_response
+
+    def self?.lookup_synchronize: [U] () { (Hash[String, Array[dns_result]] lookups) -> U } -> U
+
+    def self?.id_synchronize: () { () -> void } -> void
+  end
+end

data/sig/response/body.rbs

@@ -0,0 +1,52 @@
+module HTTPX
+  class Response::Body
+    include _Reader
+    include _ToS
+    include _ToStr
+
+    attr_reader encoding: Encoding
+    attr_reader encodings: Array[String]
+
+    attr_reader buffer: Response::Buffer?
+
+    @response: Response
+    @headers: Headers
+    @options: Options
+    @state: :idle | :memory | :buffer | :closed
+    @window_size: Integer
+    @length: Integer
+    @reader: Response::Buffer?
+    @inflaters: Array[Transcoder::_Inflater]
+
+    def initialize: (Response, Options) -> void
+
+    def closed?: () -> bool
+
+    def write:(String chunk) -> Integer?
+
+    def filename: () -> String?
+
+    def bytesize: () -> Integer
+
+    def each: () { (String) -> void } -> void
+            | () -> Enumerable[String]
+
+    def empty?: () -> bool
+
+    def copy_to: (String | File | _Writer destination) -> void
+
+    def close: () -> void
+
+    def rewind: () -> void
+
+    private
+
+    def initialize_inflaters: () -> void
+
+    def self.initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> Transcoder::GZIP::Inflater
+
+    def decode_chunk: (String chunk) -> String
+
+    def transition: (Symbol nextstate) -> void
+  end
+end

data/sig/response/buffer.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  class Response::Buffer
+    attr_reader buffer: StringIO | Tempfile
+
+    @threshold_size: Integer
+    @bytesize: Integer
+    @encoding: Encoding
+
+    def initialize: (threshold_size: Integer, ?bytesize: Integer, ?encoding: Encoding) -> void
+
+    def size: () -> Integer
+
+    def write: (String chunk) -> Integer
+
+    def to_s: () -> String
+
+    def close: () -> void
+
+    private
+
+    def try_upgrade_buffer: () -> void
+  end
+end