pyg-nightly 2.7.0.dev20250606__py3-none-any.whl → 2.7.0.dev20250608__py3-none-any.whl

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_()

torch_geometric/nn/models/deep_graph_infomax.py

@@ -106,7 +106,7 @@ class DeepGraphInfomax(torch.nn.Module):
         """
         from sklearn.linear_model import LogisticRegression
 
-        clf = LogisticRegression(solver=solver, *args,
+        clf = LogisticRegression(*args, solver=solver,
                                  **kwargs).fit(train_z.detach().cpu().numpy(),
                                                train_y.detach().cpu().numpy())
         return clf.score(test_z.detach().cpu().numpy(),

torch_geometric/nn/models/glem.py

@@ -37,20 +37,28 @@ class GLEM(torch.nn.Module):
         See `examples/llm_plus_gnn/glem.py` for example usage.
     """
     def __init__(
-            self,
-            lm_to_use: str = 'prajjwal1/bert-tiny',
-            gnn_to_use: basic_gnn = GraphSAGE,
-            out_channels: int = 47,
-            gnn_loss=nn.CrossEntropyLoss(reduction='mean'),
-            lm_loss=nn.CrossEntropyLoss(reduction='mean'),
-            alpha: float = 0.5,
-            beta: float = 0.5,
-            lm_dtype: torch.dtype = torch.bfloat16,
-            lm_use_lora: bool = True,
-            lora_target_modules: Optional[Union[List[str], str]] = None,
-            device: Union[str, torch.device] = torch.device('cpu'),
+        self,
+        lm_to_use: str = 'prajjwal1/bert-tiny',
+        gnn_to_use: basic_gnn = GraphSAGE,
+        out_channels: int = 47,
+        gnn_loss: Optional[nn.Module] = None,
+        lm_loss: Optional[nn.Module] = None,
+        alpha: float = 0.5,
+        beta: float = 0.5,
+        lm_dtype: torch.dtype = torch.bfloat16,
+        lm_use_lora: bool = True,
+        lora_target_modules: Optional[Union[List[str], str]] = None,
+        device: Optional[Union[str, torch.device]] = None,
     ):
         super().__init__()
+
+        if gnn_loss is None:
+            gnn_loss = nn.CrossEntropyLoss(reduction='mean')
+        if lm_loss is None:
+            lm_loss = nn.CrossEntropyLoss(reduction='mean')
+        if device is None:
+            device = torch.device('cpu')
+
         self.device = device
         self.lm_loss = lm_loss
         self.gnn = gnn_to_use

torch_geometric/nn/models/gpse.py

@@ -716,11 +716,18 @@ class GPSENodeEncoder(torch.nn.Module):
 
 
 @torch.no_grad()
-def gpse_process(model: Module, data: Data, rand_type: str,
-                 use_vn: bool = True, bernoulli_thresh: float = 0.5,
-                 neighbor_loader: bool = False,
-                 num_neighbors: List[int] = [30, 20, 10], fillval: int = 5,
-                 layers_mp: int = None, **kwargs) -> torch.Tensor:
+def gpse_process(
+    model: Module,
+    data: Data,
+    rand_type: str,
+    use_vn: bool = True,
+    bernoulli_thresh: float = 0.5,
+    neighbor_loader: bool = False,
+    num_neighbors: Optional[List[int]] = None,
+    fillval: int = 5,
+    layers_mp: int = None,
+    **kwargs,
+) -> torch.Tensor:
     r"""Processes the data using the :class:`GPSE` model to generate and append
     GPSE encodings. Identical to :obj:`gpse_process_batch`, but operates on a
     single :class:`~torch_geometric.data.Dataset` object.
@@ -784,6 +791,8 @@ def gpse_process(model: Module, data: Data, rand_type: str,
         if layers_mp is None:
             raise ValueError('Please provide the number of message-passing '
                              'layers as "layers_mp".')
+
+        num_neighbors = num_neighbors or [30, 20, 10]
         diff = layers_mp - len(num_neighbors)
         if fillval > 0 and diff > 0:
             num_neighbors += [fillval] * diff
@@ -792,7 +801,7 @@ def gpse_process(model: Module, data: Data, rand_type: str,
                                 shuffle=False, pin_memory=True, **kwargs)
         out_list = []
         pbar = trange(data.num_nodes, position=2)
-        for i, batch in enumerate(loader):
+        for batch in loader:
             out, _ = model(batch.to(device))
             out = out[:batch.batch_size].to("cpu", non_blocking=True)
             out_list.append(out)
@@ -806,12 +815,18 @@ def gpse_process(model: Module, data: Data, rand_type: str,
 
 
 @torch.no_grad()
-def gpse_process_batch(model: GPSE, batch, rand_type: str, use_vn: bool = True,
-                       bernoulli_thresh: float = 0.5,
-                       neighbor_loader: bool = False,
-                       num_neighbors: List[int] = [30, 20, 10],
-                       fillval: int = 5, layers_mp: int = None,
-                       **kwargs) -> Tuple[torch.Tensor, torch.Tensor]:
+def gpse_process_batch(
+    model: GPSE,
+    batch,
+    rand_type: str,
+    use_vn: bool = True,
+    bernoulli_thresh: float = 0.5,
+    neighbor_loader: bool = False,
+    num_neighbors: Optional[List[int]] = None,
+    fillval: int = 5,
+    layers_mp: int = None,
+    **kwargs,
+) -> Tuple[torch.Tensor, torch.Tensor]:
     r"""Process a batch of data using the :class:`GPSE` model to generate and
     append :class:`GPSE` encodings. Identical to `gpse_process`, but operates
     on a batch of :class:`~torch_geometric.data.Data` objects.
@@ -881,6 +896,8 @@ def gpse_process_batch(model: GPSE, batch, rand_type: str, use_vn: bool = True,
         if layers_mp is None:
             raise ValueError('Please provide the number of message-passing '
                              'layers as "layers_mp".')
+
+        num_neighbors = num_neighbors or [30, 20, 10]
         diff = layers_mp - len(num_neighbors)
         if fillval > 0 and diff > 0:
             num_neighbors += [fillval] * diff
@@ -889,7 +906,7 @@ def gpse_process_batch(model: GPSE, batch, rand_type: str, use_vn: bool = True,
                                 shuffle=False, pin_memory=True, **kwargs)
         out_list = []
         pbar = trange(batch.num_nodes, position=2)
-        for i, batch in enumerate(loader):
+        for batch in loader:
             out, _ = model(batch.to(device))
             out = out[:batch.batch_size].to('cpu', non_blocking=True)
             out_list.append(out)

torch_geometric/nn/models/graph_unet.py

@@ -64,7 +64,7 @@ class GraphUNet(torch.nn.Module):
         in_channels = channels if sum_res else 2 * channels
 
         self.up_convs = torch.nn.ModuleList()
-        for i in range(depth - 1):
+        for _ in range(depth - 1):
             self.up_convs.append(GCNConv(in_channels, channels, improved=True))
         self.up_convs.append(GCNConv(in_channels, out_channels, improved=True))
 

torch_geometric/nn/models/metapath2vec.py

@@ -233,7 +233,7 @@ class MetaPath2Vec(torch.nn.Module):
         """
         from sklearn.linear_model import LogisticRegression
 
-        clf = LogisticRegression(solver=solver, *args,
+        clf = LogisticRegression(*args, solver=solver,
                                  **kwargs).fit(train_z.detach().cpu().numpy(),
                                                train_y.detach().cpu().numpy())
         return clf.score(test_z.detach().cpu().numpy(),

torch_geometric/nn/models/mlp.py

@@ -99,8 +99,10 @@ class MLP(torch.nn.Module):
         act_first = act_first or kwargs.get("relu_first", False)
         batch_norm = kwargs.get("batch_norm", None)
         if batch_norm is not None and isinstance(batch_norm, bool):
-            warnings.warn("Argument `batch_norm` is deprecated, "
-                          "please use `norm` to specify normalization layer.")
+            warnings.warn(
+                "Argument `batch_norm` is deprecated, "
+                "please use `norm` to specify normalization layer.",
+                stacklevel=2)
             norm = 'batch_norm' if batch_norm else None
             batch_norm_kwargs = kwargs.get("batch_norm_kwargs", None)
             norm_kwargs = batch_norm_kwargs or {}

torch_geometric/nn/models/node2vec.py

@@ -181,7 +181,7 @@ class Node2Vec(torch.nn.Module):
         """
         from sklearn.linear_model import LogisticRegression
 
-        clf = LogisticRegression(solver=solver, *args,
+        clf = LogisticRegression(*args, solver=solver,
                                  **kwargs).fit(train_z.detach().cpu().numpy(),
                                                train_y.detach().cpu().numpy())
         return clf.score(test_z.detach().cpu().numpy(),

torch_geometric/nn/models/rev_gnn.py

@@ -249,7 +249,7 @@ class GroupAddRev(InvertibleModule):
         else:
             assert num_groups is not None, "Please specific 'num_groups'"
             self.convs = torch.nn.ModuleList([conv])
-            for i in range(num_groups - 1):
+            for _ in range(num_groups - 1):
                 conv = copy.deepcopy(self.convs[0])
                 if hasattr(conv, 'reset_parameters'):
                     conv.reset_parameters()

torch_geometric/nn/models/signed_gcn.py

@@ -45,7 +45,7 @@ class SignedGCN(torch.nn.Module):
         self.conv1 = SignedConv(in_channels, hidden_channels // 2,
                                 first_aggr=True)
         self.convs = torch.nn.ModuleList()
-        for i in range(num_layers - 1):
+        for _ in range(num_layers - 1):
             self.convs.append(
                 SignedConv(hidden_channels // 2, hidden_channels // 2,
                            first_aggr=False))

torch_geometric/nn/nlp/llm.py

@@ -94,7 +94,8 @@ class LLM(torch.nn.Module):
         self.word_embedding = self.llm.model.get_input_embeddings()
 
         if 'max_memory' not in kwargs:  # Pure CPU:
-            warnings.warn("LLM is being used on CPU, which may be slow")
+            warnings.warn("LLM is being used on CPU, which may be slow",
+                          stacklevel=2)
             self.device = torch.device('cpu')
             self.autocast_context = nullcontext()
         else:

torch_geometric/nn/pool/__init__.py

@@ -163,8 +163,10 @@ def knn_graph(
     :rtype: :class:`torch.Tensor`
     """
     if batch is not None and x.device != batch.device:
-        warnings.warn("Input tensor 'x' and 'batch' are on different devices "
-                      "in 'knn_graph'. Performing blocking device transfer")
+        warnings.warn(
+            "Input tensor 'x' and 'batch' are on different devices "
+            "in 'knn_graph'. Performing blocking device transfer",
+            stacklevel=2)
         batch = batch.to(x.device)
 
     if not torch_geometric.typing.WITH_TORCH_CLUSTER_BATCH_SIZE:
@@ -285,8 +287,10 @@ def radius_graph(
         inputs to GPU before proceeding.
     """
     if batch is not None and x.device != batch.device:
-        warnings.warn("Input tensor 'x' and 'batch' are on different devices "
-                      "in 'radius_graph'. Performing blocking device transfer")
+        warnings.warn(
+            "Input tensor 'x' and 'batch' are on different devices "
+            "in 'radius_graph'. Performing blocking device transfer",
+            stacklevel=2)
         batch = batch.to(x.device)
 
     if not torch_geometric.typing.WITH_TORCH_CLUSTER_BATCH_SIZE:

torch_geometric/nn/pool/knn.py

@@ -91,9 +91,10 @@ class KNNIndex:
                     if hasattr(self.index, 'reserveMemory'):
                         self.index.reserveMemory(self.reserve)
                     else:
-                        warnings.warn(f"'{self.index.__class__.__name__}' "
-                                      f"does not support pre-allocation of "
-                                      f"memory")
+                        warnings.warn(
+                            f"'{self.index.__class__.__name__}' "
+                            f"does not support pre-allocation of "
+                            f"memory", stacklevel=2)
 
             self.index.train(emb)
 
@@ -135,14 +136,16 @@ class KNNIndex:
         query_k = min(query_k, self.numel)
 
         if k > 2048:  # `faiss` supports up-to `k=2048`:
-            warnings.warn(f"Capping 'k' to faiss' upper limit of 2048 "
-                          f"(got {k}). This may cause some relevant items to "
-                          f"not be retrieved.")
+            warnings.warn(
+                f"Capping 'k' to faiss' upper limit of 2048 "
+                f"(got {k}). This may cause some relevant items to "
+                f"not be retrieved.", stacklevel=2)
         elif query_k > 2048:
-            warnings.warn(f"Capping 'k' to faiss' upper limit of 2048 "
-                          f"(got {k} which got extended to {query_k} due to "
-                          f"the exclusion of existing links). This may cause "
-                          f"some relevant items to not be retrieved.")
+            warnings.warn(
+                f"Capping 'k' to faiss' upper limit of 2048 "
+                f"(got {k} which got extended to {query_k} due to "
+                f"the exclusion of existing links). This may cause "
+                f"some relevant items to not be retrieved.", stacklevel=2)
             query_k = 2048
 
         score, index = self.index.search(emb.detach(), query_k)

torch_geometric/nn/to_hetero_module.py

@@ -108,9 +108,10 @@ class ToHeteroMessagePassing(torch.nn.Module):
 
         if (not hasattr(module, 'reset_parameters')
                 and sum([p.numel() for p in module.parameters()]) > 0):
-            warnings.warn(f"'{module}' will be duplicated, but its parameters "
-                          f"cannot be reset. To suppress this warning, add a "
-                          f"'reset_parameters()' method to '{module}'")
+            warnings.warn(
+                f"'{module}' will be duplicated, but its parameters "
+                f"cannot be reset. To suppress this warning, add a "
+                f"'reset_parameters()' method to '{module}'", stacklevel=2)
 
         convs = {edge_type: copy.deepcopy(module) for edge_type in edge_types}
         self.hetero_module = HeteroConv(convs, aggr)

torch_geometric/nn/to_hetero_transformer.py

@@ -157,7 +157,7 @@ class ToHeteroTransformer(Transformer):
                 f"There exist node types ({unused_node_types}) whose "
                 f"representations do not get updated during message passing "
                 f"as they do not occur as destination type in any edge type. "
-                f"This may lead to unexpected behavior.")
+                f"This may lead to unexpected behavior.", stacklevel=2)
 
         names = self.metadata[0] + [rel for _, rel, _ in self.metadata[1]]
         for name in names:
@@ -166,7 +166,7 @@ class ToHeteroTransformer(Transformer):
                     f"The type '{name}' contains invalid characters which "
                     f"may lead to unexpected behavior. To avoid any issues, "
                     f"ensure that your types only contain letters, numbers "
-                    f"and underscores.")
+                    f"and underscores.", stacklevel=2)
 
     def placeholder(self, node: Node, target: Any, name: str):
         # Adds a `get` call to the input dictionary for every node-type or
@@ -379,7 +379,7 @@ class ToHeteroTransformer(Transformer):
                 warnings.warn(
                     f"'{target}' will be duplicated, but its parameters "
                     f"cannot be reset. To suppress this warning, add a "
-                    f"'reset_parameters()' method to '{target}'")
+                    f"'reset_parameters()' method to '{target}'", stacklevel=2)
 
         return module_dict
 

torch_geometric/nn/to_hetero_with_bases_transformer.py

@@ -165,7 +165,7 @@ class ToHeteroWithBasesTransformer(Transformer):
                 f"There exist node types ({unused_node_types}) whose "
                 f"representations do not get updated during message passing "
                 f"as they do not occur as destination type in any edge type. "
-                f"This may lead to unexpected behavior.")
+                f"This may lead to unexpected behavior.", stacklevel=2)
 
         names = self.metadata[0] + [rel for _, rel, _ in self.metadata[1]]
         for name in names:
@@ -174,7 +174,7 @@ class ToHeteroWithBasesTransformer(Transformer):
                     f"The type '{name}' contains invalid characters which "
                     f"may lead to unexpected behavior. To avoid any issues, "
                     f"ensure that your types only contain letters, numbers "
-                    f"and underscores.")
+                    f"and underscores.", stacklevel=2)
 
     def transform(self) -> GraphModule:
         self._node_offset_dict_initialized = False
@@ -361,7 +361,7 @@ class HeteroBasisConv(torch.nn.Module):
                 warnings.warn(
                     f"'{conv}' will be duplicated, but its parameters cannot "
                     f"be reset. To suppress this warning, add a "
-                    f"'reset_parameters()' method to '{conv}'")
+                    f"'reset_parameters()' method to '{conv}'", stacklevel=2)
             torch.nn.init.xavier_uniform_(conv.edge_type_weight)
 
     def forward(self, edge_type: Tensor, *args, **kwargs) -> Tensor:

torch_geometric/sampler/base.py

@@ -1,7 +1,7 @@
 import copy
 import math
 import warnings
-from abc import ABC
+from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
@@ -369,9 +369,10 @@ class HeteroSamplerOutput(CastMixin):
                         out.edge[edge_type] = None
 
                 else:
-                    warnings.warn(f"Cannot convert to bidirectional graph "
-                                  f"since the edge type {edge_type} does not "
-                                  f"seem to have a reverse edge type")
+                    warnings.warn(
+                        f"Cannot convert to bidirectional graph "
+                        f"since the edge type {edge_type} does not "
+                        f"seem to have a reverse edge type", stacklevel=2)
 
         return out
 
@@ -622,6 +623,7 @@ class BaseSampler(ABC):
         As such, it is recommended to limit the amount of information stored in
         the sampler.
     """
+    @abstractmethod
     def sample_from_nodes(
         self,
         index: NodeSamplerInput,
@@ -642,6 +644,7 @@ class BaseSampler(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
     def sample_from_edges(
         self,
         index: EdgeSamplerInput,

torch_geometric/sampler/hgt_sampler.py

@@ -1,12 +1,15 @@
-from typing import Dict, List, Union
+from typing import Dict, List, Optional, Union
 
 import torch
 
 from torch_geometric.data import Data, HeteroData
 from torch_geometric.sampler import (
     BaseSampler,
+    EdgeSamplerInput,
     HeteroSamplerOutput,
+    NegativeSampling,
     NodeSamplerInput,
+    SamplerOutput,
 )
 from torch_geometric.sampler.utils import remap_keys, to_hetero_csc
 from torch_geometric.typing import (
@@ -76,6 +79,13 @@ class HGTSampler(BaseSampler):
             metadata=(inputs.input_id, inputs.time),
         )
 
+    def sample_from_edges(
+        self,
+        index: EdgeSamplerInput,
+        neg_sampling: Optional[NegativeSampling] = None,
+    ) -> Union[HeteroSamplerOutput, SamplerOutput]:
+        pass
+
     @property
     def edge_permutation(self) -> Union[OptTensor, Dict[EdgeType, OptTensor]]:
         return self.perm

torch_geometric/sampler/neighbor_sampler.py

@@ -52,16 +52,18 @@ class NeighborSampler(BaseSampler):
     ):
         if not directed:
             subgraph_type = SubgraphType.induced
-            warnings.warn(f"The usage of the 'directed' argument in "
-                          f"'{self.__class__.__name__}' is deprecated. Use "
-                          f"`subgraph_type='induced'` instead.")
+            warnings.warn(
+                f"The usage of the 'directed' argument in "
+                f"'{self.__class__.__name__}' is deprecated. Use "
+                f"`subgraph_type='induced'` instead.", stacklevel=2)
 
         if (not torch_geometric.typing.WITH_PYG_LIB and sys.platform == 'linux'
                 and subgraph_type != SubgraphType.induced):
-            warnings.warn(f"Using '{self.__class__.__name__}' without a "
-                          f"'pyg-lib' installation is deprecated and will be "
-                          f"removed soon. Please install 'pyg-lib' for "
-                          f"accelerated neighborhood sampling")
+            warnings.warn(
+                f"Using '{self.__class__.__name__}' without a "
+                f"'pyg-lib' installation is deprecated and will be "
+                f"removed soon. Please install 'pyg-lib' for "
+                f"accelerated neighborhood sampling", stacklevel=2)
 
         self.data_type = DataType.from_data(data)
 
@@ -806,7 +808,7 @@ def neg_sample(
     out = out.view(num_samples, seed.numel())
     mask = node_time[out] > seed_time  # holds all invalid samples.
     neg_sampling_complete = False
-    for i in range(5):  # pragma: no cover
+    for _ in range(5):  # pragma: no cover
         num_invalid = int(mask.sum())
         if num_invalid == 0:
             neg_sampling_complete = True

torch_geometric/testing/decorators.py

@@ -252,8 +252,9 @@ def withDevice(func: Callable) -> Callable:
     if device:
         backend = os.getenv('TORCH_BACKEND')
         if backend is None:
-            warnings.warn(f"Please specify the backend via 'TORCH_BACKEND' in"
-                          f"order to test against '{device}'")
+            warnings.warn(
+                f"Please specify the backend via 'TORCH_BACKEND' in"
+                f"order to test against '{device}'", stacklevel=2)
         else:
             import_module(backend)
             devices.append(pytest.param(torch.device(device), id=device))

torch_geometric/testing/distributed.py

@@ -73,7 +73,7 @@ def assert_run_mproc(
     ]
     results = []
 
-    for p, q in zip(procs, queues):
+    for p, _ in zip(procs, queues):
         p.start()
 
     for p, q in zip(procs, queues):

torch_geometric/transforms/add_gpse.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from torch.nn import Module
 
 from torch_geometric.data import Data
@@ -22,13 +24,20 @@ class AddGPSE(BaseTransform):
             (default: :obj:`NormalSE`)
 
     """
-    def __init__(self, model: Module, use_vn: bool = True,
-                 rand_type: str = 'NormalSE'):
+    def __init__(
+        self,
+        model: Module,
+        use_vn: bool = True,
+        rand_type: str = 'NormalSE',
+    ):
         self.model = model
         self.use_vn = use_vn
         self.vn = VirtualNode()
         self.rand_type = rand_type
 
+    def forward(self, data: Data) -> Any:
+        pass
+
     def __call__(self, data: Data) -> Data:
         from torch_geometric.nn.models.gpse import gpse_process
 

torch_geometric/transforms/add_metapaths.py

@@ -108,13 +108,15 @@ class AddMetaPaths(BaseTransform):
         **kwargs: bool,
     ) -> None:
         if 'drop_orig_edges' in kwargs:
-            warnings.warn("'drop_orig_edges' is deprecated. Use "
-                          "'drop_orig_edge_types' instead")
+            warnings.warn(
+                "'drop_orig_edges' is deprecated. Use "
+                "'drop_orig_edge_types' instead", stacklevel=2)
             drop_orig_edge_types = kwargs['drop_orig_edges']
 
         if 'drop_unconnected_nodes' in kwargs:
-            warnings.warn("'drop_unconnected_nodes' is deprecated. Use "
-                          "'drop_unconnected_node_types' instead")
+            warnings.warn(
+                "'drop_unconnected_nodes' is deprecated. Use "
+                "'drop_unconnected_node_types' instead", stacklevel=2)
             drop_unconnected_node_types = kwargs['drop_unconnected_nodes']
 
         for path in metapaths:
@@ -144,7 +146,7 @@ class AddMetaPaths(BaseTransform):
             if self.max_sample is not None:
                 edge_index, edge_weight = self._sample(edge_index, edge_weight)
 
-            for i, edge_type in enumerate(metapath[1:]):
+            for edge_type in metapath[1:]:
                 edge_index2, edge_weight2 = self._edge_index(data, edge_type)
 
                 edge_index, edge_weight = edge_index.matmul(
@@ -276,7 +278,7 @@ class AddRandomMetaPaths(BaseTransform):
             row = start = torch.randperm(num_nodes)[:num_starts].repeat(
                 self.walks_per_node[j])
 
-            for i, edge_type in enumerate(metapath):
+            for edge_type in metapath:
                 edge_index = EdgeIndex(
                     data[edge_type].edge_index,
                     sparse_size=data[edge_type].size(),