Delete commented out print statements (#3178)

* delete commented out print statements apparently used at one point for debugging

* rename counters

* drop useless :d f-string format

Author: janosh

dev_scripts/chemenv/equivalent_indices.py

@@ -133,5 +133,5 @@
             i7 = 6 if i0 in [1, 4] else 7
             equiv_list.append([i0, i1, i2, i3, i4, i5, i6, i7])
 
-    print(f"Equivalent indices ({len(equiv_list):d}) for {cg_symbol} : ")
+    print(f"Equivalent indices ({len(equiv_list)}) for {cg_symbol} : ")
     print(equiv_list)

dev_scripts/chemenv/explicit_permutations_plane_algorithm.py

@@ -36,14 +36,14 @@
 
     new_algos = []
 
-    ialgo = 1
+    idx = 1
     for sep_plane_algo in cg._algorithms:
-        print(f"In {ialgo = :d}/{len(cg._algorithms):d}")
-        ialgo += 1
+        print(f"In {idx = }/{len(cg._algorithms)}")
+        idx += 1
         if sep_plane_algo.algorithm_type != "SEPARATION_PLANE":
             raise ValueError("Should all be separation plane")
 
-        perms_on_file = f"Permutations on file in this algorithm ({len(sep_plane_algo._permutations):d}) "
+        perms_on_file = f"Permutations on file in this algorithm ({len(sep_plane_algo._permutations)}) "
         print(perms_on_file)
         print(sep_plane_algo._permutations)
         permutations = sep_plane_algo.safe_separation_permutations(
@@ -52,7 +52,7 @@
 
         sep_plane_algo._permutations = permutations
 
-        print(f"Test permutations ({len(permutations):d}) :")
+        print(f"Test permutations ({len(permutations)}) :")
         print(permutations)
 
         lgf = LocalGeometryFinder()
@@ -134,7 +134,7 @@
                 explicit_permutations.append(sep_perms[icsm])
 
         print(perms_on_file)
-        print(f"Permutations found ({len(explicit_permutations):d}) : ")
+        print(f"Permutations found ({len(explicit_permutations)}) : ")
         print(explicit_permutations)
         sep_plane_algo.explicit_permutations = explicit_permutations
         new_algos.append(sep_plane_algo)

dev_scripts/chemenv/get_plane_permutations_optimized.py

@@ -175,7 +175,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
         # 1. Check the algorithms defined for this coordination geometry and get the explicit permutations
         original_n_explicit_perms = []
         original_n_explicit_optimized_perms = []
-        for ialgo, algo in enumerate(cg.algorithms):
+        for idx, algo in enumerate(cg.algorithms):
             algo._permutations = algo.explicit_permutations
             algo.minimum_number_of_points = 4
             if algo.algorithm_type == "EXPLICIT_PERMUTATIONS":
@@ -185,7 +185,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
             else:
                 eop = str(len(algo.explicit_optimized_permutations))
             print(
-                f"For ialgo {ialgo,:d}, plane_points are "
+                f"For {idx=}, plane_points are "
                 f"[{', '.join(map(str, algo.plane_points))}], "
                 f"side_0 is [{', '.join(map(str, algo.point_groups[0]))}] and "
                 f"side_1 is [{', '.join(map(str, algo.point_groups[1]))}]."
@@ -194,7 +194,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
             original_n_explicit_optimized_perms.append(eop)
             print(
                 f"  For this algorithm, there are {eop} optimized permutations and "
-                f"{len(algo.explicit_permutations):d} explicit permutations"
+                f"{len(algo.explicit_permutations)} explicit permutations"
             )
             if algo.other_plane_points is None:
                 input("Multiplicity and other plane points is not defined for this algorithm !")
@@ -204,7 +204,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
                 ordered_plane=algo.ordered_plane, ordered_point_groups=algo.ordered_point_groups
             )
             algo._permutations = permutations
-            print(f"Safe permutations found ({len(permutations):d})")
+            print(f"Safe permutations found ({len(permutations)})")
 
             # Definition of the facets
             all_planes_point_indices = [algo.plane_points]
@@ -213,9 +213,9 @@ def random_permutations_iterator(initial_permutation, n_permutations):
 
             # Loop on the facets
             explicit_permutations_per_plane = []
-            for iplane, plane_point_indices in enumerate(all_planes_point_indices):
+            for idx_plane, plane_point_indices in enumerate(all_planes_point_indices):
                 prt1(
-                    string=f"In plane {iplane:d} ({'-'.join(str(pp) for pp in plane_point_indices)})",
+                    string=f"In plane {idx_plane} ({'-'.join(str(pp) for pp in plane_point_indices)})",
                     printing_volume=printing_volume,
                 )
 
@@ -268,7 +268,7 @@ def random_permutations_iterator(initial_permutation, n_permutations):
             algo.explicit_permutations = [list(perm) for perm in list(explicit_permutations_per_plane[0])]
             algo.explicit_permutations.sort()
             algo.explicit_permutations = np.array(algo.explicit_permutations)
-            print(f"Explicit permutations found ({len(algo.explicit_permutations):d})")
+            print(f"Explicit permutations found ({len(algo.explicit_permutations)})")
             print(algo.explicit_permutations)
             print()
             # Setup the permutations for the next optimization
@@ -291,10 +291,10 @@ def random_permutations_iterator(initial_permutation, n_permutations):
         perms_used_algos: list[dict] = [{} for _ in cg.algorithms]
 
         # Loop on algorithms
-        for ialgo, algo in enumerate(cg.algorithms):
+        for idx, algo in enumerate(cg.algorithms):
             perms_used: dict[tuple, int] = {}
             print(
-                f"In ialgo {ialgo:d} (plane_points : "
+                f"In {idx=} (plane_points : "
                 f"[{', '.join(map(str, algo.plane_points))}], "
                 f"side_0 : [{', '.join(map(str, algo.point_groups[0]))}] and "
                 f"side_1 : [{', '.join(map(str, algo.point_groups[1]))}])"
@@ -334,12 +334,12 @@ def random_permutations_iterator(initial_permutation, n_permutations):
                 raise ValueError("Permutation setup not allowed ...")
 
             # Loop on permutations
-            iperm = 1
+            idx_perm = 1
             t0 = time.process_time()
             time_left: float | str = "Unknown"
             for indices_perm in perms_iterator:
                 prt1(
-                    string=f"Perm # {iperm:d}/{n_permutations:d} : "
+                    string=f"Perm # {idx_perm}/{n_permutations} : "
                     f"{'-'.join(map(str, indices_perm))} "
                     f"(est. rem. time : {time_left} sec)",
                     printing_volume=printing_volume,
@@ -353,9 +353,9 @@ def random_permutations_iterator(initial_permutation, n_permutations):
 
                 # Loop on the facets
                 separation_permutations = []
-                for iplane, plane_point_indices in enumerate(all_planes_point_indices):
+                for idx_plane, plane_point_indices in enumerate(all_planes_point_indices):
                     prt2(
-                        string=f"In plane {iplane:d} ({'-'.join(str(pp) for pp in plane_point_indices)})",
+                        string=f"In plane {idx_plane} ({'-'.join(str(pp) for pp in plane_point_indices)})",
                         printing_volume=printing_volume,
                     )
 
@@ -399,28 +399,28 @@ def random_permutations_iterator(initial_permutation, n_permutations):
                     else:
                         perms_used[some_perm] = 1
                 tcurrent = time.process_time()
-                time_left = (n_permutations - iperm) * (tcurrent - t0) / iperm  # type: ignore
+                time_left = (n_permutations - idx_perm) * (tcurrent - t0) / idx_perm  # type: ignore
                 time_left = f"{time_left:.1f}"
-                iperm += 1
+                idx_perm += 1
             print(
-                f"Optimized permutations {len(perms_used):d}/{len(algo.permutations):d}"
-                f"(old : {original_n_explicit_optimized_perms[ialgo]}/{original_n_explicit_perms[ialgo]}) : "
+                f"Optimized permutations {len(perms_used)}/{len(algo.permutations)}"
+                f"(old : {original_n_explicit_optimized_perms[idx]}/{original_n_explicit_perms[idx]}) : "
             )
             for perm, number in perms_used.items():
-                print(f" - permutation {'-'.join(map(str, perm))} : {number:d}")
+                print(f" - permutation {'-'.join(map(str, perm))} : {number}")
             print(
-                f"For {ialgo=} (plane_points : [{', '.join(map(str, algo.plane_points))}], "
+                f"For {idx=} (plane_points : [{', '.join(map(str, algo.plane_points))}], "
                 f"side_0 : [{', '.join(map(str, algo.point_groups[0]))}] and "
                 f"side_1 : [{', '.join(map(str, algo.point_groups[1]))}]),\n"
                 f"Optimized perturbations {len(perms_used)}/{len(algo.permutations)} (old : "
-                f"{original_n_explicit_optimized_perms[ialgo]}/{original_n_explicit_perms[ialgo]}) are :"
+                f"{original_n_explicit_optimized_perms[idx]}/{original_n_explicit_perms[idx]}) are :"
             )
-            # print(f"Optimized permutations ({len(perms_used):d}/{len(algo.permutations):d}) : ")
+            # print(f"Optimized permutations ({len(perms_used)}/{len(algo.permutations)}) : ")
             explicit_optimized_permutations = [list(perm) for perm in perms_used]
             explicit_optimized_permutations.sort()
             print(explicit_optimized_permutations)
             print()
-            test = input(f'Set optimized permutations for algorithm {ialgo:d} ? ("y" to confirm)')
+            test = input(f'Set optimized permutations for algorithm {idx} ? ("y" to confirm)')
             if test == "y":
                 algo.explicit_optimized_permutations = np.array(explicit_optimized_permutations)
 

dev_scripts/chemenv/plane_multiplicity.py

@@ -30,5 +30,5 @@
             all_plane_points.append(tuple(equiv_plane))
         all_plane_points = [tuple(equiv_plane) for equiv_plane in set(all_plane_points)]
 
-    print(f"All plane points ({len(all_plane_points):d}) for {cg_symbol} : ")
+    print(f"All plane points ({len(all_plane_points)}) for {cg_symbol} : ")
     print(all_plane_points)

dev_scripts/chemenv/strategies/multi_weights_strategy_parameters.py

@@ -277,7 +277,7 @@ def get_weights(self, weights_options):
     for ii in range(1, 14):
         self_weight_max_csms_per_cn[str(ii)] = []
         for jj in range(ii + 1, 14):
-            cn_pair = f"{ii:d}_{jj:d}"
+            cn_pair = f"{ii}_{jj}"
             self_weight_max_csms[cn_pair] = []
             delta_csm_mins[cn_pair] = []
             all_cn_pairs.append(cn_pair)

dev_scripts/chemenv/test_algos.py

@@ -65,7 +65,7 @@
         lgf.perfect_geometry = AbstractGeometry.from_cg(cg=cg)
         points_perfect = lgf.perfect_geometry.points_wocs_ctwocc()
 
-        print(f"Perm # {idx_perm:d}/{n_perms:d} : ", indices_perm)
+        print(f"Perm # {idx_perm}/{n_perms} : ", indices_perm)
 
         algos_results = []
         for algo in cg.algorithms:

dev_scripts/chemenv/test_algos_all_geoms.py

@@ -98,7 +98,7 @@
                 lgf.perfect_geometry = AbstractGeometry.from_cg(cg=cg)
                 points_perfect = lgf.perfect_geometry.points_wocs_ctwocc()
 
-                print(f"Perm # {i_perm:d}/{n_perms:d} : ", indices_perm)
+                print(f"Perm # {i_perm}/{n_perms} : ", indices_perm)
 
                 algos_results = []
                 for algo in cg.algorithms:

dev_scripts/chemenv/view_environment.py

@@ -43,11 +43,11 @@
             print("Wrong geometry, try again ...")
             continue
         print(cg.name)
-        for ipoint, point in enumerate(cg.points):
-            print(f"Point #{ipoint:d} : {point[0]!r} {point[1]!r} {point[2]!r}")
+        for idx, point in enumerate(cg.points):
+            print(f"Point #{idx} : {point[0]!r} {point[1]!r} {point[2]!r}")
         print("Algorithms used :")
-        for ialgo, algo in enumerate(cg.algorithms):
-            print(f"Algorithm #{ialgo:d} :")
+        for idx, algo in enumerate(cg.algorithms):
+            print(f"Algorithm #{idx} :")
             print(algo)
             print()
         # Visualize the separation plane of a given algorithm
@@ -56,8 +56,8 @@
             test = input("Enter index of the algorithm for which you want to visualize the plane : ")
             if test != "":
                 try:
-                    ialgo = int(test)
-                    algo = cg.algorithms[ialgo]
+                    idx = int(test)
+                    algo = cg.algorithms[idx]
                     sep_plane = True
                 except Exception:
                     print(

pymatgen/analysis/chemenv/connectivity/connected_components.py

@@ -651,7 +651,7 @@ def periodicity(self):
         """Get periodicity of this connected component."""
         if self._periodicity_vectors is None:
             self.compute_periodicity()
-        return f"{len(self._periodicity_vectors):d}D"
+        return f"{len(self._periodicity_vectors)}D"
 
     def elastic_centered_graph(self, start_node=None):
         """
@@ -681,19 +681,19 @@ def elastic_centered_graph(self, start_node=None):
         tree_level = 0
         while True:
             tree_level += 1
-            logging.debug(f"In tree level {tree_level:d} ({len(current_nodes):d} nodes)")
+            logging.debug(f"In tree level {tree_level} ({len(current_nodes)} nodes)")
             new_current_nodes = []
             # Loop on nodes in this level of the tree
             for node in current_nodes:
                 inode += 1
-                logging.debug(f"  In node #{inode:d}/{len(current_nodes):d} in level {tree_level:d} ({node})")
+                logging.debug(f"  In node #{inode}/{len(current_nodes)} in level {tree_level} ({node})")
                 node_neighbors = list(tree.neighbors(n=node))
                 node_edges = centered_connected_subgraph.edges(nbunch=[node], data=True, keys=True)
                 # Loop on neighbors of a node (from the tree used)
                 for inode_neighbor, node_neighbor in enumerate(node_neighbors):
                     logging.debug(
-                        f"    Testing neighbor #{inode_neighbor:d}/{len(node_neighbors):d} ({node_neighbor}) of "
-                        f"node #{inode:d} ({node})"
+                        f"    Testing neighbor #{inode_neighbor}/{len(node_neighbors)} ({node_neighbor}) of "
+                        f"node #{inode} ({node})"
                     )
                     already_inside = False
                     ddeltas = []
@@ -818,7 +818,7 @@ def as_dict(self):
         Returns:
             dict: Bson-serializable dict representation of the ConnectedComponent object.
         """
-        nodes = {f"{node.isite:d}": (node, data) for node, data in self._connected_subgraph.nodes(data=True)}
+        nodes = {f"{node.isite}": (node, data) for node, data in self._connected_subgraph.nodes(data=True)}
         node2stringindex = {node: strindex for strindex, (node, data) in nodes.items()}
         dict_of_dicts = nx.to_dict_of_dicts(self._connected_subgraph)
         new_dict_of_dicts = {}
@@ -899,5 +899,5 @@ def description(self, full=False):
                     get_delta(node1=en, node2=en_neighb, edge_data=edge_data).tolist()
                     for iedge, edge_data in self.graph[en][en_neighb].items()
                 )
-                out.extend([f"     ({delta[0]:d} {delta[1]:d} {delta[2]:d})" for delta in all_deltas])
+                out.extend([f"     ({delta[0]} {delta[1]} {delta[2]})" for delta in all_deltas])
         return "\n".join(out)

pymatgen/analysis/chemenv/connectivity/connectivity_finder.py

@@ -49,12 +49,12 @@ def get_structure_connectivity(self, light_structure_environments):
                 continue
             if len(site_neighbors_sets) > 1:
                 if self.multiple_environments_choice is None:
-                    raise ValueError(f"Local environment of site {isite:d} is a mix and nothing is asked about it")
+                    raise ValueError(f"Local environment of site {isite} is a mix and nothing is asked about it")
                 if self.multiple_environments_choice == "TAKE_HIGHEST_FRACTION":
                     imax = np.argmax(
                         [ee["ce_fraction"] for ee in light_structure_environments.coordination_environments[isite]]
                     )
-                    print(f"IMAX {imax:d}")
+                    print(f"IMAX {imax}")
                     site_neighbors_set = site_neighbors_sets[imax]
                 else:
                     raise RuntimeError("Should not be here")