vpndetection 1.0.0

data/lib/vpndetection/errors.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module VPNDetection
+  # Everything this library raises.
+  #
+  # `:rate_limited` and `:quota_exceeded` both arrive as HTTP 429 and are NOT the
+  # same thing. A rate limit is the API protecting itself and carries
+  # `Retry-After`; retrying works. A spent quota carries no such header and
+  # retrying will not help until the window rolls over or the limit is raised.
+  # The header is the only thing that distinguishes them.
+  class Error < StandardError
+    KINDS = %i[
+      bad_request unauthorized forbidden rate_limited quota_exceeded server_error network
+    ].freeze
+
+    RETRYABLE = %i[rate_limited server_error network].freeze
+
+    attr_reader :kind, :status, :retry_after_seconds
+
+    def initialize(kind, message, status: nil, retry_after_seconds: nil)
+      super(message)
+      @kind = kind
+      @status = status
+      @retry_after_seconds = retry_after_seconds
+    end
+
+    # Whether retrying this exact request could succeed.
+    def retryable?
+      RETRYABLE.include?(@kind)
+    end
+
+    # `message:` stands in for the response body, for a response whose body must
+    # not be read: an object storage error page has no bounded size, so a refusal
+    # from it is classified on the status alone.
+    def self.from_status(status, headers, body, message: nil)
+      message ||= message_of(body) || "request failed with status #{status}"
+      retry_after = parse_retry_after(header(headers, 'retry-after'))
+
+      case status
+      when 429
+        # Present means transient, absent means an allowance is spent. Nothing
+        # else in the response separates the two.
+        if retry_after.nil?
+          new(:quota_exceeded, message, status: status)
+        else
+          new(:rate_limited, message, status: status, retry_after_seconds: retry_after)
+        end
+      when 400 then new(:bad_request, message, status: status)
+      when 401 then new(:unauthorized, message, status: status)
+      when 403 then new(:forbidden, message, status: status)
+      # Every other 4xx is a CLIENT error. Classifying on the RANGE rather than
+      # on an enumerated list is what keeps a 404 from a bad dataset id falling
+      # through to the retryable server_error default and being retried twice
+      # before it fails.
+      when 400..499 then new(:bad_request, message, status: status)
+      else new(:server_error, message, status: status)
+      end
+    end
+
+    # A Typhoeus response that never carried an HTTP status: DNS failure,
+    # connection refused, TLS failure, or a timeout.
+    def self.from_transport(response)
+      message = response.return_message || response.return_code&.to_s || 'transport failure'
+      new(:network, message)
+    end
+
+    # Case-insensitive, and works with a plain Hash as well as with the
+    # case-blind header object Typhoeus builds from a live response.
+    def self.header(headers, name)
+      return nil if headers.nil?
+
+      value = headers[name] || headers[name.split('-').map(&:capitalize).join('-')]
+      value = headers.find { |k, _| k.to_s.downcase == name }&.last if value.nil?
+      value.is_a?(Array) ? value.last : value
+    end
+
+    # The two APIs behind this host answer with different envelopes: the lookup
+    # endpoint uses `error`, the database endpoints use `rc`. Both are read here
+    # so a caller never has to know which one they hit. An intermediary's HTML
+    # error page parses as neither and leaves the status to speak for itself.
+    def self.message_of(body)
+      parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+      return nil unless parsed.is_a?(Hash)
+
+      message = parsed['error'] || parsed['rc']
+      message.is_a?(String) ? message : nil
+    end
+
+    def self.parse_retry_after(value)
+      return nil if value.nil? || value.to_s.strip.empty?
+
+      seconds = Float(value, exception: false)
+      return seconds if seconds && seconds >= 0
+
+      # The header also permits an HTTP date.
+      when_at = Time.httpdate(value) rescue nil
+      return nil if when_at.nil?
+
+      [0, (when_at - Time.now).ceil].max
+    end
+
+    private_class_method :header, :message_of, :parse_retry_after
+  end
+end

data/lib/vpndetection/models/class_detail.rb

@@ -0,0 +1,169 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the datasets behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.04
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  # The shared detail shape for the hosting, relay, tor and cdn datasets. Every key is present when the object is populated; the object is `{}` when its flag is false. 
+  class ClassDetail < ApiModelBase
+    # The provider, or an empty string where the dataset has none.
+    attr_accessor :provider
+
+    # How strongly the classification is supported.
+    attr_accessor :confidence
+
+    # The most recent date this address was observed in this dataset.
+    attr_accessor :last_seen
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'provider' => :'provider',
+        :'confidence' => :'confidence',
+        :'last_seen' => :'last_seen'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'provider' => :'String',
+        :'confidence' => :'String',
+        :'last_seen' => :'Date'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::ClassDetail` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::ClassDetail`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'provider')
+        self.provider = attributes[:'provider']
+      end
+
+      if attributes.key?(:'confidence')
+        self.confidence = attributes[:'confidence']
+      end
+
+      if attributes.key?(:'last_seen')
+        self.last_seen = attributes[:'last_seen']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          provider == o.provider &&
+          confidence == o.confidence &&
+          last_seen == o.last_seen
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [provider, confidence, last_seen].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/vpndetection/models/dataset_checksums.rb

@@ -0,0 +1,174 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the datasets behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.04
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class DatasetChecksums < ApiModelBase
+    attr_accessor :md5
+
+    attr_accessor :sha1
+
+    attr_accessor :sha256
+
+    attr_accessor :sha512
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'md5' => :'md5',
+        :'sha1' => :'sha1',
+        :'sha256' => :'sha256',
+        :'sha512' => :'sha512'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'md5' => :'String',
+        :'sha1' => :'String',
+        :'sha256' => :'String',
+        :'sha512' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::DatasetChecksums` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::DatasetChecksums`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'md5')
+        self.md5 = attributes[:'md5']
+      end
+
+      if attributes.key?(:'sha1')
+        self.sha1 = attributes[:'sha1']
+      end
+
+      if attributes.key?(:'sha256')
+        self.sha256 = attributes[:'sha256']
+      end
+
+      if attributes.key?(:'sha512')
+        self.sha512 = attributes[:'sha512']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          md5 == o.md5 &&
+          sha1 == o.sha1 &&
+          sha256 == o.sha256 &&
+          sha512 == o.sha512
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [md5, sha1, sha256, sha512].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/vpndetection/models/dataset_checksums_response.rb

@@ -0,0 +1,216 @@
+=begin
+#VPNDetection API
+
+#The VPNDetection API: classify any IP address, and download the datasets behind the answers.  See https://docs.vpndetection.io for guides and https://github.com/vpndetection-io for the official client libraries. 
+
+The version of the OpenAPI document: 2026.09.04
+Contact: support@vpndetection.io
+Generated by: https://openapi-generator.tech
+Generator version: 7.25.0
+
+=end
+
+require 'date'
+require 'time'
+
+module VPNDetection
+  class DatasetChecksumsResponse < ApiModelBase
+    attr_accessor :id
+
+    attr_accessor :format
+
+    attr_accessor :checksums
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'format' => :'format',
+        :'checksums' => :'checksums'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'String',
+        :'format' => :'String',
+        :'checksums' => :'DatasetChecksums'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `VPNDetection::DatasetChecksumsResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `VPNDetection::DatasetChecksumsResponse`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
+      else
+        self.id = nil
+      end
+
+      if attributes.key?(:'format')
+        self.format = attributes[:'format']
+      else
+        self.format = nil
+      end
+
+      if attributes.key?(:'checksums')
+        self.checksums = attributes[:'checksums']
+      else
+        self.checksums = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @id.nil?
+        invalid_properties.push('invalid value for "id", id cannot be nil.')
+      end
+
+      if @format.nil?
+        invalid_properties.push('invalid value for "format", format cannot be nil.')
+      end
+
+      if @checksums.nil?
+        invalid_properties.push('invalid value for "checksums", checksums cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @id.nil?
+      return false if @format.nil?
+      return false if @checksums.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] id Value to be assigned
+    def id=(id)
+      if id.nil?
+        fail ArgumentError, 'id cannot be nil'
+      end
+
+      @id = id
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] format Value to be assigned
+    def format=(format)
+      if format.nil?
+        fail ArgumentError, 'format cannot be nil'
+      end
+
+      @format = format
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] checksums Value to be assigned
+    def checksums=(checksums)
+      if checksums.nil?
+        fail ArgumentError, 'checksums cannot be nil'
+      end
+
+      @checksums = checksums
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          id == o.id &&
+          format == o.format &&
+          checksums == o.checksums
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [id, format, checksums].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end