httpx-patched 1.6.2.1

data/sig/response.rbs

@@ -0,0 +1,103 @@
+module HTTPX
+  interface _Response
+    def <<: (String data) -> void
+
+    def finished?: () -> bool
+
+    def finish!: () -> void
+
+    def raise_for_status: () -> self
+
+    def error: () -> StandardError?
+  end
+
+  class Response
+    extend Forwardable
+    include Callbacks
+
+    include _Response
+    include _ToS
+    include _Reader
+
+    attr_reader status: Integer
+    attr_reader headers: Headers
+    attr_reader body: Body
+    attr_reader version: String
+
+    @options: Options
+    @request: Request
+    @content_type: ContentType
+    @finished: bool
+
+    def copy_to: (_ToPath | _Writer destination) -> void
+
+    def close: () -> void
+
+    def uri: () -> URI::Generic
+
+    def peer_address: () -> (String | IPAddr)?
+
+    def merge_headers: (_Each[[String, headers_value]]) -> void
+
+    def bodyless?: () -> bool
+
+    def content_type: () -> ContentType
+
+    def complete?: () -> bool
+
+    def json: (?JSON::options opts) -> untyped
+
+    def form: () -> Hash[String, untyped]
+
+    def initialize: (Request request, String | Integer status, String version, headers?) -> void
+
+    private
+
+    def decode:(Transcoder::_Decode transcoder, ?untyped options) -> untyped
+  end
+
+  class ContentType
+    MIME_TYPE_RE: Regexp
+    CHARSET_RE: Regexp
+
+    @header_value: String?
+    @mime_type: String?
+    @charset: String?
+
+    def mime_type: () -> String?
+
+    def charset: () -> String?
+
+    private
+
+    def initialize: (String? header_value) -> void
+  end
+
+  class ErrorResponse
+    include _Response
+    include _Reader
+    include Loggable
+    extend Forwardable
+
+    @options: Options
+    @error: Exception
+
+    %a{pure} attr_reader request: Request
+
+    %a{pure} attr_reader response: Response?
+
+    def status: () -> (Integer | _ToS)
+
+    def uri: () -> URI::Generic
+
+    def peer_address: () -> (String | IPAddr)?
+
+    def close: () -> void
+
+    private
+
+    def initialize: (Request, Exception) -> untyped
+  end
+
+  type response = Response | ErrorResponse
+end

data/sig/selector.rbs

@@ -0,0 +1,68 @@
+module HTTPX
+  interface _Selectable
+    def state: () -> Symbol
+
+    def to_io: () -> IO
+
+    def call: () -> void
+
+    def interests: () -> io_interests?
+
+    def timeout: () -> Numeric?
+
+    def handle_socket_timeout: (Numeric interval) -> void
+  end
+
+  class Selector
+    type selectable = Resolver::Resolver | Connection | (Object & _Selectable)
+
+    type io_select_selectable = (selectable | Array[selectable])?
+
+    include _Each[selectable]
+
+    extend Forwardable
+
+    READABLE: Array[io_interests]
+    WRITABLE: Array[io_interests]
+
+    @timers: Timers
+
+    @selectables: Array[selectable]
+    @is_timer_interval: bool
+
+    def next_tick: () -> void
+
+    def terminate: () -> void
+
+    def find_resolver: (Options options) -> Resolver::Resolver?
+
+    def find_connection: (http_uri request_uri, Options options) -> Connection?
+
+    def each_connection: () { (Connection) -> void} -> void
+                       | () -> Enumerable[Connection]
+
+    def find_mergeable_connection: (Connection connection) -> Connection?
+
+    def empty?: () -> bool
+
+    def register: (selectable io) -> void
+
+    def deregister: (selectable io) -> selectable?
+
+    private
+
+    def initialize: () -> void
+
+    def select: (Numeric? interval) { (selectable) -> void } -> void
+
+    def select_many: (io_select_selectable r, io_select_selectable w, Numeric? interval) { (selectable) -> void } -> void
+
+    def select_one: (selectable io, io_interests interests, Numeric? interval) { (selectable) -> void } -> void
+
+    def next_timeout: () -> Numeric?
+
+    def rw_wait: (io_select_selectable IO, Numeric? interval) -> untyped?
+  end
+
+  type io_interests = :r | :w | :rw
+end

data/sig/session.rbs

@@ -0,0 +1,104 @@
+module HTTPX
+  class Session
+    include Loggable
+    include Chainable
+
+    EMPTY_HASH: Hash[untyped, untyped]
+
+    @options: Options
+
+    # returns the HTTPX::Pool object which manages the networking required to
+    # perform requests.
+    @pool: Pool
+
+    @persistent: bool
+    @wrapped: bool
+    @closing: bool
+
+    def wrap: () { (instance) -> void } -> void
+
+    def close: (?Selector selector) -> void
+
+    def build_request: (verb verb, generic_uri uri, ?request_params params, ?Options options) -> Request
+
+    def select_connection: (Connection connection, Selector selector) -> void
+
+    def pin_connection: (Resolver::Resolver | Connection connection, Selector selector) -> void
+
+    def deselect_connection: (Connection connection, Selector selector, ?bool cloned) -> void
+
+    def select_resolver: (Resolver::Native | Resolver::HTTPS resolver, Selector selector) -> void
+
+    def deselect_resolver: (Resolver::Resolver resolver, Selector selector) -> void
+
+    def try_clone_connection: (Connection connection, Selector selector, Integer? family) -> Connection
+
+    def find_connection: (http_uri request_uri, Selector selector, Options options) -> Connection
+
+    private
+
+    def initialize: (?options) { (self) -> void } -> void
+                  | (?options) -> void
+
+    def selector_close: (Selector close) -> void
+
+    def deactivate: (Selector selector) -> void
+
+    def on_promise: (untyped, untyped) -> void
+
+    def fetch_response: (Request request, Selector selector, Options options) -> response?
+
+    def send_request: (Request request, Selector selector, ?Options options) -> void
+
+    def set_request_callbacks: (Request request) -> void
+
+    def build_requests: (verb, uri, request_params) -> Array[Request]
+                      | (Array[[verb, uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
+                      | (Array[[verb, uri]], request_params) -> Array[Request]
+                      | (verb, _Each[[uri, request_params]], Hash[Symbol, untyped]) -> Array[Request]
+                      | (verb, _Each[uri], request_params) -> Array[Request]
+
+    def do_init_connection: (Connection connection, Selector selector) -> void
+
+    def send_requests: (*Request) -> Array[response]
+
+    def _send_requests: (Array[Request] requests, Selector selector) -> void
+
+    def receive_requests: (Array[Request] requests, Selector selector) -> Array[response]
+
+    def resolve_connection: (Connection connection, Selector selector) -> void
+
+    def on_resolver_connection: (Connection connection, Selector selector) -> void
+
+    def on_resolver_close: (Resolver::Resolver resolver, Selector selector) -> void
+
+    def find_resolver_for: (Connection connection, Selector selector) -> (Resolver::Multi | Resolver::Resolver)
+
+    def coalesce_connections: (Connection conn1, Connection conn2, Selector selector, bool from_pool) -> bool
+
+    def get_current_selector: () -> Selector?
+                            | () { () -> Selector } -> Selector
+
+    def set_current_selector: (Selector? selector) -> void
+
+    def selector_store: () -> Hash[instance, Selector]
+
+    def thread_selector_store: (Thread th) -> Hash[instance, Selector]?
+
+    attr_reader self.default_options: Options
+    self.@plugins: Array[Module]
+
+    def self.plugin: (Symbol | Module plugin, ?options? options) ?{ (Class) -> void } -> singleton(Session)
+
+
+    INSTANCES: Hash[Session, Session]
+
+    def self.after_fork: () -> void
+
+    module ForkTracker
+      def _fork: () -> void
+    end
+  end
+
+  S: singleton(Session)
+end

data/sig/timers.rbs

@@ -0,0 +1,54 @@
+module HTTPX
+  class Timers
+    type callback = ^() -> void
+
+    @intervals: Array[Interval]
+    @next_interval_at: Float
+
+    def after: (Numeric interval_in_secs, ^() -> void) -> Timer
+             | (Numeric interval_in_secs) { () -> void } -> Timer
+
+    def wait_interval: () -> Numeric?
+
+    def fire: (?TimeoutError error) -> void
+
+    def initialize: () -> void
+
+    private
+
+    def drop_elapsed!: (?Numeric elapsed_time) -> void
+
+    class Interval
+      include Comparable
+
+      attr_reader interval: Numeric
+
+      @callbacks: Array[callback]
+
+      def to_f: () -> Float
+
+      def <<: (callback) -> void
+
+      def delete: (callback) -> void
+
+      def elapse: (Numeric elapsed) -> Numeric
+
+      def elapsed?: (?Numeric elapsed_time) -> bool
+
+      def no_callbacks?: () -> bool
+
+      private
+
+      def initialize: (Numeric interval) -> void
+    end
+
+    class Timer
+      @interval: Interval
+      @callback: callback
+
+      def initialize: (Interval interval, callback callback) -> void
+
+      def cancel: () -> void
+    end
+  end
+end

data/sig/transcoder/body.rbs

@@ -0,0 +1,24 @@
+module HTTPX
+  module Transcoder
+    module Body
+      class Error < HTTPX::Error
+      end
+
+      class Encoder #  < SimpleDelegator
+        @raw: Object & bodyIO
+
+        def bytesize: () -> (Integer | Float)
+
+        def content_type: () -> String
+
+        def to_s: () -> String
+
+        private
+
+        def initialize: (untyped body) -> untyped
+      end
+
+      def self?.encode: (bodyIO body) -> Encoder
+    end
+  end
+end

data/sig/transcoder/chunker.rbs

@@ -0,0 +1,49 @@
+module HTTPX::Transcoder
+  module Chunker
+    CRLF: String
+
+    class Error < HTTPX::Error
+    end
+
+    def self?.encode: (_Each[String] chunks) -> Encoder
+
+    class Encoder
+      @raw: Object & _Each[String]
+
+      def each: () { (String) -> void } -> void
+              | () -> Enumerator[String, void]
+
+      private
+
+      def initialize: (_Each[String] chunks) -> void
+    end
+
+    class Decoder
+      extend Forwardable
+      include _ToS
+
+      @buffer: String
+      @chunk_length: Integer
+      @chunk_buffer: String
+      @finished: bool
+      @state: Symbol
+      @trailers: bool
+
+      def each: () { (String) -> void } -> void
+
+      def finished?: () -> bool
+
+      def empty?: () -> bool
+
+      def <<: (string) -> void
+
+      def clear: () -> void
+
+      private
+
+      def initialize: (String, ?bool) -> void
+
+      def nextstate: (Symbol) -> void
+    end
+  end
+end

data/sig/transcoder/deflate.rbs

@@ -0,0 +1,12 @@
+module HTTPX
+  module Transcoder
+    module Deflate
+      def self?.encode: (_Encoder body) -> Deflater
+      def self?.decode: (Response body, ?bytesize: Integer) -> GZIP::Inflater
+
+      class Deflater < Transcoder::Deflater
+        @deflater: Zlib::Deflate
+      end
+    end
+  end
+end

data/sig/transcoder/form.rbs

@@ -0,0 +1,34 @@
+module HTTPX::Transcoder
+  type form_value = string
+
+  type form_nested_value = form_value | _ToAry[form_value] | _ToHash[string, form_value]
+
+  type urlencoded_input = Enumerable[[_ToS, form_nested_value]]
+
+  module Form
+    PARAM_DEPTH_LIMIT: Integer
+
+    def self?.encode: (urlencoded_input form) -> Encoder
+
+    def self?.decode: (HTTPX::Response response) -> _Decoder
+
+    class Encoder
+      extend Forwardable
+      include _ToS
+
+      @raw: String
+
+      def bytesize: () -> Integer
+
+      def content_type: () -> String
+
+      private
+
+      def initialize: (urlencoded_input form) -> untyped
+    end
+
+    module Decoder
+      def self?.call: (HTTPX::Response response, *untyped) -> Hash[String, untyped]
+    end
+  end
+end

data/sig/transcoder/gzip.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+  module Transcoder
+    module GZIP
+      def self?.encode: (body_encoder body) -> Deflater
+      def self?.decode: (Response response, ?bytesize: Integer) -> Inflater
+
+      class Deflater < Transcoder::Deflater
+        @compressed_chunk: String
+
+        private
+
+        def write: (String chunk) -> void
+
+        def compressed_chunk: () -> String
+      end
+
+      class Inflater
+        @inflater: Zlib::Inflate
+        @bytesize: Integer
+
+        def initialize: (Integer | Float bytesize) -> void
+
+        def call: (String chunk) -> String
+      end
+    end
+  end
+end

data/sig/transcoder/json.rbs

@@ -0,0 +1,28 @@
+module HTTPX::Transcoder
+  module JSON
+    JSON_REGEX: Regexp
+
+    def self?.encode: (_ToJson json) -> Encoder
+    def self?.decode: (HTTPX::Response response) -> _Decoder
+
+    def self?.json_load: (string source, ?JSON::options) -> untyped
+    def self?.json_dump: (_ToJson obj, *untyped) -> String
+
+    class Encoder
+      extend Forwardable
+
+      @raw: String
+      @charset: String
+
+      def bytesize: () -> Integer
+
+      def content_type: () -> String
+
+      def to_s: () -> String
+
+      private
+
+      def initialize: (_ToJson json) -> void
+    end
+  end
+end

data/sig/transcoder/multipart.rbs

@@ -0,0 +1,103 @@
+module HTTPX
+  module Transcoder
+    module Multipart
+      interface _MultipartInput
+        def filename: () -> String
+        def content_type: () -> String
+        def read: (?int? length, ?string? output) -> String?
+      end
+
+      MULTIPART_VALUE_COND: ^(_Reader | record_multipart_value value) -> bool
+
+      type multipart_value = string | Pathname | File | Tempfile | _Reader
+
+      type record_multipart_value = { content_type: String, filename: String, body: multipart_value } |
+                                    { content_type: String, body: multipart_value }
+
+      type multipart_nested_value = multipart_value | _ToAry[multipart_value] | _ToHash[string, multipart_value]
+
+      type multipart_input = Enumerable[[_ToS, Multipart::multipart_nested_value]]
+
+      def self?.encode: (multipart_input form_data) -> Multipart::Encoder
+
+      def self?.multipart?: (form_nested_value | multipart_nested_value form_data) -> bool
+
+      class Encoder
+        @boundary: String
+        @part_index: Integer
+        @buffer: String
+
+        @form: Enumerable[[Symbol | string, Object & multipart_nested_value]]
+        @parts: Array[Object & _Reader]
+
+        attr_reader bytesize: Integer
+
+        def content_type: () -> String
+
+        def to_s: () -> String
+
+        def read: (?int? length, ?string? buffer) -> String?
+
+        def rewind: () -> void
+
+        private
+
+        def to_parts: (multipart_input multipart_data) -> Array[_Reader]
+
+        def initialize: (multipart_input multipart_data) -> untyped
+
+        def header_part: (String key, String content_type, String? filename) -> StringIO
+
+        def read_chunks: (String buffer, ?Integer? length) -> void
+
+        def read_from_part: (?Integer? max_length) -> String?
+      end
+
+      class Decoder
+        CRLF: String
+        BOUNDARY_RE: Regexp
+        MULTIPART_CONTENT_TYPE: Regexp
+        MULTIPART_CONTENT_DISPOSITION: Regexp
+        MULTIPART_CONTENT_ID: Regexp
+        WINDOW_SIZE: Integer
+
+        @state: :idle | :part_header | :part_body | :parse_boundary | :done
+        @buffer: String
+        @parts: Hash[String, untyped]
+        @boundary: String
+        @intermediate_boundary: String
+        @current: String?
+
+        def call: (Response response, *untyped) -> Hash[String, untyped]
+
+        private
+
+        def initialize: (Response response) -> void
+
+        def parse: () -> void
+      end
+
+      class FilePart #  < SimpleDelegator
+        attr_reader original_filename: String
+        attr_reader content_type: String
+
+        # @file: Tempfile
+
+        # private
+
+        def initialize: (String filename, String content_type) -> void
+      end
+
+      module Part
+        def self?.call: [U] (Object & _MultipartInput multipart_input) -> [U, String, String]
+                      | (multipart_nested_value value) -> ([StringIO, String, String?] | [File | Tempfile, String, String])
+      end
+
+      module MimeTypeDetector
+        DEFAULT_MIMETYPE: String
+
+        def self?.call: (IO | Tempfile file, String filename) -> String?
+      end
+    end
+  end
+end

data/sig/transcoder/utils/body_reader.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  module Transcoder
+    class BodyReader
+      @body: Object & (_Reader | _Each[String])
+
+      def initialize: (body_encoder body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string? outbuf) -> String?
+
+      def close: () -> void
+    end
+  end
+end

data/sig/transcoder/utils/deflater.rbs

@@ -0,0 +1,28 @@
+module HTTPX
+  module Transcoder
+    class Deflater
+      extend Forwardable
+
+      @body: BodyReader
+      @buffer: Response::Buffer?
+      @closed: bool
+
+      attr_reader content_type: String
+
+      def initialize: (body_encoder body) -> void
+
+      def bytesize: () -> (Integer | Float)
+
+      def read: (?int? length, ?string? outbuf) -> String?
+
+      def close: () -> void
+
+      def deflate: (String? chunk) -> String?
+
+      private
+
+      def buffer_deflate!: () -> void
+
+    end
+  end
+end

data/sig/transcoder.rbs

@@ -0,0 +1,43 @@
+module HTTPX
+  type bodyIO = _Reader | _Each[String] | _ToS
+
+  type body_encoder = (Transcoder::_Encoder & _ToS) | (Transcoder::_Encoder & _Reader) | (Transcoder::_Encoder & _Each[String])
+
+  module Transcoder
+    def self?.normalize_keys: [U] (_ToS key, _ToAry[untyped] | _ToHash[_ToS, untyped] | untyped value, ?(^(untyped value) -> bool | nil) cond) { (String, ?untyped) -> U } -> U
+
+    def self?.normalize_query: (Hash[String, untyped] params, String name, String v, Integer depth) -> void
+
+    interface _Encode
+      def encode: (untyped payload) -> body_encoder
+    end
+
+    interface _Decode
+      def decode: (HTTPX::Response response) -> _Decoder
+    end
+
+    interface _Encoder
+      def bytesize: () -> (Integer | Float)
+
+      def content_type: () -> String
+    end
+
+    interface _Decoder
+      def call: (Response response, *untyped) -> untyped
+    end
+
+    interface _Inflater
+      def initialize: (Integer | Float bytesize) -> void
+
+      def call: (String chunk) -> String
+    end
+
+    interface _Deflater
+      def initialize: (Response body) -> void
+
+      def deflate: () -> void
+
+      def call: (StringIO | File buffer, ?chunk_size: Integer) ?{ (String chunk) -> void } -> void
+    end
+  end
+end