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

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

@@ -801,7 +801,7 @@ def gpse_process(
                                 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)
@@ -906,7 +906,7 @@ def gpse_process_batch(
                                 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(),

torch_geometric/transforms/base_transform.py

@@ -1,5 +1,5 @@
 import copy
-from abc import ABC
+from abc import ABC, abstractmethod
 from typing import Any
 
 
@@ -31,6 +31,7 @@ class BaseTransform(ABC):
         # Shallow-copy the data so that we prevent in-place data modification.
         return self.forward(copy.copy(data))
 
+    @abstractmethod
     def forward(self, data: Any) -> Any:
         pass
 

torch_geometric/transforms/largest_connected_components.py

@@ -47,7 +47,7 @@ class LargestConnectedComponents(BaseTransform):
             return data
 
         _, count = np.unique(component, return_counts=True)
-        subset_np = np.in1d(component, count.argsort()[-self.num_components:])
+        subset_np = np.isin(component, count.argsort()[-self.num_components:])
         subset = torch.from_numpy(subset_np)
         subset = subset.to(data.edge_index.device, torch.bool)
 

torch_geometric/transforms/random_link_split.py

@@ -245,7 +245,7 @@ class RandomLinkSplit(BaseTransform):
                 warnings.warn(
                     f"There are not enough negative edges to satisfy "
                     "the provided sampling ratio. The ratio will be "
-                    f"adjusted to {ratio:.2f}.")
+                    f"adjusted to {ratio:.2f}.", stacklevel=2)
                 num_neg_train = int((num_neg_train / num_neg) * num_neg_found)
                 num_neg_val = int((num_neg_val / num_neg) * num_neg_found)
                 num_neg_test = num_neg_found - num_neg_train - num_neg_val

torch_geometric/typing.py

@@ -81,8 +81,9 @@ try:
         WITH_CUDA_HASH_MAP = False
 except Exception as e:
     if not isinstance(e, ImportError):  # pragma: no cover
-        warnings.warn(f"An issue occurred while importing 'pyg-lib'. "
-                      f"Disabling its usage. Stacktrace: {e}")
+        warnings.warn(
+            f"An issue occurred while importing 'pyg-lib'. "
+            f"Disabling its usage. Stacktrace: {e}", stacklevel=2)
     pyg_lib = object
     WITH_PYG_LIB = False
     WITH_GMM = False
@@ -125,8 +126,9 @@ try:
     WITH_TORCH_SCATTER = True
 except Exception as e:
     if not isinstance(e, ImportError):  # pragma: no cover
-        warnings.warn(f"An issue occurred while importing 'torch-scatter'. "
-                      f"Disabling its usage. Stacktrace: {e}")
+        warnings.warn(
+            f"An issue occurred while importing 'torch-scatter'. "
+            f"Disabling its usage. Stacktrace: {e}", stacklevel=2)
     torch_scatter = object
     WITH_TORCH_SCATTER = False
 
@@ -136,8 +138,9 @@ try:
     WITH_TORCH_CLUSTER_BATCH_SIZE = 'batch_size' in torch_cluster.knn.__doc__
 except Exception as e:
     if not isinstance(e, ImportError):  # pragma: no cover
-        warnings.warn(f"An issue occurred while importing 'torch-cluster'. "
-                      f"Disabling its usage. Stacktrace: {e}")
+        warnings.warn(
+            f"An issue occurred while importing 'torch-cluster'. "
+            f"Disabling its usage. Stacktrace: {e}", stacklevel=2)
     WITH_TORCH_CLUSTER = False
     WITH_TORCH_CLUSTER_BATCH_SIZE = False
 
@@ -154,7 +157,7 @@ except Exception as e:
     if not isinstance(e, ImportError):  # pragma: no cover
         warnings.warn(
             f"An issue occurred while importing 'torch-spline-conv'. "
-            f"Disabling its usage. Stacktrace: {e}")
+            f"Disabling its usage. Stacktrace: {e}", stacklevel=2)
     WITH_TORCH_SPLINE_CONV = False
 
 try:
@@ -163,8 +166,9 @@ try:
     WITH_TORCH_SPARSE = True
 except Exception as e:
     if not isinstance(e, ImportError):  # pragma: no cover
-        warnings.warn(f"An issue occurred while importing 'torch-sparse'. "
-                      f"Disabling its usage. Stacktrace: {e}")
+        warnings.warn(
+            f"An issue occurred while importing 'torch-sparse'. "
+            f"Disabling its usage. Stacktrace: {e}", stacklevel=2)
     WITH_TORCH_SPARSE = False
 
     class SparseStorage:  # type: ignore

torch_geometric/utils/_scatter.py

@@ -88,9 +88,10 @@ def scatter(
 
             if (src.is_cuda and src.requires_grad and not is_compiling()
                     and not is_in_onnx_export()):
-                warnings.warn(f"The usage of `scatter(reduce='{reduce}')` "
-                              f"can be accelerated via the 'torch-scatter'"
-                              f" package, but it was not found")
+                warnings.warn(
+                    f"The usage of `scatter(reduce='{reduce}')` "
+                    f"can be accelerated via the 'torch-scatter'"
+                    f" package, but it was not found", stacklevel=2)
 
             index = broadcast(index, src, dim)
             if not is_in_onnx_export():
@@ -120,9 +121,10 @@ def scatter(
                 or not src.is_cuda):
 
             if src.is_cuda and not is_compiling():
-                warnings.warn(f"The usage of `scatter(reduce='{reduce}')` "
-                              f"can be accelerated via the 'torch-scatter'"
-                              f" package, but it was not found")
+                warnings.warn(
+                    f"The usage of `scatter(reduce='{reduce}')` "
+                    f"can be accelerated via the 'torch-scatter'"
+                    f" package, but it was not found", stacklevel=2)
 
             index = broadcast(index, src, dim)
             # We initialize with `one` here to match `scatter_mul` output: