x-twitter-scraper 0.3.0

data/rbi/x_twitter_scraper/internal/type/converter.rbi

@@ -0,0 +1,225 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      module Converter
+        extend XTwitterScraper::Internal::Util::SorbetRuntimeSupport
+
+        Input =
+          T.type_alias do
+            T.any(
+              XTwitterScraper::Internal::Type::Converter,
+              T::Class[T.anything]
+            )
+          end
+
+        CoerceState =
+          T.type_alias do
+            {
+              translate_names: T::Boolean,
+              strictness: T::Boolean,
+              exactness: {
+                yes: Integer,
+                no: Integer,
+                maybe: Integer
+              },
+              error: T::Class[StandardError],
+              branched: Integer
+            }
+          end
+
+        DumpState = T.type_alias { { can_retry: T::Boolean } }
+
+        # @api private
+        sig do
+          overridable
+            .params(
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::CoerceState
+            )
+            .returns(T.anything)
+        end
+        def coerce(value, state:)
+        end
+
+        # @api private
+        sig do
+          overridable
+            .params(
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::DumpState
+            )
+            .returns(T.anything)
+        end
+        def dump(value, state:)
+        end
+
+        # @api private
+        sig { params(depth: Integer).returns(String) }
+        def inspect(depth: 0)
+        end
+
+        class << self
+          # @api private
+          sig do
+            params(
+              spec:
+                T.any(
+                  {
+                    const:
+                      T.nilable(
+                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
+                      ),
+                    enum:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      ),
+                    union:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      )
+                  },
+                  T.proc.returns(
+                    XTwitterScraper::Internal::Type::Converter::Input
+                  ),
+                  XTwitterScraper::Internal::Type::Converter::Input
+                )
+            ).returns(T.proc.returns(T.anything))
+          end
+          def self.type_info(spec)
+          end
+
+          # @api private
+          sig do
+            params(
+              type_info:
+                T.any(
+                  {
+                    const:
+                      T.nilable(
+                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
+                      ),
+                    enum:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      ),
+                    union:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      )
+                  },
+                  T.proc.returns(
+                    XTwitterScraper::Internal::Type::Converter::Input
+                  ),
+                  XTwitterScraper::Internal::Type::Converter::Input
+                ),
+              spec:
+                T.any(
+                  {
+                    const:
+                      T.nilable(
+                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
+                      ),
+                    enum:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      ),
+                    union:
+                      T.nilable(
+                        T.proc.returns(
+                          XTwitterScraper::Internal::Type::Converter::Input
+                        )
+                      )
+                  },
+                  T.proc.returns(
+                    XTwitterScraper::Internal::Type::Converter::Input
+                  ),
+                  XTwitterScraper::Internal::Type::Converter::Input
+                )
+            ).returns(XTwitterScraper::Internal::AnyHash)
+          end
+          def self.meta_info(type_info, spec)
+          end
+
+          # @api private
+          sig do
+            params(translate_names: T::Boolean).returns(
+              XTwitterScraper::Internal::Type::Converter::CoerceState
+            )
+          end
+          def self.new_coerce_state(translate_names: true)
+          end
+
+          # @api private
+          #
+          # Based on `target`, transform `value` into `target`, to the extent possible:
+          #
+          # 1. if the given `value` conforms to `target` already, return the given `value`
+          # 2. if it's possible and safe to convert the given `value` to `target`, then the
+          #    converted value
+          # 3. otherwise, the given `value` unaltered
+          #
+          # The coercion process is subject to improvement between minor release versions.
+          # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
+          sig do
+            params(
+              target: XTwitterScraper::Internal::Type::Converter::Input,
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::CoerceState
+            ).returns(T.anything)
+          end
+          def self.coerce(
+            target,
+            value,
+            # The `strictness` is one of `true`, `false`. This informs the coercion strategy
+            # when we have to decide between multiple possible conversion targets:
+            #
+            # - `true`: the conversion must be exact, with minimum coercion.
+            # - `false`: the conversion can be approximate, with some coercion.
+            #
+            # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
+            # any given conversion attempt, the exactness will be updated based on how closely
+            # the value recursively matches the target type:
+            #
+            # - `yes`: the value can be converted to the target type with minimum coercion.
+            # - `maybe`: the value can be converted to the target type with some reasonable
+            #   coercion.
+            # - `no`: the value cannot be converted to the target type.
+            #
+            # See implementation below for more details.
+            state: XTwitterScraper::Internal::Type::Converter.new_coerce_state
+          )
+          end
+
+          # @api private
+          sig do
+            params(
+              target: XTwitterScraper::Internal::Type::Converter::Input,
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::DumpState
+            ).returns(T.anything)
+          end
+          def self.dump(target, value, state: { can_retry: true })
+          end
+
+          # @api private
+          sig { params(target: T.anything, depth: Integer).returns(String) }
+          def self.inspect(target, depth:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/enum.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      #
+      # A value from among a specified list of options. OpenAPI enum values map to Ruby
+      # values in the SDK as follows:
+      #
+      # 1. boolean => true | false
+      # 2. integer => Integer
+      # 3. float => Float
+      # 4. string => Symbol
+      #
+      # We can therefore convert string values to Symbols, but can't convert other
+      # values safely.
+      module Enum
+        include XTwitterScraper::Internal::Type::Converter
+        include XTwitterScraper::Internal::Util::SorbetRuntimeSupport
+
+        # All of the valid Symbol values for this enum.
+        sig do
+          overridable.returns(
+            T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]
+          )
+        end
+        def values
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ===(other)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ==(other)
+        end
+
+        sig { returns(Integer) }
+        def hash
+        end
+
+        # @api private
+        #
+        # Unlike with primitives, `Enum` additionally validates that the value is a member
+        # of the enum.
+        sig do
+          override
+            .params(
+              value: T.any(String, Symbol, T.anything),
+              state: XTwitterScraper::Internal::Type::Converter::CoerceState
+            )
+            .returns(T.any(Symbol, T.anything))
+        end
+        def coerce(value, state:)
+        end
+
+        # @api private
+        sig do
+          override
+            .params(
+              value: T.any(Symbol, T.anything),
+              state: XTwitterScraper::Internal::Type::Converter::DumpState
+            )
+            .returns(T.any(Symbol, T.anything))
+        end
+        def dump(value, state:)
+        end
+
+        # @api private
+        sig { returns(T.anything) }
+        def to_sorbet_type
+        end
+
+        # @api private
+        sig { params(depth: Integer).returns(String) }
+        def inspect(depth: 0)
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/file_input.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      #
+      # Either `Pathname` or `StringIO`, or `IO`, or
+      # `XTwitterScraper::Internal::Type::FileInput`.
+      #
+      # Note: when `IO` is used, all retries are disabled, since many IO` streams are
+      # not rewindable.
+      class FileInput
+        extend XTwitterScraper::Internal::Type::Converter
+
+        abstract!
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def self.===(other)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def self.==(other)
+        end
+
+        class << self
+          # @api private
+          sig do
+            override
+              .params(
+                value: T.any(StringIO, String, T.anything),
+                state: XTwitterScraper::Internal::Type::Converter::CoerceState
+              )
+              .returns(T.any(StringIO, T.anything))
+          end
+          def coerce(value, state:)
+          end
+
+          # @api private
+          sig do
+            override
+              .params(
+                value: T.any(Pathname, StringIO, IO, String, T.anything),
+                state: XTwitterScraper::Internal::Type::Converter::DumpState
+              )
+              .returns(T.any(Pathname, StringIO, IO, String, T.anything))
+          end
+          def dump(value, state:)
+          end
+
+          # @api private
+          sig { returns(T.anything) }
+          def to_sorbet_type
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/hash_of.rbi

@@ -0,0 +1,108 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      #
+      # Hash of items of a given type.
+      class HashOf
+        include XTwitterScraper::Internal::Type::Converter
+        include XTwitterScraper::Internal::Util::SorbetRuntimeSupport
+
+        abstract!
+
+        Elem = type_member(:out)
+
+        sig do
+          params(
+            type_info:
+              T.any(
+                XTwitterScraper::Internal::AnyHash,
+                T.proc.returns(
+                  XTwitterScraper::Internal::Type::Converter::Input
+                ),
+                XTwitterScraper::Internal::Type::Converter::Input
+              ),
+            spec: XTwitterScraper::Internal::AnyHash
+          ).returns(T.attached_class)
+        end
+        def self.[](type_info, spec = {})
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ===(other)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ==(other)
+        end
+
+        sig { returns(Integer) }
+        def hash
+        end
+
+        # @api private
+        sig do
+          override
+            .params(
+              value: T.any(T::Hash[T.anything, T.anything], T.anything),
+              state: XTwitterScraper::Internal::Type::Converter::CoerceState
+            )
+            .returns(T.any(XTwitterScraper::Internal::AnyHash, T.anything))
+        end
+        def coerce(value, state:)
+        end
+
+        # @api private
+        sig do
+          override
+            .params(
+              value: T.any(T::Hash[T.anything, T.anything], T.anything),
+              state: XTwitterScraper::Internal::Type::Converter::DumpState
+            )
+            .returns(T.any(XTwitterScraper::Internal::AnyHash, T.anything))
+        end
+        def dump(value, state:)
+        end
+
+        # @api private
+        sig { returns(T.anything) }
+        def to_sorbet_type
+        end
+
+        # @api private
+        sig { returns(Elem) }
+        protected def item_type
+        end
+
+        # @api private
+        sig { returns(T::Boolean) }
+        protected def nilable?
+        end
+
+        # @api private
+        sig do
+          params(
+            type_info:
+              T.any(
+                XTwitterScraper::Internal::AnyHash,
+                T.proc.returns(
+                  XTwitterScraper::Internal::Type::Converter::Input
+                ),
+                XTwitterScraper::Internal::Type::Converter::Input
+              ),
+            spec: XTwitterScraper::Internal::AnyHash
+          ).void
+        end
+        def initialize(type_info, spec = {})
+        end
+
+        # @api private
+        sig { params(depth: Integer).returns(String) }
+        def inspect(depth: 0)
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/request_parameters.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      module RequestParameters
+        # Options to specify HTTP behaviour for this request.
+        sig { returns(XTwitterScraper::RequestOptions) }
+        attr_reader :request_options
+
+        sig do
+          params(request_options: XTwitterScraper::RequestOptions::OrHash).void
+        end
+        attr_writer :request_options
+
+        # @api private
+        module Converter
+          # @api private
+          sig do
+            params(params: T.anything).returns(
+              [T.anything, XTwitterScraper::Internal::AnyHash]
+            )
+          end
+          def dump_request(params)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/union.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      module Union
+        include XTwitterScraper::Internal::Type::Converter
+        include XTwitterScraper::Internal::Util::SorbetRuntimeSupport
+
+        # @api private
+        #
+        # All of the specified variant info for this union.
+        sig do
+          returns(
+            T::Array[
+              [
+                T.nilable(Symbol),
+                T.proc.returns(
+                  XTwitterScraper::Internal::Type::Converter::Input
+                ),
+                XTwitterScraper::Internal::AnyHash
+              ]
+            ]
+          )
+        end
+        private def known_variants
+        end
+
+        # @api private
+        sig do
+          returns(
+            T::Array[
+              [
+                T.nilable(Symbol),
+                T.anything,
+                XTwitterScraper::Internal::AnyHash
+              ]
+            ]
+          )
+        end
+        protected def derefed_variants
+        end
+
+        # All of the specified variants for this union.
+        sig { overridable.returns(T::Array[T.anything]) }
+        def variants
+        end
+
+        # @api private
+        sig { params(property: Symbol).void }
+        private def discriminator(property)
+        end
+
+        # @api private
+        sig do
+          params(
+            key:
+              T.any(
+                Symbol,
+                XTwitterScraper::Internal::AnyHash,
+                T.proc.returns(T.anything),
+                T.anything
+              ),
+            spec:
+              T.any(
+                XTwitterScraper::Internal::AnyHash,
+                T.proc.returns(T.anything),
+                T.anything
+              )
+          ).void
+        end
+        private def variant(key, spec = nil)
+        end
+
+        # @api private
+        sig { params(value: T.anything).returns(T.nilable(T.anything)) }
+        private def resolve_variant(value)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ===(other)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def ==(other)
+        end
+
+        sig { returns(Integer) }
+        def hash
+        end
+
+        # @api private
+        #
+        # Tries to efficiently coerce the given value to one of the known variants.
+        #
+        # If the value cannot match any of the known variants, the coercion is considered
+        # non-viable and returns the original value.
+        sig do
+          override
+            .params(
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::CoerceState
+            )
+            .returns(T.anything)
+        end
+        def coerce(value, state:)
+        end
+
+        # @api private
+        sig do
+          override
+            .params(
+              value: T.anything,
+              state: XTwitterScraper::Internal::Type::Converter::DumpState
+            )
+            .returns(T.anything)
+        end
+        def dump(value, state:)
+        end
+
+        # @api private
+        sig { returns(T.anything) }
+        def to_sorbet_type
+        end
+
+        # @api private
+        sig { params(depth: Integer).returns(String) }
+        def inspect(depth: 0)
+        end
+      end
+    end
+  end
+end

data/rbi/x_twitter_scraper/internal/type/unknown.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module XTwitterScraper
+  module Internal
+    module Type
+      # @api private
+      #
+      # When we don't know what to expect for the value.
+      class Unknown
+        extend XTwitterScraper::Internal::Type::Converter
+        extend XTwitterScraper::Internal::Util::SorbetRuntimeSupport
+
+        abstract!
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def self.===(other)
+        end
+
+        sig { params(other: T.anything).returns(T::Boolean) }
+        def self.==(other)
+        end
+
+        class << self
+          # @api private
+          #
+          # No coercion needed for Unknown type.
+          sig do
+            override
+              .params(
+                value: T.anything,
+                state: XTwitterScraper::Internal::Type::Converter::CoerceState
+              )
+              .returns(T.anything)
+          end
+          def coerce(value, state:)
+          end
+
+          # @api private
+          sig do
+            override
+              .params(
+                value: T.anything,
+                state: XTwitterScraper::Internal::Type::Converter::DumpState
+              )
+              .returns(T.anything)
+          end
+          def dump(value, state:)
+          end
+
+          # @api private
+          sig { returns(T.anything) }
+          def to_sorbet_type
+          end
+        end
+      end
+    end
+  end
+end