pyg-nightly 2.7.0.dev20250607__py3-none-any.whl → 2.7.0.dev20250609__py3-none-any.whl

torch_geometric/data/hetero_data.py

@@ -585,12 +585,13 @@ class HeteroData(BaseData, FeatureStore, GraphStore):
         global _DISPLAYED_TYPE_NAME_WARNING
         if not _DISPLAYED_TYPE_NAME_WARNING and '__' in name:
             _DISPLAYED_TYPE_NAME_WARNING = True
-            warnings.warn(f"There exist type names in the "
-                          f"'{self.__class__.__name__}' object that contain "
-                          f"double underscores '__' (e.g., '{name}'). This "
-                          f"may lead to unexpected behavior. To avoid any "
-                          f"issues, ensure that your type names only contain "
-                          f"single underscores.")
+            warnings.warn(
+                f"There exist type names in the "
+                f"'{self.__class__.__name__}' object that contain "
+                f"double underscores '__' (e.g., '{name}'). This "
+                f"may lead to unexpected behavior. To avoid any "
+                f"issues, ensure that your type names only contain "
+                f"single underscores.", stacklevel=2)
 
     def get_node_store(self, key: NodeType) -> NodeStorage:
         r"""Gets the :class:`~torch_geometric.data.storage.NodeStorage` object

torch_geometric/data/hypergraph_data.py

@@ -223,4 +223,4 @@ def warn_or_raise(msg: str, raise_on_error: bool = True) -> None:
     if raise_on_error:
         raise ValueError(msg)
     else:
-        warnings.warn(msg)
+        warnings.warn(msg, stacklevel=2)

torch_geometric/data/in_memory_dataset.py

@@ -297,7 +297,7 @@ class InMemoryDataset(Dataset):
             self._data_list = None
         msg += f' {msg4}'
 
-        warnings.warn(msg)
+        warnings.warn(msg, stacklevel=2)
 
         return self._data
 
@@ -346,7 +346,7 @@ class InMemoryDataset(Dataset):
 
 def nested_iter(node: Union[Mapping, Sequence]) -> Iterable:
     if isinstance(node, Mapping):
-        for key, value in node.items():
+        for value in node.values():
             yield from nested_iter(value)
     elif isinstance(node, Sequence):
         yield from enumerate(node)

torch_geometric/data/large_graph_indexer.py

@@ -141,7 +141,7 @@ class LargeGraphIndexer:
                 self.edge_attr[default_key] = list()
             self.edge_attr[EDGE_PID] = edges
 
-            for i, tup in enumerate(edges):
+            for tup in edges:
                 h, r, t = tup
                 self.edge_attr[EDGE_HEAD].append(h)
                 self.edge_attr[EDGE_RELATION].append(r)

torch_geometric/data/lightning/datamodule.py

@@ -40,9 +40,11 @@ class LightningDataModule(PLLightningDataModule):
                           kwargs.get('num_workers', 0) > 0)
 
         if 'shuffle' in kwargs:
-            warnings.warn(f"The 'shuffle={kwargs['shuffle']}' option is "
-                          f"ignored in '{self.__class__.__name__}'. Remove it "
-                          f"from the argument list to disable this warning")
+            warnings.warn(
+                f"The 'shuffle={kwargs['shuffle']}' option is "
+                f"ignored in '{self.__class__.__name__}'. Remove it "
+                f"from the argument list to disable this warning",
+                stacklevel=2)
             del kwargs['shuffle']
 
         self.kwargs = kwargs
@@ -74,34 +76,39 @@ class LightningData(LightningDataModule):
             raise ValueError(f"Undefined 'loader' option (got '{loader}')")
 
         if loader == 'full' and kwargs['batch_size'] != 1:
-            warnings.warn(f"Re-setting 'batch_size' to 1 in "
-                          f"'{self.__class__.__name__}' for loader='full' "
-                          f"(got '{kwargs['batch_size']}')")
+            warnings.warn(
+                f"Re-setting 'batch_size' to 1 in "
+                f"'{self.__class__.__name__}' for loader='full' "
+                f"(got '{kwargs['batch_size']}')", stacklevel=2)
             kwargs['batch_size'] = 1
 
         if loader == 'full' and kwargs['num_workers'] != 0:
-            warnings.warn(f"Re-setting 'num_workers' to 0 in "
-                          f"'{self.__class__.__name__}' for loader='full' "
-                          f"(got '{kwargs['num_workers']}')")
+            warnings.warn(
+                f"Re-setting 'num_workers' to 0 in "
+                f"'{self.__class__.__name__}' for loader='full' "
+                f"(got '{kwargs['num_workers']}')", stacklevel=2)
             kwargs['num_workers'] = 0
 
         if loader == 'full' and kwargs.get('sampler') is not None:
-            warnings.warn("'sampler' option is not supported for "
-                          "loader='full'")
+            warnings.warn(
+                "'sampler' option is not supported for "
+                "loader='full'", stacklevel=2)
             kwargs.pop('sampler', None)
 
         if loader == 'full' and kwargs.get('batch_sampler') is not None:
-            warnings.warn("'batch_sampler' option is not supported for "
-                          "loader='full'")
+            warnings.warn(
+                "'batch_sampler' option is not supported for "
+                "loader='full'", stacklevel=2)
             kwargs.pop('batch_sampler', None)
 
         super().__init__(has_val, has_test, **kwargs)
 
         if loader == 'full':
             if kwargs.get('pin_memory', False):
-                warnings.warn(f"Re-setting 'pin_memory' to 'False' in "
-                              f"'{self.__class__.__name__}' for loader='full' "
-                              f"(got 'True')")
+                warnings.warn(
+                    f"Re-setting 'pin_memory' to 'False' in "
+                    f"'{self.__class__.__name__}' for loader='full' "
+                    f"(got 'True')", stacklevel=2)
             self.kwargs['pin_memory'] = False
 
         self.data = data
@@ -127,10 +134,11 @@ class LightningData(LightningDataModule):
                 graph_sampler.__class__,
             )
             if len(sampler_kwargs) > 0:
-                warnings.warn(f"Ignoring the arguments "
-                              f"{list(sampler_kwargs.keys())} in "
-                              f"'{self.__class__.__name__}' since a custom "
-                              f"'graph_sampler' was passed")
+                warnings.warn(
+                    f"Ignoring the arguments "
+                    f"{list(sampler_kwargs.keys())} in "
+                    f"'{self.__class__.__name__}' since a custom "
+                    f"'graph_sampler' was passed", stacklevel=2)
             self.graph_sampler = graph_sampler
 
         else:

torch_geometric/data/storage.py

@@ -454,7 +454,7 @@ class NodeStorage(BaseStorage):
             f"'{set(self.keys())}'. Please explicitly set 'num_nodes' as an "
             f"attribute of " +
             ("'data'" if self._key is None else f"'data[{self._key}]'") +
-            " to suppress this warning")
+            " to suppress this warning", stacklevel=2)
         if 'edge_index' in self and isinstance(self.edge_index, Tensor):
             if self.edge_index.numel() > 0:
                 return int(self.edge_index.max()) + 1

torch_geometric/datasets/dbp15k.py

@@ -73,7 +73,7 @@ class DBP15K(InMemoryDataset):
     def process(self) -> None:
         embs = {}
         with open(osp.join(self.raw_dir, 'sub.glove.300d')) as f:
-            for i, line in enumerate(f):
+            for line in f:
                 info = line.strip().split(' ')
                 if len(info) > 300:
                     embs[info[0]] = torch.tensor([float(x) for x in info[1:]])

torch_geometric/datasets/molecule_net.py

@@ -210,8 +210,9 @@ class MoleculeNet(InMemoryDataset):
             data.y = y
 
             if data.num_nodes == 0:
-                warnings.warn(f"Skipping molecule '{smiles}' since it "
-                              f"resulted in zero atoms")
+                warnings.warn(
+                    f"Skipping molecule '{smiles}' since it "
+                    f"resulted in zero atoms", stacklevel=2)
                 continue
 
             if self.pre_filter is not None and not self.pre_filter(data):

torch_geometric/datasets/tag_dataset.py

@@ -128,7 +128,7 @@ class TAGDataset(InMemoryDataset):
     @property
     def raw_file_names(self) -> List[str]:
         file_names = []
-        for root, _, files in os.walk(osp.join(self.root, 'raw')):
+        for _, _, files in os.walk(osp.join(self.root, 'raw')):
             for file in files:
                 file_names.append(file)
         return file_names

torch_geometric/datasets/wikics.py

@@ -45,7 +45,8 @@ class WikiCS(InMemoryDataset):
             warnings.warn(
                 f"The {self.__class__.__name__} dataset now returns an "
                 f"undirected graph by default. Please explicitly specify "
-                f"'is_undirected=False' to restore the old behavior.")
+                f"'is_undirected=False' to restore the old behavior.",
+                stacklevel=2)
             is_undirected = True
         self.is_undirected = is_undirected
         super().__init__(root, transform, pre_transform,

torch_geometric/deprecation.py

@@ -23,7 +23,7 @@ def deprecated(
             out = f"'{name}' is deprecated"
             if details is not None:
                 out += f", {details}"
-            warnings.warn(out)
+            warnings.warn(out, stacklevel=2)
             return func(*args, **kwargs)
 
         return wrapper

torch_geometric/distributed/rpc.py

@@ -92,7 +92,7 @@ def shutdown_rpc(id: str = None, graceful: bool = True,
 class RPCRouter:
     r"""A router to get the worker based on the partition ID."""
     def __init__(self, partition_to_workers: List[List[str]]):
-        for pid, rpc_worker_list in enumerate(partition_to_workers):
+        for rpc_worker_list in partition_to_workers:
             if len(rpc_worker_list) == 0:
                 raise ValueError('No RPC worker is in worker list')
         self.partition_to_workers = partition_to_workers
@@ -120,7 +120,7 @@ def rpc_partition_to_workers(
     partition_to_workers = [[] for _ in range(num_partitions)]
     gathered_results = global_all_gather(
         (ctx.role, num_partitions, current_partition_idx))
-    for worker_name, (role, nparts, idx) in gathered_results.items():
+    for worker_name, (_, _, idx) in gathered_results.items():
         partition_to_workers[idx].append(worker_name)
     return partition_to_workers
 

torch_geometric/explain/algorithm/captum_explainer.py

@@ -73,7 +73,8 @@ class CaptumExplainer(ExplainerAlgorithm):
                              f"{self.attribution_method_class.__name__}")
 
         if kwargs.get('internal_batch_size', 1) != 1:
-            warnings.warn("Overriding 'internal_batch_size' to 1")
+            warnings.warn("Overriding 'internal_batch_size' to 1",
+                          stacklevel=2)
 
         if 'internal_batch_size' in self._get_attribute_parameters():
             kwargs['internal_batch_size'] = 1

torch_geometric/explain/algorithm/graphmask_explainer.py

@@ -202,25 +202,25 @@ class GraphMaskExplainer(ExplainerAlgorithm):
 
         baselines, self.gates, full_biases = [], torch.nn.ModuleList(), []
 
-        for v_dim, m_dim, h_dim in zip(i_dim, j_dim, h_dim):
+        for v_dim, m_dim, o_dim in zip(i_dim, j_dim, h_dim):
             self.transform, self.layer_norm = [], []
             input_dims = [v_dim, m_dim, v_dim]
             for _, input_dim in enumerate(input_dims):
                 self.transform.append(
-                    Linear(input_dim, h_dim, bias=False).to(device))
-                self.layer_norm.append(LayerNorm(h_dim).to(device))
+                    Linear(input_dim, o_dim, bias=False).to(device))
+                self.layer_norm.append(LayerNorm(o_dim).to(device))
 
             self.transforms = torch.nn.ModuleList(self.transform)
             self.layer_norms = torch.nn.ModuleList(self.layer_norm)
 
             self.full_bias = Parameter(
-                torch.tensor(h_dim, dtype=torch.float, device=device))
+                torch.tensor(o_dim, dtype=torch.float, device=device))
             full_biases.append(self.full_bias)
 
-            self.reset_parameters(input_dims, h_dim)
+            self.reset_parameters(input_dims, o_dim)
 
             self.non_linear = ReLU()
-            self.output_layer = Linear(h_dim, 1).to(device)
+            self.output_layer = Linear(o_dim, 1).to(device)
 
             gate = [
                 self.transforms, self.layer_norms, self.non_linear,
@@ -385,7 +385,7 @@ class GraphMaskExplainer(ExplainerAlgorithm):
                         f'Train explainer for graph {index} with layer '
                         f'{layer}')
             self._enable_layer(layer)
-            for epoch in range(self.epochs):
+            for _ in range(self.epochs):
                 with torch.no_grad():
                     model(x, edge_index, **kwargs)
                 gates, total_penalty = [], 0

torch_geometric/explain/explainer.py

@@ -192,7 +192,7 @@ class Explainer:
             if target is not None:
                 warnings.warn(
                     f"The 'target' should not be provided for the explanation "
-                    f"type '{self.explanation_type.value}'")
+                    f"type '{self.explanation_type.value}'", stacklevel=2)
             prediction = self.get_prediction(x, edge_index, **kwargs)
             target = self.get_target(prediction)
 

torch_geometric/graphgym/config.py

@@ -16,8 +16,9 @@ try:  # Define global config object
     cfg = CN()
 except ImportError:
     cfg = None
-    warnings.warn("Could not define global config object. Please install "
-                  "'yacs' via 'pip install yacs' in order to use GraphGym")
+    warnings.warn(
+        "Could not define global config object. Please install "
+        "'yacs' via 'pip install yacs' in order to use GraphGym", stacklevel=2)
 
 
 def set_cfg(cfg):

torch_geometric/graphgym/imports.py

@@ -11,5 +11,7 @@ except ImportError:
     LightningModule = torch.nn.Module
     Callback = object
 
-    warnings.warn("Please install 'pytorch_lightning' via  "
-                  "'pip install pytorch_lightning' in order to use GraphGym")
+    warnings.warn(
+        "Please install 'pytorch_lightning' via  "
+        "'pip install pytorch_lightning' in order to use GraphGym",
+        stacklevel=2)

torch_geometric/graphgym/logger.py

@@ -239,7 +239,7 @@ def create_logger():
     r"""Create logger for the experiment."""
     loggers = []
     names = ['train', 'val', 'test']
-    for i, dataset in enumerate(range(cfg.share.num_splits)):
+    for i, _ in enumerate(range(cfg.share.num_splits)):
         loggers.append(Logger(name=names[i], task_type=infer_task()))
     return loggers
 

torch_geometric/graphgym/models/encoder.py

@@ -53,7 +53,7 @@ class AtomEncoder(torch.nn.Module):
 
         self.atom_embedding_list = torch.nn.ModuleList()
 
-        for i, dim in enumerate(get_atom_feature_dims()):
+        for dim in get_atom_feature_dims():
             emb = torch.nn.Embedding(dim, emb_dim)
             torch.nn.init.xavier_uniform_(emb.weight.data)
             self.atom_embedding_list.append(emb)
@@ -87,7 +87,7 @@ class BondEncoder(torch.nn.Module):
 
         self.bond_embedding_list = torch.nn.ModuleList()
 
-        for i, dim in enumerate(get_bond_feature_dims()):
+        for dim in get_bond_feature_dims():
             emb = torch.nn.Embedding(dim, emb_dim)
             torch.nn.init.xavier_uniform_(emb.weight.data)
             self.bond_embedding_list.append(emb)

torch_geometric/hash_tensor.py

@@ -69,10 +69,11 @@ def get_hash_map(key: Tensor) -> Union[CPUHashMap, CUDAHashMap]:
         return CUDAHashMap(key, 0.5)
 
     if key.is_cuda:
-        warnings.warn("Fallback to CPU-based mapping algorithm which may "
-                      "cause slowdowns and device synchronization. Please "
-                      "install 'pyg-lib' for an accelerated 'HashTensor' "
-                      "implementation.")
+        warnings.warn(
+            "Fallback to CPU-based mapping algorithm which may "
+            "cause slowdowns and device synchronization. Please "
+            "install 'pyg-lib' for an accelerated 'HashTensor' "
+            "implementation.", stacklevel=2)
 
     if torch_geometric.typing.WITH_CPU_HASH_MAP:
         return CPUHashMap(key.cpu(), -1)

torch_geometric/io/fs.py

@@ -226,11 +226,12 @@ def torch_load(path: str, map_location: Any = None) -> Any:
                             "compatible in your case.")
                 match = re.search(r'add_safe_globals\(.*?\)', error_msg)
                 if match is not None:
-                    warnings.warn(f"{warn_msg} Please use "
-                                  f"`torch.serialization.{match.group()}` to "
-                                  f"allowlist this global.")
+                    warnings.warn(
+                        f"{warn_msg} Please use "
+                        f"`torch.serialization.{match.group()}` to "
+                        f"allowlist this global.", stacklevel=2)
                 else:
-                    warnings.warn(warn_msg)
+                    warnings.warn(warn_msg, stacklevel=2)
 
                 with fsspec.open(path, 'rb') as f:
                     return torch.load(f, map_location, weights_only=False)

torch_geometric/loader/ibmb_loader.py

@@ -148,7 +148,7 @@ def indices_complete_check(
         if isinstance(aux, Tensor):
             aux = aux.cpu().numpy()
 
-        assert np.all(np.in1d(out,
+        assert np.all(np.isin(out,
                               aux)), "Not all output nodes are in aux nodes!"
         outs.append(out)
 
@@ -236,7 +236,7 @@ def create_batchwise_out_aux_pairs(
             logits[tele_set, i] = 1. / len(tele_set)
 
         new_logits = logits.clone()
-        for i in range(num_iter):
+        for _ in range(num_iter):
             new_logits = adj @ new_logits * (1 - alpha) + alpha * logits
 
         inds = new_logits.argsort(0)
@@ -498,7 +498,7 @@ class IBMBBaseLoader(torch.utils.data.DataLoader):
             assert adj is not None
 
         for out, aux in pbar:
-            mask = torch.from_numpy(np.in1d(aux, out))
+            mask = torch.from_numpy(np.isin(aux, out))
             if isinstance(aux, np.ndarray):
                 aux = torch.from_numpy(aux)
             subg = get_subgraph(aux, graph, return_edge_index_type, adj,
@@ -541,7 +541,7 @@ class IBMBBaseLoader(torch.utils.data.DataLoader):
         out, aux = zip(*data_list)
         out = np.concatenate(out)
         aux = np.unique(np.concatenate(aux))
-        mask = torch.from_numpy(np.in1d(aux, out))
+        mask = torch.from_numpy(np.isin(aux, out))
         aux = torch.from_numpy(aux)
 
         subg = get_subgraph(aux, self.graph, self.return_edge_index_type,

torch_geometric/loader/mixin.py

@@ -248,7 +248,8 @@ class AffinityMixin:
             warnings.warn(
                 "Due to conflicting parallelization methods it is not advised "
                 "to use affinitization with 'HeteroData' datasets. "
-                "Use `enable_multithreading` for better performance.")
+                "Use `enable_multithreading` for better performance.",
+                stacklevel=2)
 
         self.loader_cores = loader_cores[:] if loader_cores else None
         if self.loader_cores is None:

torch_geometric/loader/prefetch.py

@@ -27,8 +27,9 @@ class DeviceHelper:
 
         if ((self.device.type == 'cuda' and not with_cuda)
                 or (self.device.type == 'xpu' and not with_xpu)):
-            warnings.warn(f"Requested device '{self.device.type}' is not "
-                          f"available, falling back to CPU")
+            warnings.warn(
+                f"Requested device '{self.device.type}' is not "
+                f"available, falling back to CPU", stacklevel=2)
             self.device = torch.device('cpu')
 
         self.stream = None

torch_geometric/nn/aggr/fused.py

@@ -216,7 +216,7 @@ class FusedAggregation(Aggregation):
         outs: List[Optional[Tensor]] = []
 
         # Iterate over all reduction ops to compute first results:
-        for i, reduce in enumerate(self.reduce_ops):
+        for reduce in self.reduce_ops:
             if reduce is None:
                 outs.append(None)
                 continue

torch_geometric/nn/conv/appnp.py

@@ -109,7 +109,7 @@ class APPNP(MessagePassing):
                     edge_index = cache
 
         h = x
-        for k in range(self.K):
+        for _ in range(self.K):
             if self.dropout > 0 and self.training:
                 if isinstance(edge_index, Tensor):
                     if is_torch_sparse_tensor(edge_index):

torch_geometric/nn/conv/gen_conv.py

@@ -178,7 +178,7 @@ class GENConv(MessagePassing):
             self.lin_dst = Linear(in_channels[1], out_channels, bias=bias)
 
         channels = [out_channels]
-        for i in range(num_layers - 1):
+        for _ in range(num_layers - 1):
             channels.append(out_channels * expansion)
         channels.append(out_channels)
         self.mlp = MLP(channels, norm=norm, bias=bias)

torch_geometric/nn/conv/gravnet_conv.py

@@ -63,7 +63,8 @@ class GravNetConv(MessagePassing):
         if num_workers is not None:
             warnings.warn(
                 "'num_workers' attribute in '{self.__class__.__name__}' is "
-                "deprecated and will be removed in a future release")
+                "deprecated and will be removed in a future release",
+                stacklevel=2)
 
         self.in_channels = in_channels
         self.out_channels = out_channels

torch_geometric/nn/conv/hetero_conv.py

@@ -77,7 +77,8 @@ class HeteroConv(torch.nn.Module):
                 f"There exist node types ({src_node_types - dst_node_types}) "
                 f"whose representations do not get updated during message "
                 f"passing as they do not occur as destination type in any "
-                f"edge type. This may lead to unexpected behavior.")
+                f"edge type. This may lead to unexpected behavior.",
+                stacklevel=2)
 
         self.convs = ModuleDict(convs)
         self.aggr = aggr

torch_geometric/nn/conv/meshcnn_conv.py

@@ -456,12 +456,13 @@ class MeshCNNConv(MessagePassing):
                 {type(network)}"
             if not hasattr(network, "in_channels") and \
                     not hasattr(network, "in_features"):
-                warn(f"kernel[{i}] does not have attribute \
+                warn(
+                    f"kernel[{i}] does not have attribute \
                             'in_channels' nor 'out_features'. The \
                             network must take as input a \
                             {self.in_channels}-dimensional tensor. \
                             Still, assuming user configured \
-                            correctly. Continuing..")
+                            correctly. Continuing..", stacklevel=2)
             else:
                 input_dimension = getattr(network, "in_channels",
                                           network.in_features)
@@ -474,12 +475,13 @@ class MeshCNNConv(MessagePassing):
 
             if not hasattr(network, "out_channels") and \
                     not hasattr(network, "out_features"):
-                warn(f"kernel[{i}] does not have attribute \
+                warn(
+                    f"kernel[{i}] does not have attribute \
                                 'in_channels' nor 'out_features'. The \
                                 network must take as input a \
                                 {self.in_channels}-dimensional tensor. \
                                 Still, assuming user configured \
-                                correctly. Continuing..")
+                                correctly. Continuing..", stacklevel=2)
             else:
                 output_dimension = getattr(network, "out_channels",
                                            network.out_features)

torch_geometric/nn/conv/message_passing.py

@@ -1029,6 +1029,7 @@ class MessagePassing(torch.nn.Module):
             :meth:`jittable` is deprecated and a no-op from :pyg:`PyG` 2.5
             onwards.
         """
-        warnings.warn(f"'{self.__class__.__name__}.jittable' is deprecated "
-                      f"and a no-op. Please remove its usage.")
+        warnings.warn(
+            f"'{self.__class__.__name__}.jittable' is deprecated "
+            f"and a no-op. Please remove its usage.", stacklevel=2)
         return self

torch_geometric/nn/conv/sg_conv.py

@@ -90,7 +90,7 @@ class SGConv(MessagePassing):
                     edge_index, edge_weight, x.size(self.node_dim), False,
                     self.add_self_loops, self.flow, dtype=x.dtype)
 
-            for k in range(self.K):
+            for _ in range(self.K):
                 # propagate_type: (x: Tensor, edge_weight: OptTensor)
                 x = self.propagate(edge_index, x=x, edge_weight=edge_weight)
                 if self.cached:

torch_geometric/nn/conv/spline_conv.py

@@ -132,7 +132,8 @@ class SplineConv(MessagePassing):
         if not x[0].is_cuda:
             warnings.warn(
                 'We do not recommend using the non-optimized CPU version of '
-                '`SplineConv`. If possible, please move your data to GPU.')
+                '`SplineConv`. If possible, please move your data to GPU.',
+                stacklevel=2)
 
         # propagate_type: (x: OptPairTensor, edge_attr: OptTensor)
         out = self.propagate(edge_index, x=x, edge_attr=edge_attr, size=size)

torch_geometric/nn/conv/ssg_conv.py

@@ -100,7 +100,7 @@ class SSGConv(MessagePassing):
                     self.add_self_loops, self.flow, dtype=x.dtype)
 
             h = x * self.alpha
-            for k in range(self.K):
+            for _ in range(self.K):
                 # propagate_type: (x: Tensor, edge_weight: OptTensor)
                 x = self.propagate(edge_index, x=x, edge_weight=edge_weight)
                 h = h + (1 - self.alpha) / self.K * x

torch_geometric/nn/data_parallel.py

@@ -57,10 +57,11 @@ class DataParallel(torch.nn.DataParallel):
                  follow_batch=None, exclude_keys=None):
         super().__init__(module, device_ids, output_device)
 
-        warnings.warn("'DataParallel' is usually much slower than "
-                      "'DistributedDataParallel' even on a single machine. "
-                      "Please consider switching to 'DistributedDataParallel' "
-                      "for multi-GPU training.")
+        warnings.warn(
+            "'DataParallel' is usually much slower than "
+            "'DistributedDataParallel' even on a single machine. "
+            "Please consider switching to 'DistributedDataParallel' "
+            "for multi-GPU training.", stacklevel=2)
 
         self.src_device = torch.device(f'cuda:{self.device_ids[0]}')
         self.follow_batch = follow_batch or []

torch_geometric/nn/fx.py

@@ -130,11 +130,13 @@ class Transformer:
         # (node-level, edge-level) by filling `self._state`:
         for node in list(self.graph.nodes):
             if node.op == 'call_function' and 'training' in node.kwargs:
-                warnings.warn(f"Found function '{node.name}' with keyword "
-                              f"argument 'training'. During FX tracing, this "
-                              f"will likely be baked in as a constant value. "
-                              f"Consider replacing this function by a module "
-                              f"to properly encapsulate its training flag.")
+                warnings.warn(
+                    f"Found function '{node.name}' with keyword "
+                    f"argument 'training'. During FX tracing, this "
+                    f"will likely be baked in as a constant value. "
+                    f"Consider replacing this function by a module "
+                    f"to properly encapsulate its training flag.",
+                    stacklevel=2)
 
             if node.op == 'placeholder':
                 if node.name not in self._state:

torch_geometric/nn/models/attentive_fp.py

@@ -160,7 +160,7 @@ class AttentiveFP(torch.nn.Module):
         edge_index = torch.stack([row, batch], dim=0)
 
         out = global_add_pool(x, batch).relu_()
-        for t in range(self.num_timesteps):
+        for _ in range(self.num_timesteps):
             h = F.elu_(self.mol_conv((x, out), edge_index))
             h = F.dropout(h, p=self.dropout, training=self.training)
             out = self.mol_gru(h, out).relu_()