dependabot-uv 0.349.0 → 0.351.0

data/lib/dependabot/uv/package.rb

@@ -0,0 +1,27 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require "dependabot/python/package/package_registry_finder"
+require "dependabot/python/package/package_details_fetcher"
+
+module Dependabot
+  module Uv
+    # UV uses the same Python package registry handling (PyPI)
+    module Package
+      # Re-export constants from Python::Package for backward compatibility
+      CREDENTIALS_USERNAME = Python::Package::CREDENTIALS_USERNAME
+      CREDENTIALS_PASSWORD = Python::Package::CREDENTIALS_PASSWORD
+      APPLICATION_JSON = Python::Package::APPLICATION_JSON
+      APPLICATION_TEXT = Python::Package::APPLICATION_TEXT
+      CPYTHON = Python::Package::CPYTHON
+      PYTHON = Python::Package::PYTHON
+      UNKNOWN = Python::Package::UNKNOWN
+      MAIN_PYPI_INDEXES = Python::Package::MAIN_PYPI_INDEXES
+      VERSION_REGEX = Python::Package::VERSION_REGEX
+
+      PackageRegistryFinder = Dependabot::Python::Package::PackageRegistryFinder
+      PackageDetailsFetcher = Dependabot::Python::Package::PackageDetailsFetcher
+    end
+  end
+end

data/lib/dependabot/uv/requirement.rb

@@ -1,206 +1,14 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-
-require "dependabot/requirement"
+require "dependabot/python/requirement"
 require "dependabot/utils"
-require "dependabot/uv/version"
 
 module Dependabot
   module Uv
-    class Requirement < Dependabot::Requirement
-      extend T::Sig
-
-      OR_SEPARATOR = T.let(/(?<=[a-zA-Z0-9)*])\s*\|+/, Regexp)
-
-      # Add equality and arbitrary-equality matchers
-      OPS = T.let(
-        OPS.merge(
-          "==" => ->(v, r) { v == r },
-          "===" => ->(v, r) { v.to_s == r.to_s }
-        ),
-        T::Hash[String, T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped)]
-      )
-
-      quoted = OPS.keys.sort_by(&:length).reverse
-                  .map { |k| Regexp.quote(k) }.join("|")
-      version_pattern = Uv::Version::VERSION_PATTERN
-
-      PATTERN_RAW = T.let("\\s*(?<op>#{quoted})?\\s*(?<version>#{version_pattern})\\s*".freeze, String)
-      PATTERN = T.let(/\A#{PATTERN_RAW}\z/, Regexp)
-      PARENS_PATTERN = T.let(/\A\(([^)]+)\)\z/, Regexp)
-
-      sig { params(obj: T.any(Gem::Version, String)).returns([String, Gem::Version]) }
-      def self.parse(obj)
-        return ["=", Uv::Version.new(obj.to_s)] if obj.is_a?(Gem::Version)
-
-        line = obj.to_s
-        if (matches = PARENS_PATTERN.match(line))
-          line = matches[1]
-        end
-
-        unless (matches = PATTERN.match(line))
-          msg = "Illformed requirement [#{obj.inspect}]"
-          raise BadRequirementError, msg
-        end
-
-        return DefaultRequirement if matches[:op] == ">=" && matches[:version] == "0"
-
-        [matches[:op] || "=", Uv::Version.new(T.must(matches[:version]))]
-      end
-
-      # Returns an array of requirements. At least one requirement from the
-      # returned array must be satisfied for a version to be valid.
-      #
-      # NOTE: Or requirements are only valid for Poetry.
-      sig { override.params(requirement_string: T.nilable(String)).returns(T::Array[Requirement]) }
-      def self.requirements_array(requirement_string)
-        return [new(nil)] if requirement_string.nil?
-
-        if (matches = PARENS_PATTERN.match(requirement_string))
-          requirement_string = matches[1]
-        end
-
-        T.must(requirement_string).strip.split(OR_SEPARATOR).map do |req_string|
-          new(req_string.strip)
-        end
-      end
-
-      sig { params(requirements: T.nilable(T.any(String, T::Array[String]))).void }
-      def initialize(*requirements)
-        requirements = requirements.flatten.flat_map do |req_string|
-          next if req_string.nil?
-
-          # Standard python doesn't support whitespace in requirements, but Poetry does.
-          req_string = req_string.gsub(/(\d +)([<=>])/, '\1,\2')
-
-          req_string.split(",").map(&:strip).map do |r|
-            convert_python_constraint_to_ruby_constraint(r)
-          end
-        end
-
-        super(requirements)
-      end
-
-      sig { params(version: T.any(Gem::Version, String)).returns(T::Boolean) }
-      def satisfied_by?(version)
-        version = Uv::Version.new(version.to_s)
-
-        requirements.all? { |op, rv| T.must(OPS[op] || OPS["="]).call(version, rv) }
-      end
-
-      sig { returns(T::Boolean) }
-      def exact?
-        return false unless requirements.size == 1
-
-        %w(= == ===).include?(requirements[0][0])
-      end
-
-      private
-
-      sig { params(req_string: T.nilable(String)).returns(T.nilable(T.any(String, T::Array[String]))) }
-      def convert_python_constraint_to_ruby_constraint(req_string)
-        return nil if req_string.nil? || req_string.strip.empty?
-        return nil if req_string == "*"
-
-        req_string = req_string.gsub("~=", "~>")
-        req_string = req_string.gsub(/(?<=\d)[<=>].*\Z/, "")
-
-        if req_string.match?(/~[^>]/) then convert_tilde_req(req_string)
-        elsif req_string.start_with?("^") then convert_caret_req(req_string)
-        elsif req_string.match?(/^=?={0,2}\s*\d+\.\d+(\.\d+)?(-[a-z0-9.-]+)?(\.\*)?$/i)
-          convert_exact(req_string)
-        elsif req_string.include?(".*") then convert_wildcard(req_string)
-        else
-          req_string
-        end
-      end
-
-      # Poetry uses ~ requirements.
-      # https://github.com/sdispater/poetry#tilde-requirements
-      sig { params(req_string: String).returns(String) }
-      def convert_tilde_req(req_string)
-        version = req_string.gsub(/^~\>?/, "")
-        parts = version.split(".")
-        parts << "0" if parts.count < 3
-        "~> #{parts.join('.')}"
-      end
-
-      # Poetry uses ^ requirements
-      # https://github.com/sdispater/poetry#caret-requirement
-      sig { params(req_string: String).returns(T::Array[String]) }
-      def convert_caret_req(req_string)
-        version = req_string.gsub(/^\^/, "")
-        parts = version.split(".")
-        parts.fill("0", parts.length...3)
-        first_non_zero = parts.find { |d| d != "0" }
-        first_non_zero_index =
-          first_non_zero ? parts.index(first_non_zero) : parts.count - 1
-        upper_bound = parts.map.with_index do |part, i|
-          if i < T.must(first_non_zero_index) then part
-          elsif i == first_non_zero_index then (part.to_i + 1).to_s
-          # .dev has lowest precedence: https://packaging.python.org/en/latest/specifications/version-specifiers/#summary-of-permitted-suffixes-and-relative-ordering
-          elsif i > T.must(first_non_zero_index) && i == 2 then "0.dev"
-          else
-            "0"
-          end
-        end.join(".")
-
-        [">= #{version}", "< #{upper_bound}"]
-      end
-
-      sig { params(req_string: String).returns(String) }
-      def convert_wildcard(req_string)
-        # NOTE: This isn't perfect. It replaces the "!= 1.0.*" case with
-        # "!= 1.0.0". There's no way to model this correctly in Ruby :'(
-        quoted_ops = OPS.keys.sort_by(&:length).reverse
-                        .map { |k| Regexp.quote(k) }.join("|")
-        op_match = req_string.match(/\A\s*(#{quoted_ops})?/)
-        op = op_match&.captures&.first.to_s.strip
-        exact_op = ["", "=", "==", "==="].include?(op)
-
-        req_string.strip
-                  .split(".")
-                  .first(T.must(req_string.split(".").index { |s| s.include?("*") }) + 1)
-                  .join(".")
-                  .gsub(/\*(?!$)/, "0")
-                  .gsub(/\*$/, "0.dev")
-                  .tap { |s| exact_op ? s.gsub!(/^(?<!!)=*/, "~>") : s }
-      end
-
-      sig { params(req_string: String).returns(T.any(String, T::Array[String])) }
-      def convert_exact(req_string)
-        arbitrary_equality = req_string.start_with?("===")
-        cleaned_version = req_string.gsub(/^=+/, "").strip
-
-        return ["=== #{cleaned_version}"] if arbitrary_equality
-
-        # Handle versions wildcarded with .*, e.g. 1.0.*
-        if cleaned_version.include?(".*")
-          # Remove all characters after the first .*, and the .*
-          cleaned_version = cleaned_version.split(".*").first
-          version = Version.new(cleaned_version)
-          # Get the release segment parts [major, minor, patch]
-          version_parts = version.release_segment
-
-          if version_parts.length == 1
-            major = T.must(version_parts[0])
-            [">= #{major}.0.0.dev", "< #{major + 1}.0.0"]
-          elsif version_parts.length == 2
-            major, minor = version_parts
-            "~> #{major}.#{minor}.0.dev"
-          elsif version_parts.length == 3
-            major, minor, patch = version_parts
-            "~> #{major}.#{minor}.#{patch}.dev"
-          else
-            "= #{cleaned_version}"
-          end
-        else
-          "= #{cleaned_version}"
-        end
-      end
-    end
+    # UV uses Python's requirement scheme, so we delegate to Python::Requirement
+    Requirement = Dependabot::Python::Requirement
   end
 end
 

data/lib/dependabot/uv/requirement_parser.rb

@@ -1,60 +1,12 @@
 # typed: strong
 # frozen_string_literal: true
 
+require "sorbet-runtime"
+require "dependabot/python/requirement_parser"
+
 module Dependabot
   module Uv
-    class RequirementParser
-      NAME = /[a-zA-Z0-9](?:[a-zA-Z0-9\-_\.]*[a-zA-Z0-9])?/
-      EXTRA = /[a-zA-Z0-9\-_\.]+/
-      COMPARISON = /===|==|>=|<=|<|>|~=|!=/
-      VERSION = /([1-9][0-9]*!)?[0-9]+[a-zA-Z0-9\-_.*]*(\+[0-9a-zA-Z]+(\.[0-9a-zA-Z]+)*)?/
-
-      REQUIREMENT = /(?<comparison>#{COMPARISON})\s*\\?\s*v?(?<version>#{VERSION})/
-      HASH = /--hash=(?<algorithm>.*?):(?<hash>.*?)(?=\s|\\|$)/
-      REQUIREMENTS = /#{REQUIREMENT}(\s*,\s*\\?\s*#{REQUIREMENT})*/
-      HASHES = /#{HASH}(\s*\\?\s*#{HASH})*/
-      MARKER_OP = /\s*(#{COMPARISON}|(\s*in)|(\s*not\s*in))/
-      PYTHON_STR_C = %r{[a-zA-Z0-9\s\(\)\.\{\}\-_\*#:;/\?\[\]!~`@\$%\^&=\+\|<>]}
-      PYTHON_STR = /('(#{PYTHON_STR_C}|")*'|"(#{PYTHON_STR_C}|')*")/
-      ENV_VAR =
-        /python_version|python_full_version|os_name|sys_platform|
-         platform_release|platform_system|platform_version|platform_machine|
-         platform_python_implementation|implementation_name|
-         implementation_version/
-      MARKER_VAR = /\s*(#{ENV_VAR}|#{PYTHON_STR})/
-      MARKER_EXPR_ONE = /#{MARKER_VAR}#{MARKER_OP}#{MARKER_VAR}/
-      MARKER_EXPR = /(#{MARKER_EXPR_ONE}|\(\s*|\s*\)|\s+and\s+|\s+or\s+)+/
-
-      INSTALL_REQ_WITH_REQUIREMENT =
-        /\s*\\?\s*(?<name>#{NAME})
-          \s*\\?\s*(\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-          \s*\\?\s*\(?(?<requirements>#{REQUIREMENTS})\)?
-          \s*\\?\s*(;\s*(?<markers>#{MARKER_EXPR}))?
-          \s*\\?\s*(?<hashes>#{HASHES})?
-          \s*#*\s*(?<comment>.+)?
-        /x
-
-      INSTALL_REQ_WITHOUT_REQUIREMENT =
-        /^\s*\\?\s*(?<name>#{NAME})
-          \s*\\?\s*(\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-          \s*\\?\s*(;\s*(?<markers>#{MARKER_EXPR}))?
-          \s*\\?\s*(?<hashes>#{HASHES})?
-          \s*#*\s*(?<comment>.+)?$
-        /x
-
-      VALID_REQ_TXT_REQUIREMENT =
-        /^\s*\\?\s*(?<name>#{NAME})
-          \s*\\?\s*(\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-          \s*\\?\s*\(?(?<requirements>#{REQUIREMENTS})?\)?
-          \s*\\?\s*(;\s*(?<markers>#{MARKER_EXPR}))?
-          \s*\\?\s*(?<hashes>#{HASHES})?
-          \s*(\#+\s*(?<comment>.*))?$
-        /x
-
-      NAME_WITH_EXTRAS =
-        /\s*\\?\s*(?<name>#{NAME})
-          (\s*\\?\s*\[\s*(?<extras>#{EXTRA}(\s*,\s*#{EXTRA})*)\s*\])?
-        /x
-    end
+    # UV uses the same Python requirement parsing regex patterns (PEP 508)
+    RequirementParser = Dependabot::Python::RequirementParser
   end
 end

data/lib/dependabot/uv/update_checker/latest_version_finder.rb

@@ -1,24 +1,15 @@
 # typed: strong
 # frozen_string_literal: true
 
-require "cgi"
-require "excon"
-require "nokogiri"
 require "sorbet-runtime"
-
-require "dependabot/dependency"
 require "dependabot/uv/update_checker"
-require "dependabot/update_checkers/version_filters"
-require "dependabot/registry_client"
-require "dependabot/uv/authed_url_builder"
-require "dependabot/uv/name_normaliser"
-require "dependabot/uv/package/package_registry_finder"
-require "dependabot/uv/package/package_details_fetcher"
+require "dependabot/uv/package"
 require "dependabot/package/package_latest_version_finder"
 
 module Dependabot
   module Uv
     class UpdateChecker
+      # UV uses the same PyPI registry for package lookups as Python
       class LatestVersionFinder < Dependabot::Package::PackageLatestVersionFinder
         extend T::Sig
 
@@ -26,11 +17,14 @@ module Dependabot
           override.returns(T.nilable(Dependabot::Package::PackageDetails))
         end
         def package_details
-          @package_details ||= Package::PackageDetailsFetcher.new(
-            dependency: dependency,
-            dependency_files: dependency_files,
-            credentials: credentials
-          ).fetch
+          @package_details ||= T.let(
+            Package::PackageDetailsFetcher.new(
+              dependency: dependency,
+              dependency_files: dependency_files,
+              credentials: credentials
+            ).fetch,
+            T.nilable(Dependabot::Package::PackageDetails)
+          )
         end
 
         sig { override.returns(T::Boolean) }

data/lib/dependabot/uv/version.rb

@@ -1,331 +1,14 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-
-require "dependabot/version"
+require "dependabot/python/version"
 require "dependabot/utils"
 
-# See https://packaging.python.org/en/latest/specifications/version-specifiers for spec details.
-
 module Dependabot
   module Uv
-    class Version < Dependabot::Version
-      extend T::Sig
-
-      sig { returns(Integer) }
-      attr_reader :epoch
-
-      sig { returns(T::Array[Integer]) }
-      attr_reader :release_segment
-
-      sig { returns(T.nilable(T::Array[T.any(String, Integer)])) }
-      attr_reader :dev
-
-      sig { returns(T.nilable(T::Array[T.any(String, Integer)])) }
-      attr_reader :pre
-
-      sig { returns(T.nilable(T::Array[T.any(String, Integer)])) }
-      attr_reader :post
-
-      sig { returns(T.nilable(T::Array[T.any(String, Integer)])) }
-      attr_reader :local
-
-      INFINITY = T.let(1000, Integer)
-      NEGATIVE_INFINITY = T.let(-INFINITY, Integer)
-
-      # See https://peps.python.org/pep-0440/#appendix-b-parsing-version-strings-with-regular-expressions
-      VERSION_PATTERN = /
-        v?
-        (?:
-          (?:(?<epoch>[0-9]+)!)?                          # epoch
-          (?<release>[0-9]+(?:\.[0-9]+)*)                 # release
-          (?<pre>                                         # prerelease
-            [-_\.]?
-            (?<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?<pre_n>[0-9]+)?
-          )?
-          (?<post>                                        # post release
-            (?:-(?<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?<post_l>post|rev|r)
-                [-_\.]?
-                (?<post_n2>[0-9]+)?
-            )
-          )?
-          (?<dev>                                          # dev release
-            [-_\.]?
-            (?<dev_l>dev)
-            [-_\.]?
-            (?<dev_n>[0-9]+)?
-          )?
-        )
-        (?:\+(?<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?    # local version
-      /ix
-
-      ANCHORED_VERSION_PATTERN = /\A\s*#{VERSION_PATTERN}\s*\z/
-
-      sig { override.params(version: VersionParameter).returns(T::Boolean) }
-      def self.correct?(version)
-        return false if version.nil?
-
-        version.to_s.match?(ANCHORED_VERSION_PATTERN)
-      end
-
-      sig { override.params(version: VersionParameter).void }
-      def initialize(version) # rubocop:disable Metrics/AbcSize
-        raise Dependabot::BadRequirementError, "Malformed version string - string is nil" if version.nil?
-
-        @version_string = T.let(version.to_s, String)
-
-        raise Dependabot::BadRequirementError, "Malformed version string - string is empty" if @version_string.empty?
-
-        matches = ANCHORED_VERSION_PATTERN.match(@version_string.downcase)
-
-        unless matches
-          raise Dependabot::BadRequirementError,
-                "Malformed version string - #{@version_string} does not match regex"
-        end
-
-        @epoch = T.let(matches["epoch"].to_i, Integer)
-        @release_segment = T.let(matches["release"]&.split(".")&.map(&:to_i) || [], T::Array[Integer])
-        @pre = T.let(
-          parse_letter_version(matches["pre_l"], matches["pre_n"]),
-          T.nilable(T::Array[T.any(String, Integer)])
-        )
-        @post = T.let(
-          parse_letter_version(matches["post_l"], matches["post_n1"] || matches["post_n2"]),
-          T.nilable(T::Array[T.any(String, Integer)])
-        )
-        @dev = T.let(
-          parse_letter_version(matches["dev_l"], matches["dev_n"]),
-          T.nilable(T::Array[T.any(String, Integer)])
-        )
-        @local = T.let(parse_local_version(matches["local"]), T.nilable(T::Array[T.any(String, Integer)]))
-        super(matches["release"] || "")
-      end
-
-      sig { override.params(version: VersionParameter).returns(Dependabot::Uv::Version) }
-      def self.new(version)
-        T.cast(super, Dependabot::Uv::Version)
-      end
-
-      sig { returns(String) }
-      def to_s
-        @version_string
-      end
-
-      sig { returns(String) }
-      def inspect # :nodoc:
-        "#<#{self.class} #{@version_string}>"
-      end
-
-      sig { returns(T::Boolean) }
-      def prerelease?
-        !!(pre || dev)
-      end
-
-      sig { returns(Dependabot::Uv::Version) }
-      def release
-        Dependabot::Uv::Version.new(release_segment.join("."))
-      end
-
-      sig { params(other: VersionParameter).returns(Integer) }
-      def <=>(other)
-        other = Dependabot::Uv::Version.new(other.to_s) unless other.is_a?(Dependabot::Uv::Version)
-
-        epoch_comparison = epoch <=> other.epoch
-        return epoch_comparison unless epoch_comparison.zero?
-
-        release_comparison = release_version_comparison(other)
-        return release_comparison unless release_comparison.zero?
-
-        pre_comparison = compare_keys(pre_cmp_key, other.pre_cmp_key)
-        return pre_comparison unless pre_comparison.zero?
-
-        post_comparison = compare_keys(post_cmp_key, other.post_cmp_key)
-        return post_comparison unless post_comparison.zero?
-
-        dev_comparison = compare_keys(dev_cmp_key, other.dev_cmp_key)
-        return dev_comparison unless dev_comparison.zero?
-
-        compare_keys(local_cmp_key, other.local_cmp_key)
-      end
-
-      sig do
-        params(
-          key: T.any(Integer, T::Array[T.any(String, Integer)]),
-          other_key: T.any(Integer, T::Array[T.any(String, Integer)])
-        ).returns(Integer)
-      end
-      def compare_keys(key, other_key)
-        if key.is_a?(Integer) && other_key.is_a?(Integer)
-          key <=> other_key
-        elsif key.is_a?(Array) && other_key.is_a?(Array)
-          key <=> other_key
-        elsif key.is_a?(Integer)
-          key == NEGATIVE_INFINITY ? -1 : 1
-        elsif other_key.is_a?(Integer)
-          other_key == NEGATIVE_INFINITY ? 1 : -1
-        end
-      end
-
-      sig { returns(T.any(Integer, T::Array[T.any(String, Integer)])) }
-      def pre_cmp_key
-        if pre.nil? && post.nil? && dev # sort 1.0.dev0 before 1.0a0
-          NEGATIVE_INFINITY
-        elsif pre.nil?
-          INFINITY # versions without a pre-release should sort after those with one.
-        else
-          T.must(pre)
-        end
-      end
-
-      sig { returns(T.any(Integer, T::Array[T.any(String, Integer)])) }
-      def local_cmp_key
-        if local.nil?
-          # Versions without a local segment should sort before those with one.
-          NEGATIVE_INFINITY
-        else
-          # According to PEP440.
-          # - Alphanumeric segments sort before numeric segments
-          # - Alphanumeric segments sort lexicographically
-          # - Numeric segments sort numerically
-          # - Shorter versions sort before longer versions when the prefixes match exactly
-          T.must(local).map do |token|
-            if token.is_a?(Integer)
-              [token, ""]
-            else
-              [NEGATIVE_INFINITY, token]
-            end
-          end.flatten
-        end
-      end
-
-      sig { returns(T.any(Integer, T::Array[T.any(String, Integer)])) }
-      def post_cmp_key
-        # Versions without a post segment should sort before those with one.
-        return NEGATIVE_INFINITY if post.nil?
-
-        T.must(post)
-      end
-
-      sig { returns(T.any(Integer, T::Array[T.any(String, Integer)])) }
-      def dev_cmp_key
-        # Versions without a dev segment should sort after those with one.
-        return INFINITY if dev.nil?
-
-        T.must(dev)
-      end
-
-      sig { returns(String) }
-      def lowest_prerelease_suffix
-        "dev0"
-      end
-
-      sig { override.returns(T::Array[String]) }
-      def ignored_patch_versions
-        parts = release_segment # e.g [1,2,3] if version is 1.2.3-alpha3
-        version_parts = parts.fill(0, parts.length...2)
-        upper_parts = version_parts.first(1) + [version_parts[1].to_i + 1] + [lowest_prerelease_suffix]
-        lower_bound = "> #{self}"
-        upper_bound = "< #{upper_parts.join('.')}"
-
-        ["#{lower_bound}, #{upper_bound}"]
-      end
-
-      sig { override.returns(T::Array[String]) }
-      def ignored_minor_versions
-        parts = release_segment # e.g [1,2,3] if version is 1.2.3-alpha3
-        version_parts = parts.fill(0, parts.length...2)
-        lower_parts = version_parts.first(1) + [version_parts[1].to_i + 1] + [lowest_prerelease_suffix]
-        upper_parts = version_parts.first(0) + [version_parts[0].to_i + 1] + [lowest_prerelease_suffix]
-        lower_bound = ">= #{lower_parts.join('.')}"
-        upper_bound = "< #{upper_parts.join('.')}"
-
-        ["#{lower_bound}, #{upper_bound}"]
-      end
-
-      sig { override.returns(T::Array[String]) }
-      def ignored_major_versions
-        version_parts = release_segment # e.g [1,2,3] if version is 1.2.3-alpha3
-        lower_parts = [version_parts[0].to_i + 1] + [lowest_prerelease_suffix] # earliest next major version prerelease
-        lower_bound = ">= #{lower_parts.join('.')}"
-
-        [lower_bound]
-      end
-
-      private
-
-      sig { params(other: Dependabot::Uv::Version).returns(Integer) }
-      def release_version_comparison(other)
-        tokens, other_tokens = pad_for_comparison(release_segment, other.release_segment)
-        tokens <=> other_tokens
-      end
-
-      sig do
-        params(
-          tokens: T::Array[Integer],
-          other_tokens: T::Array[Integer]
-        ).returns(T::Array[T::Array[Integer]])
-      end
-      def pad_for_comparison(tokens, other_tokens)
-        tokens = tokens.dup
-        other_tokens = other_tokens.dup
-
-        longer = [tokens, other_tokens].max_by(&:count)
-        shorter = [tokens, other_tokens].min_by(&:count)
-
-        difference = T.must(longer).length - T.must(shorter).length
-
-        difference.times { T.must(shorter) << 0 }
-
-        [tokens, other_tokens]
-      end
-
-      sig { params(local: T.nilable(String)).returns(T.nilable(T::Array[T.any(String, Integer)])) }
-      def parse_local_version(local)
-        return if local.nil?
-
-        # Takes a string like abc.1.twelve and turns it into ["abc", 1, "twelve"]
-        local.split(/[\._-]/).map { |s| /^\d+$/.match?(s) ? s.to_i : s }
-      end
-
-      sig do
-        params(
-          letter: T.nilable(String), number: T.nilable(String)
-        ).returns(T.nilable(T::Array[T.any(String, Integer)]))
-      end
-      def parse_letter_version(letter = nil, number = nil)
-        return if letter.nil? && number.nil?
-
-        if letter
-          # Implicit 0 for cases where prerelease has no numeral
-          number ||= 0
-
-          # Normalize alternate spellings
-          if letter == "alpha"
-            letter = "a"
-          elsif letter == "beta"
-            letter = "b"
-          elsif %w(c pre preview).include? letter
-            letter = "rc"
-          elsif %w(rev r).include? letter
-            letter = "post"
-          end
-
-          return letter, number.to_i
-        end
-
-        # Number but no letter i.e. implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        [letter, number.to_i]
-      end
-    end
+    # UV uses Python's version scheme, so we delegate to Python::Version
+    Version = Dependabot::Python::Version
   end
 end