dependabot-uv 0.299.1 → 0.301.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37479ebd370ef17d7a56b2e53b0f9e94d93608fcbafdfb98a588d23f3f61c8f7
-  data.tar.gz: d3ff78147e58cf5fe353773c9bdf6c7f920c6ae73140de722827ce3f335ba30d
+  metadata.gz: f8eea1accc31d49dda91328296fc952b9d49a1e3cfddb443772b1cd794905779
+  data.tar.gz: a6978d2a2679d009129333b785331ee903b19b5ef673bdba89d81a1b8d67473f
 SHA512:
-  metadata.gz: 413470f2e052517d9a689131997e6425bf253e13cf558a1a217b4f7322ba4cfc28e9d78436a8249e3373ef9d7531fb8b6f5480b19401fcfc61be134c334986fd
-  data.tar.gz: a8edce98cdf17c759619019ab9406c4120c67129d884da7cc7111b2d247ba426ee865e53523b75c3ecd9c5fd93eaf9944071732f37ff59111e1955ead835d556
+  metadata.gz: 5e5c87148fd6d1db52d0a5fe59b6855a2e0fa50396b6613cb01f7d9ef86845b3c191b5b3dd8188f245c1fc230617c44b8f0531bd03fb4f15b695fc60d2674ee5
+  data.tar.gz: 2802f6b46388ca8a30bebfc56cf02594eaff5cf87aed03cf0c79facf0e6f13b62b150426ea2341f636607d2e8f48e899a92724451ffca00d2397c3870ca2c01e

data/lib/dependabot/uv/file_fetcher.rb

@@ -7,7 +7,7 @@ require "sorbet-runtime"
 require "dependabot/file_fetchers"
 require "dependabot/file_fetchers/base"
 require "dependabot/uv/language_version_manager"
-require "dependabot/uv/pip_compile_file_matcher"
+require "dependabot/uv/requirements_file_matcher"
 require "dependabot/uv/requirement_parser"
 require "dependabot/uv/file_parser/pyproject_files_parser"
 require "dependabot/uv/file_parser/python_requirement_parser"
@@ -22,19 +22,24 @@ module Dependabot
       CHILD_REQUIREMENT_REGEX = /^-r\s?(?<path>.*\.(?:txt|in))/
       CONSTRAINT_REGEX = /^-c\s?(?<path>.*\.(?:txt|in))/
       DEPENDENCY_TYPES = %w(packages dev-packages).freeze
+      REQUIREMENT_FILE_PATTERNS = {
+        extensions: [".txt", ".in"],
+        filenames: ["uv.lock"]
+      }.freeze
+      MAX_FILE_SIZE = 500_000
 
       def self.required_files_in?(filenames)
-        return true if filenames.any? { |name| name.end_with?(".txt", ".in") }
+        return true if filenames.any? { |name| name.end_with?(*REQUIREMENT_FILE_PATTERNS[:extensions]) }
 
         # If there is a directory of requirements return true
         return true if filenames.include?("requirements")
 
-        # If this repo is using pyproject.toml return true
+        # If this repo is using pyproject.toml return true (uv.lock files require a pyproject.toml)
         filenames.include?("pyproject.toml")
       end
 
       def self.required_files_message
-        "Repo must contain a requirements.txt, requirements.in, or pyproject.toml" \
+        "Repo must contain a requirements.txt, uv.lock, requirements.in, or pyproject.toml" \
       end
 
       def ecosystem_versions
@@ -69,6 +74,7 @@ module Dependabot
         fetched_files += requirements_in_files
         fetched_files += requirement_files if requirements_txt_files.any?
 
+        fetched_files += uv_lock_files
         fetched_files += project_files
         fetched_files << python_version_file if python_version_file
 
@@ -125,6 +131,11 @@ module Dependabot
           child_requirement_in_files
       end
 
+      def uv_lock_files
+        req_txt_and_in_files.select { |f| f.name.end_with?("uv.lock") } +
+          child_uv_lock_files
+      end
+
       def parsed_pyproject
         raise "No pyproject.toml" unless pyproject
 
@@ -137,18 +148,8 @@ module Dependabot
         return @req_txt_and_in_files if @req_txt_and_in_files
 
         @req_txt_and_in_files = []
-
-        repo_contents
-          .select { |f| f.type == "file" }
-          .select { |f| f.name.end_with?(".txt", ".in") }
-          .reject { |f| f.size > 500_000 }
-          .map { |f| fetch_file_from_host(f.name) }
-          .select { |f| requirements_file?(f) }
-          .each { |f| @req_txt_and_in_files << f }
-
-        repo_contents
-          .select { |f| f.type == "dir" }
-          .each { |f| @req_txt_and_in_files += req_files_for_dir(f) }
+        @req_txt_and_in_files += fetch_requirement_files_from_path
+        @req_txt_and_in_files += fetch_requirement_files_from_dirs
 
         @req_txt_and_in_files
       end
@@ -158,12 +159,7 @@ module Dependabot
         relative_reqs_dir =
           requirements_dir.path.gsub(%r{^/?#{Regexp.escape(dir)}/?}, "")
 
-        repo_contents(dir: relative_reqs_dir)
-          .select { |f| f.type == "file" }
-          .select { |f| f.name.end_with?(".txt", ".in") }
-          .reject { |f| f.size > 500_000 }
-          .map { |f| fetch_file_from_host("#{relative_reqs_dir}/#{f.name}") }
-          .select { |f| requirements_file?(f) }
+        fetch_requirement_files_from_path(relative_reqs_dir)
       end
 
       def child_requirement_txt_files
@@ -174,6 +170,10 @@ module Dependabot
         child_requirement_files.select { |f| f.name.end_with?(".in") }
       end
 
+      def child_uv_lock_files
+        child_requirement_files.select { |f| f.name.end_with?("uv.lock") }
+      end
+
       def child_requirement_files
         @child_requirement_files ||=
           begin
@@ -295,7 +295,7 @@ module Dependabot
 
       def parse_requirement_path_dependencies(req_file)
         # If this is a pip-compile lockfile, rely on whatever path dependencies we found in the main manifest
-        return [] if pip_compile_file_matcher.lockfile_for_pip_compile_file?(req_file)
+        return [] if requirements_in_file_matcher.compiled_file?(req_file)
 
         uneditable_reqs =
           req_file.content
@@ -318,8 +318,38 @@ module Dependabot
         Pathname.new(path).cleanpath.to_path
       end
 
-      def pip_compile_file_matcher
-        @pip_compile_file_matcher ||= PipCompileFileMatcher.new(requirements_in_files)
+      def requirements_in_file_matcher
+        @requirements_in_file_matcher ||= RequiremenstFileMatcher.new(requirements_in_files)
+      end
+
+      def fetch_requirement_files_from_path(path = nil)
+        contents = path ? repo_contents(dir: path) : repo_contents
+        filter_requirement_files(contents, base_path: path)
+      end
+
+      def fetch_requirement_files_from_dirs
+        repo_contents
+          .select { |f| f.type == "dir" }
+          .flat_map { |dir| req_files_for_dir(dir) }
+      end
+
+      def filter_requirement_files(contents, base_path: nil)
+        contents
+          .select { |f| f.type == "file" }
+          .select { |f| file_matches_requirement_pattern?(f.name) }
+          .reject { |f| f.size > MAX_FILE_SIZE }
+          .map { |f| fetch_file_with_path(f.name, base_path) }
+          .select { |f| REQUIREMENT_FILE_PATTERNS[:filenames].include?(f.name) || requirements_file?(f) }
+      end
+
+      def file_matches_requirement_pattern?(filename)
+        REQUIREMENT_FILE_PATTERNS[:extensions].any? { |ext| filename.end_with?(ext) } ||
+          REQUIREMENT_FILE_PATTERNS[:filenames].any?(filename)
+      end
+
+      def fetch_file_with_path(filename, base_path)
+        path = base_path ? File.join(base_path, filename) : filename
+        fetch_file_from_host(path)
       end
     end
   end

data/lib/dependabot/uv/file_parser/python_requirement_parser.rb

@@ -6,7 +6,7 @@ require "open3"
 require "dependabot/errors"
 require "dependabot/shared_helpers"
 require "dependabot/uv/file_parser"
-require "dependabot/uv/pip_compile_file_matcher"
+require "dependabot/uv/requirements_file_matcher"
 require "dependabot/uv/requirement"
 
 module Dependabot
@@ -21,12 +21,10 @@ module Dependabot
 
         def user_specified_requirements
           [
-            pipfile_python_requirement,
             pyproject_python_requirement,
             pip_compile_python_requirement,
             python_version_file_version,
-            runtime_file_python_version,
-            setup_file_requirement
+            runtime_file_python_version
           ].compact
         end
 
@@ -44,18 +42,6 @@ module Dependabot
 
         private
 
-        def pipfile_python_requirement
-          return unless pipfile
-
-          parsed_pipfile = TomlRB.parse(pipfile.content)
-          requirement =
-            parsed_pipfile.dig("requires", "python_full_version") ||
-            parsed_pipfile.dig("requires", "python_version")
-          return unless requirement&.match?(/^\d/)
-
-          requirement
-        end
-
         def pyproject_python_requirement
           return unless pyproject
 
@@ -74,7 +60,7 @@ module Dependabot
 
         def pip_compile_python_requirement
           requirement_files.each do |file|
-            next unless pip_compile_file_matcher.lockfile_for_pip_compile_file?(file)
+            next unless requirements_in_file_matcher.compiled_file?(file)
 
             marker = /^# This file is autogenerated by pip-compile with [pP]ython (?<version>\d+.\d+)$/m
             match = marker.match(file.content)
@@ -112,19 +98,6 @@ module Dependabot
           file_version
         end
 
-        def setup_file_requirement
-          return unless setup_file
-
-          req = setup_file.content
-                          .match(/python_requires\s*=\s*['"](?<req>[^'"]+)['"]/)
-                          &.named_captures&.fetch("req")&.strip
-
-          requirement_class.new(req)
-          req
-        rescue Gem::Requirement::BadRequirementError
-          nil
-        end
-
         def pyenv_versions
           @pyenv_versions ||= run_command("pyenv install --list")
         end
@@ -133,8 +106,8 @@ module Dependabot
           SharedHelpers.run_shell_command(command, env: env, stderr_to_stdout: true)
         end
 
-        def pip_compile_file_matcher
-          @pip_compile_file_matcher ||= PipCompileFileMatcher.new(pip_compile_files)
+        def requirements_in_file_matcher
+          @requirements_in_file_matcher ||= RequiremenstFileMatcher.new(pip_compile_files)
         end
 
         def requirement_class
@@ -148,22 +121,10 @@ module Dependabot
           false
         end
 
-        def pipfile
-          dependency_files.find { |f| f.name == "Pipfile" }
-        end
-
-        def pipfile_lock
-          dependency_files.find { |f| f.name == "Pipfile.lock" }
-        end
-
         def pyproject
           dependency_files.find { |f| f.name == "pyproject.toml" }
         end
 
-        def setup_file
-          dependency_files.find { |f| f.name == "setup.py" }
-        end
-
         def python_version_file
           dependency_files.find { |f| f.name == ".python-version" }
         end

data/lib/dependabot/uv/file_parser.rb

@@ -11,17 +11,16 @@ require "dependabot/errors"
 require "dependabot/uv/language"
 require "dependabot/uv/native_helpers"
 require "dependabot/uv/name_normaliser"
-require "dependabot/uv/pip_compile_file_matcher"
+require "dependabot/uv/requirements_file_matcher"
 require "dependabot/uv/language_version_manager"
 require "dependabot/uv/package_manager"
+require "toml-rb"
 
 module Dependabot
   module Uv
     class FileParser < Dependabot::FileParsers::Base
       extend T::Sig
-      require_relative "file_parser/pipfile_files_parser"
       require_relative "file_parser/pyproject_files_parser"
-      require_relative "file_parser/setup_file_parser"
       require_relative "file_parser/python_requirement_parser"
 
       DEPENDENCY_GROUP_KEYS = T.let([
@@ -40,18 +39,16 @@ module Dependabot
       ).freeze
 
       # we use this placeholder version in case we are not able to detect any
-      # PIP version from shell, we are ensuring that the actual update is not blocked
+      # uv version from shell, we are ensuring that the actual update is not blocked
       # in any way if any metric collection exception start happening
       UNDETECTED_PACKAGE_MANAGER_VERSION = "0.0"
 
-      sig { override.returns(T::Array[Dependabot::Dependency]) }
+      sig { override.returns(T::Array[Dependency]) }
       def parse
-        # TODO: setup.py from external dependencies is evaluated. Provide guards before removing this.
-        raise Dependabot::UnexpectedExternalCode if @reject_external_code
-
         dependency_set = DependencySet.new
 
         dependency_set += pyproject_file_dependencies if pyproject
+        dependency_set += uv_lock_file_dependencies
         dependency_set += requirement_dependencies if requirement_files.any?
 
         dependency_set.dependencies
@@ -69,58 +66,57 @@ module Dependabot
         )
       end
 
+      # Normalize dependency names to match the PyPI index normalization
+      sig { params(name: String, extras: T::Array[String]).returns(String) }
+      def self.normalize_dependency_name(name, extras = [])
+        NameNormaliser.normalise_including_extras(name, extras)
+      end
+
       private
 
-      sig { returns(Dependabot::Uv::LanguageVersionManager) }
+      sig { returns(LanguageVersionManager) }
       def language_version_manager
         @language_version_manager ||= T.let(LanguageVersionManager.new(python_requirement_parser:
                                         python_requirement_parser), T.nilable(LanguageVersionManager))
       end
 
-      sig { returns(Dependabot::Uv::FileParser::PythonRequirementParser) }
+      sig { returns(FileParser::PythonRequirementParser) }
       def python_requirement_parser
-        @python_requirement_parser ||= T.let(FileParser::PythonRequirementParser.new(dependency_files:
-                                         dependency_files), T.nilable(FileParser::PythonRequirementParser))
+        @python_requirement_parser ||= T.let(PythonRequirementParser.new(dependency_files:
+                                         dependency_files), T.nilable(PythonRequirementParser))
       end
 
       sig { returns(Ecosystem::VersionManager) }
       def package_manager
-        if Dependabot::Experiments.enabled?(:enable_file_parser_python_local)
+        if Experiments.enabled?(:enable_file_parser_python_local)
           Dependabot.logger.info("Detected package manager : #{detected_package_manager.name}")
         end
 
-        @package_manager ||= T.let(detected_package_manager, T.nilable(Dependabot::Ecosystem::VersionManager))
+        @package_manager ||= T.let(detected_package_manager, T.nilable(Ecosystem::VersionManager))
       end
 
       sig { returns(Ecosystem::VersionManager) }
       def detected_package_manager
-        setup_python_environment if Dependabot::Experiments.enabled?(:enable_file_parser_python_local)
+        setup_python_environment if Experiments.enabled?(:enable_file_parser_python_local)
 
-        PackageManager.new(T.must(detect_pipcompile_version))
+        PackageManager.new(T.must(detect_uv_version))
       end
 
-      # Detects the version of pip-compile. If the version cannot be detected, it returns nil
       sig { returns(T.nilable(String)) }
-      def detect_pipcompile_version
-        if pipcompile_in_file
-          package_manager = PackageManager::NAME
+      def detect_uv_version
+        version = uv_version.to_s.split("version ").last&.split(")")&.first
 
-          version = package_manager_version(package_manager)
-                    .to_s.split("version ").last&.split(")")&.first
+        log_if_version_malformed("uv", version)
 
-          log_if_version_malformed(package_manager, version)
-
-          # makes sure we have correct version format returned
-          version if version&.match?(/^\d+(?:\.\d+)*$/)
-        end
+        version if version&.match?(/^\d+(?:\.\d+)*$/)
       rescue StandardError
         nil
       end
 
-      sig { params(package_manager: String).returns(T.any(String, T.untyped)) }
-      def package_manager_version(package_manager)
-        version_info = SharedHelpers.run_shell_command("pyenv exec #{package_manager} --version")
-        Dependabot.logger.info("Package manager #{package_manager}, Info : #{version_info}")
+      sig { returns(T.any(String, T.untyped)) }
+      def uv_version
+        version_info = SharedHelpers.run_shell_command("pyenv exec uv --version")
+        Dependabot.logger.info("Package manager uv, Info : #{version_info}")
 
         version_info.match(/\d+(?:\.\d+)*/)&.to_s
       rescue StandardError => e
@@ -128,7 +124,6 @@ module Dependabot
         nil
       end
 
-      # setup python local setup on file parser stage
       sig { returns(T.nilable(String)) }
       def setup_python_environment
         language_version_manager.install_required_python
@@ -141,7 +136,6 @@ module Dependabot
 
       sig { params(package_manager: String, version: String).returns(T::Boolean) }
       def log_if_version_malformed(package_manager, version)
-        # logs warning if malformed version is found
         if version.match?(/^\d+(?:\.\d+)*$/)
           true
         else
@@ -152,7 +146,7 @@ module Dependabot
 
       sig { returns(String) }
       def python_raw_version
-        if Dependabot::Experiments.enabled?(:enable_file_parser_python_local)
+        if Experiments.enabled?(:enable_file_parser_python_local)
           Dependabot.logger.info("Detected python version: #{language_version_manager.python_version}")
           Dependabot.logger.info("Detected python major minor version: #{language_version_manager.python_major_minor}")
         end
@@ -173,15 +167,39 @@ module Dependabot
         )
       end
 
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
+      sig { returns(T::Array[DependencyFile]) }
       def requirement_files
         dependency_files.select { |f| f.name.end_with?(".txt", ".in") }
       end
 
+      sig { returns(T::Array[DependencyFile]) }
+      def uv_lock_files
+        dependency_files.select { |f| f.name == "uv.lock" }
+      end
+
       sig { returns(DependencySet) }
-      def pipenv_dependencies
-        @pipenv_dependencies ||= T.let(PipfileFilesParser.new(dependency_files:
-                                    dependency_files).dependency_set, T.nilable(DependencySet))
+      def uv_lock_file_dependencies
+        dependency_set = DependencySet.new
+
+        uv_lock_files.each do |file|
+          lockfile_content = TomlRB.parse(file.content)
+          packages = lockfile_content.fetch("package", [])
+
+          packages.each do |package_data|
+            next unless package_data.is_a?(Hash) && package_data["name"] && package_data["version"]
+
+            dependency_set << Dependency.new(
+              name: normalised_name(package_data["name"]),
+              version: package_data["version"],
+              requirements: [], # Lock files don't contain requirements
+              package_manager: "uv"
+            )
+          end
+        rescue StandardError => e
+          Dependabot.logger.warn("Error parsing uv.lock: #{e.message}")
+        end
+
+        dependency_set
       end
 
       sig { returns(DependencySet) }
@@ -194,8 +212,6 @@ module Dependabot
       def requirement_dependencies
         dependencies = DependencySet.new
         parsed_requirement_files.each do |dep|
-          # If a requirement has a `<`, `<=` or '==' marker then updating it is
-          # probably blocked. Ignore it.
           next if blocking_marker?(dep)
 
           name = dep["name"]
@@ -204,7 +220,7 @@ module Dependabot
           original_file = get_original_file(file)
 
           requirements =
-            if original_file && pip_compile_file_matcher.lockfile_for_pip_compile_file?(original_file) then []
+            if original_file && requirements_in_file_matcher.compiled_file?(original_file) then []
             else
               [{
                 requirement: dep["requirement"],
@@ -214,7 +230,7 @@ module Dependabot
               }]
             end
 
-          # PyYAML < 6.0 will cause `pip-compile` to fail due to incompatibility with Cython 3. Workaround it.
+          # PyYAML < 6.0 will cause `pip-compile` to fail due to incompatibility with Cython 3. Workaround it. PR #8189
           SharedHelpers.run_shell_command("pyenv exec pip install cython<3.0") if old_pyyaml?(name, version)
 
           dependencies <<
@@ -268,7 +284,6 @@ module Dependabot
       def marker_satisfied?(marker, python_version)
         conditions = marker.split(/\s+(and|or)\s+/)
 
-        # Explicitly define the type of result as T::Boolean
         result = T.let(evaluate_condition(conditions.shift, python_version), T::Boolean)
 
         until conditions.empty?
@@ -295,26 +310,20 @@ module Dependabot
 
         case operator
         when "<"
-          Dependabot::Uv::Version.new(python_version) < Dependabot::Uv::Version.new(version)
+          Version.new(python_version) < Version.new(version)
         when "<="
-          Dependabot::Uv::Version.new(python_version) <= Dependabot::Uv::Version.new(version)
+          Version.new(python_version) <= Version.new(version)
         when ">"
-          Dependabot::Uv::Version.new(python_version) > Dependabot::Uv::Version.new(version)
+          Version.new(python_version) > Version.new(version)
         when ">="
-          Dependabot::Uv::Version.new(python_version) >= Dependabot::Uv::Version.new(version)
+          Version.new(python_version) >= Version.new(version)
         when "=="
-          Dependabot::Uv::Version.new(python_version) == Dependabot::Uv::Version.new(version)
+          Version.new(python_version) == Version.new(version)
         else
           false
         end
       end
 
-      sig { returns(DependencySet) }
-      def setup_file_dependencies
-        @setup_file_dependencies ||= T.let(SetupFileParser.new(dependency_files: dependency_files)
-                                    .dependency_set, T.nilable(DependencySet))
-      end
-
       sig { returns(T.untyped) }
       def parsed_requirement_files
         SharedHelpers.in_a_temporary_directory do
@@ -333,7 +342,7 @@ module Dependabot
         evaluation_errors = REQUIREMENT_FILE_EVALUATION_ERRORS
         raise unless e.message.start_with?(*evaluation_errors)
 
-        raise Dependabot::DependencyFileNotEvaluatable, e.message
+        raise DependencyFileNotEvaluatable, e.message
       end
 
       sig { params(requirements: T.untyped).returns(T.untyped) }
@@ -341,18 +350,13 @@ module Dependabot
         requirements.each do |dep|
           next unless dep["requirement"]
 
-          Uv::Requirement.new(dep["requirement"].split(","))
+          Requirement.new(dep["requirement"].split(","))
         rescue Gem::Requirement::BadRequirementError => e
-          raise Dependabot::DependencyFileNotEvaluatable, e.message
+          raise DependencyFileNotEvaluatable, e.message
         end
       end
 
-      sig { returns(T::Boolean) }
-      def pipcompile_in_file
-        requirement_files.any? { |f| f.name.end_with?(PackageManager::MANIFEST_FILENAME) }
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
+      sig { returns(T::Array[DependencyFile]) }
       def write_temporary_dependency_files
         dependency_files
           .reject { |f| f.name == ".python-version" }
@@ -375,60 +379,32 @@ module Dependabot
 
       sig { params(name: String, extras: T::Array[String]).returns(String) }
       def normalised_name(name, extras = [])
-        NameNormaliser.normalise_including_extras(name, extras)
+        FileParser.normalize_dependency_name(name, extras)
       end
 
       sig { override.returns(T.untyped) }
       def check_required_files
         filenames = dependency_files.map(&:name)
         return if filenames.any? { |name| name.end_with?(".txt", ".in") }
-        return if pipfile
         return if pyproject
-        return if setup_file
-        return if setup_cfg_file
 
         raise "Missing required files!"
       end
 
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def pipfile
-        @pipfile ||= T.let(get_original_file("Pipfile"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def pipfile_lock
-        @pipfile_lock ||= T.let(get_original_file("Pipfile.lock"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
+      sig { returns(T.nilable(DependencyFile)) }
       def pyproject
-        @pyproject ||= T.let(get_original_file("pyproject.toml"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def poetry_lock
-        @poetry_lock ||= T.let(get_original_file("poetry.lock"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def setup_file
-        @setup_file ||= T.let(get_original_file("setup.py"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def setup_cfg_file
-        @setup_cfg_file ||= T.let(get_original_file("setup.cfg"), T.nilable(Dependabot::DependencyFile))
+        @pyproject ||= T.let(get_original_file("pyproject.toml"), T.nilable(DependencyFile))
       end
 
-      sig { returns(T::Array[Dependabot::Uv::Requirement]) }
-      def pip_compile_files
-        @pip_compile_files ||= T.let(dependency_files.select { |f| f.name.end_with?(".in") }, T.untyped)
+      sig { returns(T::Array[Requirement]) }
+      def requirements_in_files
+        @requirements_in_files ||= T.let(dependency_files.select { |f| f.name.end_with?(".in") }, T.untyped)
       end
 
-      sig { returns(Dependabot::Uv::PipCompileFileMatcher) }
-      def pip_compile_file_matcher
-        @pip_compile_file_matcher ||= T.let(PipCompileFileMatcher.new(pip_compile_files),
-                                            T.nilable(Dependabot::Uv::PipCompileFileMatcher))
+      sig { returns(RequiremenstFileMatcher) }
+      def requirements_in_file_matcher
+        @requirements_in_file_matcher ||= T.let(RequiremenstFileMatcher.new(requirements_in_files),
+                                                T.nilable(RequiremenstFileMatcher))
       end
     end
   end