httpx 0.8.1 → 0.10.2

data/sig/parser/http1.rbs

@@ -0,0 +1,50 @@
+module HTTPX
+  module Parser
+    type parsed_headers = Hash[String, Array[String]]
+
+    interface _HTTP1Events
+
+      def on_start: () -> void
+      def on_headers: (parsed_headers) -> void
+      def on_trailers: (parsed_headers) -> void
+      def on_data: (String) -> void
+      def on_complete: () -> void
+    end
+
+    class HTTP1
+      VERSIONS: Array[String]
+
+      def <<: (String chunk) -> void
+
+      def headers: () -> parsed_headers
+
+      def http_version: () -> Array[1 | 0]
+
+      def reset!: () -> void
+
+      def status_code: () -> Integer
+
+      def upgrade?: () -> bool
+
+      def upgrade_data: () -> String
+
+      private
+
+      def initialize: (_HTTP1Events observer) -> untyped
+
+      def nextstate: (Symbol state) -> void
+
+      def no_more_data?: () -> bool
+
+      def parse: () -> void
+
+      def parse_data: () -> void
+
+      def parse_headers: () -> void
+
+      def parse_headline: () -> void
+
+      def prepare_data: (parsed_headers headers) -> void
+    end
+  end
+end

data/sig/plugins/authentication.rbs

@@ -0,0 +1,11 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      module InstanceMethods
+        def authentication: (string token) -> instance
+      end
+    end
+
+    type sessionAuthentication = Session & Plugins::Authentication::InstanceMethods
+  end
+end

data/sig/plugins/basic_authentication.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module BasicAuthentication
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def basic_authentication: (string user, string password) -> instance
+      end
+    end
+
+    type sessionBasicAuthentication = Plugins::sessionAuthentication & Plugins::Authentication::InstanceMethods
+  end
+end

data/sig/plugins/compression.rbs

@@ -0,0 +1,55 @@
+module HTTPX
+  module Plugins
+    module Compression
+      extend Registry[Symbol, Class]
+
+      type deflatable = _Reader | _ToS
+
+      interface _Deflater
+        def deflate: (deflatable, _Writer, chunk_size: Integer) -> void
+                   | (deflatable, _Writer, chunk_size: Integer) { (String) -> void } -> void
+      end
+
+      interface _Inflater
+        def inflate: (string) -> String
+
+        def initialize: (Numeric bytesize) -> untyped
+      end
+       
+      def self.load_dependencies: (singleton(Session)) -> void
+
+      interface _CompressionOptions
+        def compression_threshold_size: () -> _Integer?
+        def compression_threshold_size=: (int) -> int
+        def with_compression_threshold_size: (int) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _CompressionOptions)
+
+
+      module ResponseBodyMethods
+        @encodings: Array[String]
+        @_deflaters: Array[_Decoder]
+
+        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/compression/brotli.rbs

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module Brotli
+        def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.decoder: (Numeric bytesize) -> Inflater
+
+        module Deflater
+          extend _Deflater
+        end
+
+        class Inflater
+          include _Inflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/compression/deflate.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module Deflate
+        def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.inflater: (Numeric bytesize) -> GZIP::Inflater
+
+        module Deflater
+          extend _Deflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/compression/gzip.rbs

@@ -0,0 +1,29 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module GZIP
+        def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.inflater: (Numeric bytesize) -> Inflater
+
+        class Deflater
+          include _Deflater
+
+          @compressed_chunk: String
+          
+          private
+          
+          def initialize: () -> untyped
+          def write: (string) -> void
+          def compressed_chunk: () -> String
+        end
+
+        class Inflater
+          include _Inflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/cookies.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  module Plugins
+    module Cookies
+      type jar = Jar | _Each[cookies]
+
+      interface _CookieOptions
+        def cookies: () -> Jar?
+        def cookies=: (jar) -> Jar
+        def with_cookies: (jar) -> instance
+      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 & Plugins::Cookies::InstanceMethods
+    type headersCookies = Headers & Plugins::Cookies::HeadersMethods
+  end
+end

data/sig/plugins/cookies/cookie.rbs

@@ -0,0 +1,50 @@
+module HTTPX
+  module Plugins::Cookies
+    type cookie_attributes = Hash[Symbol | String, top]
+
+    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
+
+      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?: (uri) -> bool
+
+      def self.new: (Cookie) -> untyped
+                    | (cookie_attributes) -> untyped
+                    | (String, String) -> untyped
+                    | (String, String, cookie_attributes) -> untyped
+
+      def self.path_match?: (String, String) -> bool
+
+      private
+
+      def initialize: (cookie_attributes) -> untyped
+                    | (String, String) -> untyped
+                    | (String, String, cookie_attributes?) -> untyped
+      
+      def acceptable_from_uri?: (uri) -> bool
+    end
+  end
+end

data/sig/plugins/cookies/jar.rbs

@@ -0,0 +1,27 @@
+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) -> void
+
+      def add: (Cookie) -> void
+             | (Cookie, String) -> void
+
+      def []: (uri) -> Array[Cookie]
+
+      def each: (uri) { (Cookie) -> void } -> void
+              | (uri) -> Enumerable[Cookie]
+              | () { (Cookie) -> void } -> void
+              | () -> Enumerable[Cookie]
+      private
+
+      def initialize: () -> void
+                    | (_Each[cookie]) -> untyped
+    end
+  end
+end

data/sig/plugins/digest_authentication.rbs

@@ -0,0 +1,33 @@
+module HTTPX
+  module Plugins
+    module DigestAuthentication
+      DigestError: singleton(Error)
+
+      interface _DigestOptions
+        def digest: () -> Digest?
+        def digest=: (Digest) -> Digest
+        def with_digest: (Digest) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _DigestOptions)
+
+      def self.load_dependencies: (*untyped) -> void
+
+      module InstanceMethods
+        def digest_authentication: (string user, string password) -> instance
+      end
+
+      class Digest
+        def generate_header: (Request, Response, ?bool?) -> String
+
+        private
+
+        def initialize: (string user, string password) -> untyped
+        def make_cnonce: () -> String
+        def next_nonce: () -> Integer
+      end
+    end
+
+    type sessionDigestAuthentication = Plugins::sessionAuthentication & Plugins::Authentication::InstanceMethods
+  end
+end

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,21 @@
+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 initialize: (Hash[Symbol | string, HTTP::FormData::Part | string] multipart_data) -> untyped
+
+        def multipart?: (top) -> bool
+      end
+    end
+  end
+end