def get_updates_for_inclusions()

in src/core/src/package_managers/PackageManager.py [0:0]

• 36 lines of code
• 14 McCabe index (conditional complexity)

    def get_updates_for_inclusions(self, package_filter):
        """Get missing updates for inclusions"""
        self.composite_logger.log_verbose("[PM] Checking for inclusions...")

        # Trivial empty list cases
        if not package_filter.is_inclusion_list_present():
            self.composite_logger.log_verbose("[PM]  > No inclusion list was present.")
            return [], []
        if package_filter.is_msft_all_classification_included():  # remember that this function is inclusion-list aware if you suspect there's a bug here
            self.composite_logger.log_verbose("[PM]  > Inclusion list was present, but all classifications were selected - inclusions are irrelevant and will be ignored.")
            return [], []

        # Get all available updates
        self.composite_logger.log_verbose("[PM] Getting all available updates for filtering...")
        packages, package_versions = self.get_all_updates(True)  # if a cached version is available, that is fine here
        included_packages = []
        included_package_versions = []
        not_included_packages = []

        # Check for inclusions
        for index, package in enumerate(packages):
            if package_filter.check_for_inclusion(package, package_versions[index]):    # check for the latest version
                self.composite_logger.log_debug("[PM] > Package satisfied inclusion list: " + str(package) + " (version=" + package_versions[index] + ")")
                included_packages.append(package)
                included_package_versions.append(package_versions[index])

            elif package_filter.check_for_inclusion(package):                           # check for all available versions
                available_versions = self.get_all_available_versions_of_package(package)
                matched = False
                for available_version in available_versions:
                    if not package_filter.check_for_inclusion(package, available_version):
                        continue
                    self.composite_logger.log_debug("[PM] > Package satisfied inclusion list: " + str(package) + " (version=" + available_version + ", latest version=" + package_versions[index] + ")")
                    included_packages.append(package)
                    included_package_versions.append(available_version)
                    matched = True
                    break

                if not matched:
                    self.composite_logger.log_warning("[PM] > Package [" + package + "] is available, but not the specific version requested. Available versions found: " + str(available_versions))
                    not_included_packages.append(package)

            else:                                                                       # no match
                self.composite_logger.log_verbose("[PM] > Package didn't satisfy inclusion list: " + str(package))
                not_included_packages.append(package)

        return included_packages, included_package_versions