[gentoo-commits] proj/portage:master commit in: lib/_emerge/resolver/

[Zac Medico]

commit:     602d2cd487bb48788e9654a7b7fd5a3be34150d9
Author:     Aaron Bauman <bman <AT> gentoo <DOT> org>
AuthorDate: Mon Aug  3 02:53:42 2020 +0000
Commit:     Zac Medico <zmedico <AT> gentoo <DOT> org>
CommitDate: Mon Aug  3 03:07:31 2020 +0000
URL:        https://gitweb.gentoo.org/proj/portage.git/commit/?id=602d2cd4

lib/_emerge/resolver/slot_collision.py: fix redefined-builtin W0622

* This fixes the referenced warning by renaming the 'id' variable to
 'name' and the 'type' variable to 'atype'
* Additional cosmetic/style changes found along the way.

Signed-off-by: Aaron Bauman <bman <AT> gentoo.org>
Signed-off-by: Zac Medico <zmedico <AT> gentoo.org>

 lib/_emerge/resolver/slot_collision.py | 74 +++++++++++++++++-----------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/lib/_emerge/resolver/slot_collision.py b/lib/_emerge/resolver/slot_collision.py
index cc16287de..2b8f59953 100644
--- a/lib/_emerge/resolver/slot_collision.py
+++ b/lib/_emerge/resolver/slot_collision.py
@@ -591,14 +591,14 @@ class slot_conflict_handler:
 							version_violated = False
 							slot_violated = False
 							use = []
-							for (type, sub_type), parents in collision_reasons.items():
+							for (ctype, sub_type), parents in collision_reasons.items():
 								for x in parents:
 									if parent == x[0] and atom == x[1]:
-										if type == "version":
+										if ctype == "version":
 											version_violated = True
-										elif type == "slot":
+										elif ctype == "slot":
 											slot_violated = True
-										elif type == "use":
+										elif ctype == "use":
 											use.append(sub_type)
 										break
 
@@ -934,64 +934,64 @@ class slot_conflict_handler:
 				msg += "}"
 			msg += "]\n"
 			writemsg(msg, noiselevel=-1)
-		
+
 		required_changes = {}
-		for id, pkg in enumerate(config):
+		for idx, pkg in enumerate(config):
 			if not pkg.installed:
-				#We can't change the USE of installed packages.
-				for flag in all_involved_flags[id]:
+				# We can't change the USE of installed packages.
+				for flag in all_involved_flags[idx]:
 					if not pkg.iuse.is_valid_flag(flag):
 						continue
-					state = all_involved_flags[id][flag]
+					state = all_involved_flags[idx][flag]
 					self._force_flag_for_package(required_changes, pkg, flag, state)
 
-			#Go through all (parent, atom) pairs for the current slot conflict.
-			for ppkg, atom in all_conflict_atoms_by_slotatom[id]:
+			# Go through all (parent, atom) pairs for the current slot conflict.
+			for ppkg, atom in all_conflict_atoms_by_slotatom[idx]:
 				if not atom.package:
 					continue
 				use = atom.unevaluated_atom.use
 				if not use:
-					#No need to force something for an atom without USE conditionals.
-					#These atoms are already satisfied.
+					# No need to force something for an atom without USE conditionals.
+					# These atoms are already satisfied.
 					continue
-				for flag in all_involved_flags[id]:
-					state = all_involved_flags[id][flag]
+				for flag in all_involved_flags[idx]:
+					state = all_involved_flags[idx][flag]
 					
 					if flag not in use.required or not use.conditional:
 						continue
 					if flag in use.conditional.enabled:
-						#[flag?]
+						# [flag?]
 						if state == "enabled":
-							#no need to change anything, the atom won't
-							#force -flag on pkg
+							# no need to change anything, the atom won't
+							# force -flag on pkg
 							pass
 						elif state == "disabled":
-							#if flag is enabled we get [flag] -> it must be disabled
+							# if flag is enabled we get [flag] -> it must be disabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "disabled")
 					elif flag in use.conditional.disabled:
-						#[!flag?]
+						# [!flag?]
 						if state == "enabled":
-							#if flag is enabled we get [-flag] -> it must be disabled
+							# if flag is enabled we get [-flag] -> it must be disabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "disabled")
 						elif state == "disabled":
-							#no need to change anything, the atom won't
-							#force +flag on pkg
+							# no need to change anything, the atom won't
+							# force +flag on pkg
 							pass
 					elif flag in use.conditional.equal:
-						#[flag=]
+						# [flag=]
 						if state == "enabled":
-							#if flag is disabled we get [-flag] -> it must be enabled
+							# if flag is disabled we get [-flag] -> it must be enabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "enabled")
 						elif state == "disabled":
-							#if flag is enabled we get [flag] -> it must be disabled
+							# if flag is enabled we get [flag] -> it must be disabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "disabled")
 					elif flag in use.conditional.not_equal:
-						#[!flag=]
+						# [!flag=]
 						if state == "enabled":
-							#if flag is enabled we get [-flag] -> it must be disabled
+							# if flag is enabled we get [-flag] -> it must be disabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "disabled")
 						elif state == "disabled":
-							#if flag is disabled we get [flag] -> it must be enabled
+							# if flag is disabled we get [flag] -> it must be enabled
 							self._force_flag_for_package(required_changes, ppkg, flag, "enabled")
 
 		is_valid_solution = True
@@ -999,12 +999,12 @@ class slot_conflict_handler:
 			for state in required_changes[pkg].values():
 				if not state in ("enabled", "disabled"):
 					is_valid_solution = False
-		
+
 		if not is_valid_solution:
 			return None
 
-		#Check if all atoms are satisfied after the changes are applied.
-		for id, pkg in enumerate(config):
+		# Check if all atoms are satisfied after the changes are applied.
+		for idx, pkg in enumerate(config):
 			new_use = _pkg_use_enabled(pkg)
 			if pkg in required_changes:
 				old_use = pkg.use.enabled
@@ -1015,14 +1015,14 @@ class slot_conflict_handler:
 					elif state == "disabled":
 						new_use.discard(flag)
 				if not new_use.symmetric_difference(old_use):
-					#avoid copying the package in findAtomForPackage if possible
+					# avoid copying the package in findAtomForPackage if possible
 					new_use = old_use
 
-			for ppkg, atom in all_conflict_atoms_by_slotatom[id]:
+			for ppkg, atom in all_conflict_atoms_by_slotatom[idx]:
 				if not atom.package:
 					continue
 				if not hasattr(ppkg, "use"):
-					#It's a SetArg or something like that.
+					# It's a SetArg or something like that.
 					continue
 				ppkg_new_use = set(_pkg_use_enabled(ppkg))
 				if ppkg in required_changes:
@@ -1035,7 +1035,7 @@ class slot_conflict_handler:
 				new_atom = atom.unevaluated_atom.evaluate_conditionals(ppkg_new_use)
 				i = InternalPackageSet(initial_atoms=(new_atom,))
 				if not i.findAtomForPackage(pkg, new_use):
-					#We managed to create a new problem with our changes.
+					# We managed to create a new problem with our changes.
 					is_valid_solution = False
 					if self.debug:
 						writemsg(("new conflict introduced: %s"
@@ -1046,7 +1046,7 @@ class slot_conflict_handler:
 			if not is_valid_solution:
 				break
 
-		#Make sure the changes don't violate REQUIRED_USE
+		# Make sure the changes don't violate REQUIRED_USE
 		for pkg in required_changes:
 			required_use = pkg._metadata.get("REQUIRED_USE")
 			if not required_use: