pyg-nightly 2.7.0.dev20250504__py3-none-any.whl → 2.7.0.dev20250505__py3-none-any.whl

{pyg_nightly-2.7.0.dev20250504.dist-info → pyg_nightly-2.7.0.dev20250505.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg-nightly
-Version: 2.7.0.dev20250504
+Version: 2.7.0.dev20250505
 Summary: Graph Neural Network Library for PyTorch
 Keywords: deep-learning,pytorch,geometric-deep-learning,graph-neural-networks,graph-convolutional-networks
 Author-email: Matthias Fey <matthias@pyg.org>

{pyg_nightly-2.7.0.dev20250504.dist-info → pyg_nightly-2.7.0.dev20250505.dist-info}/RECORD

@@ -1,4 +1,4 @@
-torch_geometric/__init__.py,sha256=sQzmkvhoO3gUcLkGhTtJi5ZIApfl_-Dnsejf7c1o9RI,1978
+torch_geometric/__init__.py,sha256=BiduxVS51etguzPOVckBI8kTSmBUcEA48YUl_PxIJlw,2255
 torch_geometric/_compile.py,sha256=f-WQeH4VLi5Hn9lrgztFUCSrN_FImjhQa6BxFzcYC38,1338
 torch_geometric/_onnx.py,sha256=V9ffrIKSqhDw6xUZ12lkuSfNs48cQp2EeJ6Z19GfnVw,349
 torch_geometric/backend.py,sha256=lVaf7aLoVaB3M-UcByUJ1G4T4FOK6LXAg0CF4W3E8jo,1575
@@ -7,7 +7,7 @@ torch_geometric/config_store.py,sha256=zdMzlgBpUmBkPovpYQh5fMNwTZLDq2OneqX47QEx7
 torch_geometric/debug.py,sha256=cLyH9OaL2v7POyW-80b19w-ctA7a_5EZsS4aUF1wc2U,1295
 torch_geometric/deprecation.py,sha256=dWRymDIUkUVI2MeEmBG5WF4R6jObZeseSBV9G6FNfjc,858
 torch_geometric/device.py,sha256=tU5-_lBNVbVHl_kUmWPwiG5mQ1pyapwMF4JkmtNN3MM,1224
-torch_geometric/edge_index.py,sha256=J8uHIUXleOv4A2XONkT6yaTJi9yXauxBRJiHmJHMox4,70330
+torch_geometric/edge_index.py,sha256=jSWrZ77qKKydVDxiXrsBlaoL6Qdems6-HiA_B_qDo2o,70078
 torch_geometric/experimental.py,sha256=JbtNNEXjFGI8hZ9raM6-qrZURP6Z5nlDK8QicZUIbz0,4756
 torch_geometric/hash_tensor.py,sha256=WB-aBCJWNWqnlnzQ8Ob4LHeCXm0u1_NPPhmNAEwBpq4,24906
 torch_geometric/home.py,sha256=EV54B4Dmiv61GDbkCwtCfWGWJ4eFGwZ8s3KOgGjwYgY,790
@@ -19,7 +19,7 @@ torch_geometric/logging.py,sha256=HmHHLiCcM64k-6UYNOSfXPIeSGNAyiGGcn8cD8tlyuQ,85
 torch_geometric/resolver.py,sha256=fn-_6mCpI2xv7eDZnIFcYrHOn0IrwbkWFLDb9laQrWI,1270
 torch_geometric/seed.py,sha256=MJLbVwpb9i8mK3oi32sS__Cq-dRq_afTeoOL_HoA9ko,372
 torch_geometric/template.py,sha256=rqjDWgcSAgTCiV4bkOjWRPaO4PpUdC_RXigzxxBqAu8,1060
-torch_geometric/typing.py,sha256=bUIcBMcvDGn3DV1p6VFvkQ64fCB3mO2SNrlFxCoKCkc,15624
+torch_geometric/typing.py,sha256=Ryx6oGoOsEh8rJ3O0O6j8O18ZPHkrIv-7dr-suQZa6Q,15486
 torch_geometric/warnings.py,sha256=t114CbkrmiqkXaavx5g7OO52dLdktf-U__B5QqYIQvI,413
 torch_geometric/contrib/__init__.py,sha256=0pWkmXfZtbdr-AKwlii5LTFggTEH-MCrSKpZxrtPlVs,352
 torch_geometric/contrib/datasets/__init__.py,sha256=lrGnWsEiJf5zsBRmshGZZFN_uYR2ezDjbj9n9nCpvtk,23
@@ -32,7 +32,7 @@ torch_geometric/contrib/nn/models/rbcd_attack.py,sha256=qcyxBxAbx8LKzpp3RoJQ0cxl
 torch_geometric/contrib/transforms/__init__.py,sha256=lrGnWsEiJf5zsBRmshGZZFN_uYR2ezDjbj9n9nCpvtk,23
 torch_geometric/data/__init__.py,sha256=D6Iz5A9vEb_2rpf96Zn7uM-lchZ3WpW8X7WdAD1yxKw,4565
 torch_geometric/data/batch.py,sha256=8X8CN4_1rjrh48R3R2--mZUgfsO7Po9JP-H6SbrBiBA,8740
-torch_geometric/data/collate.py,sha256=RRiUMBLxDAitaHx7zF0qiMR2nW1NY_0uaNdxlUo5-bo,12756
+torch_geometric/data/collate.py,sha256=tOUvttXoEo-bOvJx_qMivJq2JqOsB9iDdjovtiyys4o,12644
 torch_geometric/data/data.py,sha256=mp_jsjsaVwUcY-FghlqNZTHUQEKBdi7xWR_oA2ewrD4,43821
 torch_geometric/data/database.py,sha256=VTct1xyzXsK0GZahBV9-noviCzjRteAsKMG7VgJ52n0,22998
 torch_geometric/data/datapipes.py,sha256=9_Cq3j_7LIF4plQFzbLaqyy0LcpKdAic6yiKgMqSX9A,3083
@@ -415,7 +415,7 @@ torch_geometric/nn/dense/dense_graph_conv.py,sha256=_7y-EmyStVouGPyA2H5baufNZHwj
 torch_geometric/nn/dense/dense_sage_conv.py,sha256=erfy0RAWOAkbRi8QXBVgkv37QeSo8XdcXYGYLZBgY7A,2672
 torch_geometric/nn/dense/diff_pool.py,sha256=bHIKbfV8Fv36H611V8bDpT6ACTKx8d1-hKzDXm5dQ9g,3051
 torch_geometric/nn/dense/dmon_pool.py,sha256=l4usDrjX4LAVcAU2jTXte4aUk8UeyDStlRHzKwwpi8s,6115
-torch_geometric/nn/dense/linear.py,sha256=BYssHSn8KnUC0_N_wBDAXfnbHRYBIUkHGmc-0bHV8bw,17773
+torch_geometric/nn/dense/linear.py,sha256=rAXLXq8kAuyyR1fxNOj8Rj_w7Zk5TMergcPUsXQAWI4,17150
 torch_geometric/nn/dense/mincut_pool.py,sha256=CirJKIEXICGul3ziTno-o2EqDkQLkV7m2KxdYPyI4ZI,4111
 torch_geometric/nn/functional/__init__.py,sha256=ggqde0hPT7wKzWAbQaEe9yX-Jcg_tWO-wivMmAJ9rz0,129
 torch_geometric/nn/functional/bro.py,sha256=_MurXJXVY1cFaCjDEAyvNoXv-Ka_Odlz-jxIS4OuDzY,1549
@@ -498,10 +498,10 @@ torch_geometric/nn/pool/sag_pool.py,sha256=YgNJUDd2WrE2PW9_ibQC7YaXlnSOCJ_4vt2LY
 torch_geometric/nn/pool/topk_pool.py,sha256=0n2Bg2Pt6nVozlAJjZpIMcTCMG7o_sGkzDNzNVN8D3A,5159
 torch_geometric/nn/pool/voxel_grid.py,sha256=OLe0kAsYYiJLdlgNwJYTIDX53lg1t2X_TCTawPtcU2A,2793
 torch_geometric/nn/pool/connect/__init__.py,sha256=rIaO9siCtXt5wBTQnSWnDyadnGZgF1hgfQo21Foij2M,287
-torch_geometric/nn/pool/connect/base.py,sha256=CD8L_PGbf9tOE6cHjtA7OEt2R4rNF8C81YkVP2MH01s,4081
+torch_geometric/nn/pool/connect/base.py,sha256=2rLOCC5NGQ7CIrrY-_zWtXKVcW6MPrVJO7tFxJHw4m0,4009
 torch_geometric/nn/pool/connect/filter_edges.py,sha256=LDzTjOWRjone2Gw7buBwwp2rOSRVaDmoyPJBik18BTo,2190
 torch_geometric/nn/pool/select/__init__.py,sha256=V0nnZQhbWPt_yDylHD5nwCSBMYzyWfgETePvNE-a7AM,254
-torch_geometric/nn/pool/select/base.py,sha256=On7xaGjMf_ISRvDmpBpJ0krYof0a78XEzSkq_NzLcqU,3298
+torch_geometric/nn/pool/select/base.py,sha256=1PhuMBqmAGscr4ERluRHapZ4-GcMMLebluuRJB0esms,3225
 torch_geometric/nn/pool/select/topk.py,sha256=R1LTjOvanJqlrcDe0qinqz286qOJpmjC1tPeiQdPGcU,5305
 torch_geometric/nn/unpool/__init__.py,sha256=J6I3abNR1MRxisXzbX3sBRH-hlMpmUe7FVc3UziZ67s,129
 torch_geometric/nn/unpool/knn_interpolate.py,sha256=8GlKoB-wzZz6ETJP7SsKHbzwenr4JiPg6sK3uh9I6R8,2586
@@ -592,17 +592,17 @@ torch_geometric/utils/_degree.py,sha256=FcsGx5cQdrBmoCQ4qQ2csjsTiDICP1as4x1HD9y5
 torch_geometric/utils/_grid.py,sha256=1coutST2TMV9TSQcmpXze0GIK9odzZ9wBtbKs6u26D8,2562
 torch_geometric/utils/_homophily.py,sha256=1nXxGUATFPB3icEGpvEWUiuYbjU9gDGtlWpuLbtWhJk,5090
 torch_geometric/utils/_index_sort.py,sha256=FTJacmOsqgsyof7MJFHlVVdXhHOjR0j7siTb0UZ-YT0,1283
-torch_geometric/utils/_lexsort.py,sha256=chMEJJRXqfE6-K4vrVszdr3c338EhMZyi0Q9IEJD3p0,1403
+torch_geometric/utils/_lexsort.py,sha256=GvqVvDrEjurQP_zDZsWkg6zCkL4ORVPNRdTsoa2pllc,1097
 torch_geometric/utils/_negative_sampling.py,sha256=jxsmpryeoTT8qQrvIH11MgyhgoWzvqPGRAcVyU85VCU,15494
 torch_geometric/utils/_normalize_edge_index.py,sha256=H6DY-Dzi1Psr3igG_nb0U3ZPNZz-BBDntO2iuA8FtzA,1682
 torch_geometric/utils/_normalized_cut.py,sha256=uwVJkl-Q0tpY-w0nvcHajcQYcqFh1oDOf55XELdjJBU,1167
 torch_geometric/utils/_one_hot.py,sha256=vXC7l7zudYRZIwWv6mT-Biuk2zKELyqteJXLynPocPM,1404
-torch_geometric/utils/_scatter.py,sha256=f8nSA_zZXO2YwKMnaGcx_Cz-11UdMxfck-hl0B6Mcng,14614
+torch_geometric/utils/_scatter.py,sha256=qwM8GpMiXT8uuckTg9nYDtwg2WqAWljkhjLE8omOHhk,11642
 torch_geometric/utils/_segment.py,sha256=CqS7_NMQihX89gEwFVHbyMEZgaEnSlJGpyuWqy3i8HI,1976
 torch_geometric/utils/_select.py,sha256=BZ5P6-1riR4xhCIJZnsNg5HmeAGelRzH42TpADj9xpQ,2439
 torch_geometric/utils/_softmax.py,sha256=6dTVbWX04laemRP-ZFPMS6ymRZtRa8zYF22QCXl_m4w,3242
-torch_geometric/utils/_sort_edge_index.py,sha256=oPS1AkAmPm5Aq8sSGI-e-OkeXOnU5X58Q86eamHi4gA,4500
-torch_geometric/utils/_spmm.py,sha256=uRq21nCgostC2jE6SKfp2xIY4_BtrXOG5YHbWUEPv10,5794
+torch_geometric/utils/_sort_edge_index.py,sha256=Z5F9xcRp3hKzTiTlc2gqYufs8QLDSI4cuJNRI0zF0G4,4373
+torch_geometric/utils/_spmm.py,sha256=zesnYzhGZoEih99iW_fMBysiWFPLLiuV8YTIQg0fOL4,5740
 torch_geometric/utils/_subgraph.py,sha256=GcOGNUcVe97tifuQyi5qBZ88A_Wo3-o17l9xCSIsau4,18456
 torch_geometric/utils/_to_dense_adj.py,sha256=hl1sboUBvED5Er66bqLms4VdmxKA-7Y3ozJIR-YIAUc,3606
 torch_geometric/utils/_to_dense_batch.py,sha256=-K5NjjfvjKYKJQ3kXgNIDR7lwMJ_GGISI45b50IGMvY,4582
@@ -632,12 +632,12 @@ torch_geometric/utils/ppr.py,sha256=ebiHbQqRJsQbGUI5xu-IkzQSQsgIaC71vgO0KcXIKAk,
 torch_geometric/utils/random.py,sha256=Rv5HlhG5310rytbT9EZ7xWLGKQfozfz1azvYi5nx2-U,5148
 torch_geometric/utils/repeat.py,sha256=RxCoRoEisaP6NouXPPW5tY1Rn-tIfrmpJPm0qGP6W8M,815
 torch_geometric/utils/smiles.py,sha256=lGQ2BwJ49uBrQfIxxPz8ceTO9Jo-XCjlLxs1ql3xrsA,7130
-torch_geometric/utils/sparse.py,sha256=uYd0oPrp5XN0c2Zc15f-00rhhVMfLnRMqNcqcmILNKQ,25519
+torch_geometric/utils/sparse.py,sha256=MJyWkn-r9sdMyR_m-aBUIQUkvxsYLUNP9jYlfntSUpI,25118
 torch_geometric/utils/undirected.py,sha256=H_nfpI0_WluOG6VfjPyldvcjL4w5USAKWu2x5nUAUjw,6222
 torch_geometric/visualization/__init__.py,sha256=b-HnVesXjyJ_L1N-DnjiRiRVf7lhwKaBQF_2i5YMVSU,208
 torch_geometric/visualization/graph.py,sha256=PoI9tjbEXZVkMUg4CvTLbzqtEfzUwMUcsw57DNBEU0s,14311
 torch_geometric/visualization/influence.py,sha256=CWMvuNA_Nf1sfbJmQgn58yS4OFpeKXeZPe7kEuvkUBw,477
-pyg_nightly-2.7.0.dev20250504.dist-info/licenses/LICENSE,sha256=ic-27cMJc1kWoMEYncz3Ya3Ur2Bi3bNLWib2DT763-o,1067
-pyg_nightly-2.7.0.dev20250504.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyg_nightly-2.7.0.dev20250504.dist-info/METADATA,sha256=xhjWav-LGW_50rzAl-sv3_1PoXWiwfWSOt72KhW_8nI,62979
-pyg_nightly-2.7.0.dev20250504.dist-info/RECORD,,
+pyg_nightly-2.7.0.dev20250505.dist-info/licenses/LICENSE,sha256=ic-27cMJc1kWoMEYncz3Ya3Ur2Bi3bNLWib2DT763-o,1067
+pyg_nightly-2.7.0.dev20250505.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyg_nightly-2.7.0.dev20250505.dist-info/METADATA,sha256=JqptxbND3anHymFM2E5zV7xbDWSmL7mf9V5YVQkoJmk,62979
+pyg_nightly-2.7.0.dev20250505.dist-info/RECORD,,

torch_geometric/__init__.py

@@ -31,7 +31,7 @@ from .lazy_loader import LazyLoader
 contrib = LazyLoader('contrib', globals(), 'torch_geometric.contrib')
 graphgym = LazyLoader('graphgym', globals(), 'torch_geometric.graphgym')
 
-__version__ = '2.7.0.dev20250504'
+__version__ = '2.7.0.dev20250505'
 
 __all__ = [
     'Index',
@@ -57,6 +57,13 @@ __all__ = [
     '__version__',
 ]
 
+if not torch_geometric.typing.WITH_PT113:
+    import warnings as std_warnings
+
+    std_warnings.warn("PyG 2.7 removed support for PyTorch < 1.13. Consider "
+                      "Consider upgrading to PyTorch >= 1.13 or downgrading "
+                      "to PyG <= 2.6. ")
+
 # Serialization ###############################################################
 
 if torch_geometric.typing.WITH_PT24:

torch_geometric/data/collate.py

@@ -191,10 +191,8 @@ def _collate(
             if torch_geometric.typing.WITH_PT20:
                 storage = elem.untyped_storage()._new_shared(
                     numel * elem.element_size(), device=elem.device)
-            elif torch_geometric.typing.WITH_PT112:
-                storage = elem.storage()._new_shared(numel, device=elem.device)
             else:
-                storage = elem.storage()._new_shared(numel)
+                storage = elem.storage()._new_shared(numel, device=elem.device)
             shape = list(elem.size())
             if cat_dim is None or elem.dim() == 0:
                 shape = [len(values)] + shape

torch_geometric/edge_index.py

@@ -298,8 +298,7 @@ class EdgeIndex(Tensor):
                 indptr = None
             data = torch.stack([row, col], dim=0)
 
-        if (torch_geometric.typing.WITH_PT112
-                and data.layout == torch.sparse_csc):
+        if data.layout == torch.sparse_csc:
             row = data.row_indices()
             indptr = data.ccol_indices()
 
@@ -882,10 +881,6 @@ class EdgeIndex(Tensor):
                 If not specified, non-zero elements will be assigned a value of
                 :obj:`1.0`. (default: :obj:`None`)
         """
-        if not torch_geometric.typing.WITH_PT112:
-            raise NotImplementedError(
-                "'to_sparse_csc' not supported for PyTorch < 1.12")
-
         (colptr, row), perm = self.get_csc()
         if value is not None and perm is not None:
             value = value[perm]
@@ -922,7 +917,7 @@ class EdgeIndex(Tensor):
             return self.to_sparse_coo(value)
         if layout == torch.sparse_csr:
             return self.to_sparse_csr(value)
-        if torch_geometric.typing.WITH_PT112 and layout == torch.sparse_csc:
+        if layout == torch.sparse_csc:
             return self.to_sparse_csc(value)
 
         raise ValueError(f"Unexpected tensor layout (got '{layout}')")

torch_geometric/nn/dense/linear.py

@@ -1,4 +1,3 @@
-import copy
 import math
 import sys
 import time
@@ -114,25 +113,6 @@ class Linear(torch.nn.Module):
 
         self.reset_parameters()
 
-    def __deepcopy__(self, memo):
-        # PyTorch<1.13 cannot handle deep copies of uninitialized parameters :(
-        # TODO Drop this code once PyTorch 1.12 is no longer supported.
-        out = Linear(
-            self.in_channels,
-            self.out_channels,
-            self.bias is not None,
-            self.weight_initializer,
-            self.bias_initializer,
-        ).to(self.weight.device)
-
-        if self.in_channels > 0:
-            out.weight = copy.deepcopy(self.weight, memo)
-
-        if self.bias is not None:
-            out.bias = copy.deepcopy(self.bias, memo)
-
-        return out
-
     def reset_parameters(self):
         r"""Resets all learnable parameters of the module."""
         reset_weight_(self.weight, self.in_channels, self.weight_initializer)

torch_geometric/nn/pool/connect/base.py

@@ -4,7 +4,6 @@ from typing import Optional
 import torch
 from torch import Tensor
 
-import torch_geometric.typing
 from torch_geometric.nn.pool.select import SelectOutput
 
 
@@ -49,8 +48,7 @@ class ConnectOutput:
         self.batch = batch
 
 
-if torch_geometric.typing.WITH_PT113:
-    ConnectOutput = torch.jit.script(ConnectOutput)
+ConnectOutput = torch.jit.script(ConnectOutput)
 
 
 class Connect(torch.nn.Module):

torch_geometric/nn/pool/select/base.py

@@ -4,8 +4,6 @@ from typing import Optional
 import torch
 from torch import Tensor
 
-import torch_geometric.typing
-
 
 @dataclass(init=False)
 class SelectOutput:
@@ -64,8 +62,7 @@ class SelectOutput:
         self.weight = weight
 
 
-if torch_geometric.typing.WITH_PT113:
-    SelectOutput = torch.jit.script(SelectOutput)
+SelectOutput = torch.jit.script(SelectOutput)
 
 
 class Select(torch.nn.Module):

torch_geometric/typing.py

@@ -21,8 +21,6 @@ WITH_PT23 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 3
 WITH_PT24 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 4
 WITH_PT25 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 5
 WITH_PT26 = WITH_PT20 and int(torch.__version__.split('.')[1]) >= 6
-WITH_PT111 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 11
-WITH_PT112 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 12
 WITH_PT113 = WITH_PT20 or int(torch.__version__.split('.')[1]) >= 13
 
 WITH_WINDOWS = os.name == 'nt'

torch_geometric/utils/_lexsort.py

@@ -1,11 +1,7 @@
 from typing import List
 
-import numpy as np
-import torch
 from torch import Tensor
 
-import torch_geometric.typing
-
 
 def lexsort(
     keys: List[Tensor],
@@ -28,11 +24,6 @@ def lexsort(
     """
     assert len(keys) >= 1
 
-    if not torch_geometric.typing.WITH_PT113:
-        keys = [k.neg() for k in keys] if descending else keys
-        out = np.lexsort([k.detach().cpu().numpy() for k in keys], axis=dim)
-        return torch.from_numpy(out).to(keys[0].device)
-
     out = keys[0].argsort(dim=dim, descending=descending, stable=True)
     for k in keys[1:]:
         index = k.gather(dim, out)

torch_geometric/utils/_scatter.py

@@ -8,185 +8,132 @@ from torch_geometric import is_compiling, is_in_onnx_export, warnings
 from torch_geometric.typing import torch_scatter
 from torch_geometric.utils.functions import cumsum
 
-if torch_geometric.typing.WITH_PT112:  # pragma: no cover
-
-    warnings.filterwarnings('ignore', '.*is in beta and the API may change.*')
-
-    def scatter(
-        src: Tensor,
-        index: Tensor,
-        dim: int = 0,
-        dim_size: Optional[int] = None,
-        reduce: str = 'sum',
-    ) -> Tensor:
-        r"""Reduces all values from the :obj:`src` tensor at the indices
-        specified in the :obj:`index` tensor along a given dimension
-        :obj:`dim`. See the `documentation
-        <https://pytorch-scatter.readthedocs.io/en/latest/functions/
-        scatter.html>`__ of the :obj:`torch_scatter` package for more
-        information.
-
-        Args:
-            src (torch.Tensor): The source tensor.
-            index (torch.Tensor): The index tensor.
-            dim (int, optional): The dimension along which to index.
-                (default: :obj:`0`)
-            dim_size (int, optional): The size of the output tensor at
-                dimension :obj:`dim`. If set to :obj:`None`, will create a
-                minimal-sized output tensor according to
-                :obj:`index.max() + 1`. (default: :obj:`None`)
-            reduce (str, optional): The reduce operation (:obj:`"sum"`,
-                :obj:`"mean"`, :obj:`"mul"`, :obj:`"min"` or :obj:`"max"`,
-                :obj:`"any"`). (default: :obj:`"sum"`)
-        """
-        if isinstance(index, Tensor) and index.dim() != 1:
-            raise ValueError(f"The `index` argument must be one-dimensional "
-                             f"(got {index.dim()} dimensions)")
-
-        dim = src.dim() + dim if dim < 0 else dim
-
-        if isinstance(src, Tensor) and (dim < 0 or dim >= src.dim()):
-            raise ValueError(f"The `dim` argument must lay between 0 and "
-                             f"{src.dim() - 1} (got {dim})")
-
-        if dim_size is None:
-            dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
-
-        # For now, we maintain various different code paths, based on whether
-        # the input requires gradients and whether it lays on the CPU/GPU.
-        # For example, `torch_scatter` is usually faster than
-        # `torch.scatter_reduce` on GPU, while `torch.scatter_reduce` is faster
-        # on CPU.
-        # `torch.scatter_reduce` has a faster forward implementation for
-        # "min"/"max" reductions since it does not compute additional arg
-        # indices, but is therefore way slower in its backward implementation.
-        # More insights can be found in `test/utils/test_scatter.py`.
-
-        size = src.size()[:dim] + (dim_size, ) + src.size()[dim + 1:]
-
-        # For "any" reduction, we use regular `scatter_`:
-        if reduce == 'any':
-            index = broadcast(index, src, dim)
-            return src.new_zeros(size).scatter_(dim, index, src)
+warnings.filterwarnings('ignore', '.*is in beta and the API may change.*')
 
-        # For "sum" and "mean" reduction, we make use of `scatter_add_`:
-        if reduce == 'sum' or reduce == 'add':
-            index = broadcast(index, src, dim)
-            return src.new_zeros(size).scatter_add_(dim, index, src)
 
-        if reduce == 'mean':
-            count = src.new_zeros(dim_size)
-            count.scatter_add_(0, index, src.new_ones(src.size(dim)))
-            count = count.clamp(min=1)
+def scatter(
+    src: Tensor,
+    index: Tensor,
+    dim: int = 0,
+    dim_size: Optional[int] = None,
+    reduce: str = 'sum',
+) -> Tensor:
+    r"""Reduces all values from the :obj:`src` tensor at the indices specified
+    in the :obj:`index` tensor along a given dimension ``dim``. See the
+    `documentation <https://pytorch-scatter.readthedocs.io/en/latest/functions/scatter.html>`__  # noqa: E501
+    of the ``torch_scatter`` package for more information.
 
-            index = broadcast(index, src, dim)
-            out = src.new_zeros(size).scatter_add_(dim, index, src)
-
-            return out / broadcast(count, out, dim)
-
-        # For "min" and "max" reduction, we prefer `scatter_reduce_` on CPU or
-        # in case the input does not require gradients:
-        if reduce in ['min', 'max', 'amin', 'amax']:
-            if (not torch_geometric.typing.WITH_TORCH_SCATTER
-                    or is_compiling() or is_in_onnx_export() or not src.is_cuda
-                    or not src.requires_grad):
-
-                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")
-
-                index = broadcast(index, src, dim)
-                if not is_in_onnx_export():
-                    return src.new_zeros(size).scatter_reduce_(
-                        dim, index, src, reduce=f'a{reduce[-3:]}',
-                        include_self=False)
-
-                fill = torch.full(  # type: ignore
-                    size=(1, ),
-                    fill_value=src.min() if 'max' in reduce else src.max(),
-                    dtype=src.dtype,
-                    device=src.device,
-                ).expand_as(src)
-                out = src.new_zeros(size).scatter_reduce_(
-                    dim, index, fill, reduce=f'a{reduce[-3:]}',
-                    include_self=True)
-                return out.scatter_reduce_(dim, index, src,
-                                           reduce=f'a{reduce[-3:]}',
-                                           include_self=True)
-
-            return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
-                                         reduce=reduce[-3:])
-
-        # For "mul" reduction, we prefer `scatter_reduce_` on CPU:
-        if reduce == 'mul':
-            if (not torch_geometric.typing.WITH_TORCH_SCATTER
-                    or is_compiling() 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")
-
-                index = broadcast(index, src, dim)
-                # We initialize with `one` here to match `scatter_mul` output:
-                return src.new_ones(size).scatter_reduce_(
-                    dim, index, src, reduce='prod', include_self=True)
-
-            return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
-                                         reduce='mul')
-
-        raise ValueError(f"Encountered invalid `reduce` argument '{reduce}'")
-
-else:  # pragma: no cover
-
-    def scatter(
-        src: Tensor,
-        index: Tensor,
-        dim: int = 0,
-        dim_size: Optional[int] = None,
-        reduce: str = 'sum',
-    ) -> Tensor:
-        r"""Reduces all values from the :obj:`src` tensor at the indices
-        specified in the :obj:`index` tensor along a given dimension
-        :obj:`dim`. See the `documentation
-        <https://pytorch-scatter.readthedocs.io/en/latest/functions/
-        scatter.html>`_ of the :obj:`torch_scatter` package for more
-        information.
-
-        Args:
-            src (torch.Tensor): The source tensor.
-            index (torch.Tensor): The index tensor.
-            dim (int, optional): The dimension along which to index.
-                (default: :obj:`0`)
-            dim_size (int, optional): The size of the output tensor at
-                dimension :obj:`dim`. If set to :obj:`None`, will create a
-                minimal-sized output tensor according to
-                :obj:`index.max() + 1`. (default: :obj:`None`)
-            reduce (str, optional): The reduce operation (:obj:`"sum"`,
-                :obj:`"mean"`, :obj:`"mul"`, :obj:`"min"` or :obj:`"max"`,
-                :obj:`"any"`). (default: :obj:`"sum"`)
-        """
-        if reduce == 'any':
-            dim = src.dim() + dim if dim < 0 else dim
-
-            if dim_size is None:
-                dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
-
-            size = src.size()[:dim] + (dim_size, ) + src.size()[dim + 1:]
+    Args:
+        src (torch.Tensor): The source tensor.
+        index (torch.Tensor): The index tensor.
+        dim (int, optional): The dimension along which to index.
+            (default: ``0``)
+        dim_size (int, optional): The size of the output tensor at dimension
+            ``dim``. If set to :obj:`None`, will create a minimal-sized output
+            tensor according to ``index.max() + 1``. (default: :obj:`None`)
+        reduce (str, optional): The reduce operation (``"sum"``, ``"mean"``,
+            ``"mul"``, ``"min"``, ``"max"`` or ``"any"``). (default: ``"sum"``)
+    """
+    if isinstance(index, Tensor) and index.dim() != 1:
+        raise ValueError(f"The `index` argument must be one-dimensional "
+                         f"(got {index.dim()} dimensions)")
+
+    dim = src.dim() + dim if dim < 0 else dim
+
+    if isinstance(src, Tensor) and (dim < 0 or dim >= src.dim()):
+        raise ValueError(f"The `dim` argument must lay between 0 and "
+                         f"{src.dim() - 1} (got {dim})")
+
+    if dim_size is None:
+        dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
+
+    # For now, we maintain various different code paths, based on whether
+    # the input requires gradients and whether it lays on the CPU/GPU.
+    # For example, `torch_scatter` is usually faster than
+    # `torch.scatter_reduce` on GPU, while `torch.scatter_reduce` is faster
+    # on CPU.
+    # `torch.scatter_reduce` has a faster forward implementation for
+    # "min"/"max" reductions since it does not compute additional arg
+    # indices, but is therefore way slower in its backward implementation.
+    # More insights can be found in `test/utils/test_scatter.py`.
+
+    size = src.size()[:dim] + (dim_size, ) + src.size()[dim + 1:]
+
+    # For "any" reduction, we use regular `scatter_`:
+    if reduce == 'any':
+        index = broadcast(index, src, dim)
+        return src.new_zeros(size).scatter_(dim, index, src)
+
+    # For "sum" and "mean" reduction, we make use of `scatter_add_`:
+    if reduce == 'sum' or reduce == 'add':
+        index = broadcast(index, src, dim)
+        return src.new_zeros(size).scatter_add_(dim, index, src)
+
+    if reduce == 'mean':
+        count = src.new_zeros(dim_size)
+        count.scatter_add_(0, index, src.new_ones(src.size(dim)))
+        count = count.clamp(min=1)
+
+        index = broadcast(index, src, dim)
+        out = src.new_zeros(size).scatter_add_(dim, index, src)
+
+        return out / broadcast(count, out, dim)
+
+    # For "min" and "max" reduction, we prefer `scatter_reduce_` on CPU or
+    # in case the input does not require gradients:
+    if reduce in ['min', 'max', 'amin', 'amax']:
+        if (not torch_geometric.typing.WITH_TORCH_SCATTER or is_compiling()
+                or is_in_onnx_export() or not src.is_cuda
+                or not src.requires_grad):
+
+            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")
 
             index = broadcast(index, src, dim)
-            return src.new_zeros(size).scatter_(dim, index, src)
+            if not is_in_onnx_export():
+                return src.new_zeros(size).scatter_reduce_(
+                    dim, index, src, reduce=f'a{reduce[-3:]}',
+                    include_self=False)
+
+            fill = torch.full(  # type: ignore
+                size=(1, ),
+                fill_value=src.min() if 'max' in reduce else src.max(),
+                dtype=src.dtype,
+                device=src.device,
+            ).expand_as(src)
+            out = src.new_zeros(size).scatter_reduce_(dim, index, fill,
+                                                      reduce=f'a{reduce[-3:]}',
+                                                      include_self=True)
+            return out.scatter_reduce_(dim, index, src,
+                                       reduce=f'a{reduce[-3:]}',
+                                       include_self=True)
 
-        if not torch_geometric.typing.WITH_TORCH_SCATTER:
-            raise ImportError("'scatter' requires the 'torch-scatter' package")
+        return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
+                                     reduce=reduce[-3:])
+
+    # For "mul" reduction, we prefer `scatter_reduce_` on CPU:
+    if reduce == 'mul':
+        if (not torch_geometric.typing.WITH_TORCH_SCATTER or is_compiling()
+                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")
 
-        if reduce == 'amin' or reduce == 'amax':
-            reduce = reduce[-3:]
+            index = broadcast(index, src, dim)
+            # We initialize with `one` here to match `scatter_mul` output:
+            return src.new_ones(size).scatter_reduce_(dim, index, src,
+                                                      reduce='prod',
+                                                      include_self=True)
 
         return torch_scatter.scatter(src, index, dim, dim_size=dim_size,
-                                     reduce=reduce)
+                                     reduce='mul')
+
+    raise ValueError(f"Encountered invalid `reduce` argument '{reduce}'")
 
 
 def broadcast(src: Tensor, ref: Tensor, dim: int) -> Tensor:
@@ -215,24 +162,18 @@ def scatter_argmax(
     if dim_size is None:
         dim_size = int(index.max()) + 1 if index.numel() > 0 else 0
 
-    if torch_geometric.typing.WITH_PT112:
-        if not is_in_onnx_export():
-            res = src.new_empty(dim_size)
-            res.scatter_reduce_(0, index, src.detach(), reduce='amax',
-                                include_self=False)
-        else:
-            # `include_self=False` is currently not supported by ONNX:
-            res = src.new_full(
-                size=(dim_size, ),
-                fill_value=src.min(),  # type: ignore
-            )
-            res.scatter_reduce_(0, index, src.detach(), reduce="amax",
-                                include_self=True)
-    elif torch_geometric.typing.WITH_PT111:
-        res = torch.scatter_reduce(src.detach(), 0, index, reduce='amax',
-                                   output_size=dim_size)  # type: ignore
+    if not is_in_onnx_export():
+        res = src.new_empty(dim_size)
+        res.scatter_reduce_(0, index, src.detach(), reduce='amax',
+                            include_self=False)
     else:
-        raise ValueError("'scatter_argmax' requires PyTorch >= 1.11")
+        # `include_self=False` is currently not supported by ONNX:
+        res = src.new_full(
+            size=(dim_size, ),
+            fill_value=src.min(),  # type: ignore
+        )
+        res.scatter_reduce_(0, index, src.detach(), reduce="amax",
+                            include_self=True)
 
     out = index.new_full((dim_size, ), fill_value=dim_size - 1)
     nonzero = (src == res[index]).nonzero().view(-1)
@@ -290,13 +231,7 @@ def group_argsort(
 
     # Compute `grouped_argsort`:
     src = src - 2 * index if descending else src + 2 * index
-    if torch_geometric.typing.WITH_PT113:
-        perm = src.argsort(descending=descending, stable=stable)
-    else:
-        perm = src.argsort(descending=descending)
-        if stable:
-            warnings.warn("Ignoring option `stable=True` in 'group_argsort' "
-                          "since it requires PyTorch >= 1.13.0")
+    perm = src.argsort(descending=descending, stable=stable)
     out = torch.empty_like(index)
     out[perm] = torch.arange(index.numel(), device=index.device)
 

torch_geometric/utils/_sort_edge_index.py

@@ -107,8 +107,6 @@ def sort_edge_index(  # noqa: F811
     num_nodes = maybe_num_nodes(edge_index, num_nodes)
 
     if num_nodes * num_nodes > torch_geometric.typing.MAX_INT64:
-        if not torch_geometric.typing.WITH_PT113:
-            raise ValueError("'sort_edge_index' will result in an overflow")
         perm = lexsort(keys=[
             edge_index[int(sort_by_row)],
             edge_index[1 - int(sort_by_row)],

torch_geometric/utils/_spmm.py

@@ -115,8 +115,7 @@ def spmm(
         if src.layout == torch.sparse_csr:
             ptr = src.crow_indices()
             deg = ptr[1:] - ptr[:-1]
-        elif (torch_geometric.typing.WITH_PT112
-              and src.layout == torch.sparse_csc):
+        elif src.layout == torch.sparse_csc:
             assert src.layout == torch.sparse_csc
             ones = torch.ones_like(src.values())
             index = src.row_indices()

torch_geometric/utils/sparse.py

@@ -1,4 +1,3 @@
-import typing
 import warnings
 from typing import Any, List, Optional, Tuple, Union
 
@@ -124,8 +123,7 @@ def is_torch_sparse_tensor(src: Any) -> bool:
             return True
         if src.layout == torch.sparse_csr:
             return True
-        if (torch_geometric.typing.WITH_PT112
-                and src.layout == torch.sparse_csc):
+        if src.layout == torch.sparse_csc:
             return True
     return False
 
@@ -320,12 +318,6 @@ def to_torch_csc_tensor(
                size=(4, 4), nnz=6, layout=torch.sparse_csc)
 
     """
-    if not torch_geometric.typing.WITH_PT112:
-        if typing.TYPE_CHECKING:
-            raise NotImplementedError
-        return torch_geometric.typing.MockTorchCSCTensor(
-            edge_index, edge_attr, size)
-
     if size is None:
         size = int(edge_index.max()) + 1
 
@@ -392,7 +384,7 @@ def to_torch_sparse_tensor(
         return to_torch_coo_tensor(edge_index, edge_attr, size, is_coalesced)
     if layout == torch.sparse_csr:
         return to_torch_csr_tensor(edge_index, edge_attr, size, is_coalesced)
-    if torch_geometric.typing.WITH_PT112 and layout == torch.sparse_csc:
+    if layout == torch.sparse_csc:
         return to_torch_csc_tensor(edge_index, edge_attr, size, is_coalesced)
 
     raise ValueError(f"Unexpected sparse tensor layout (got '{layout}')")
@@ -431,7 +423,7 @@ def to_edge_index(adj: Union[Tensor, SparseTensor]) -> Tuple[Tensor, Tensor]:
         col = adj.col_indices().detach()
         return torch.stack([row, col], dim=0).long(), adj.values()
 
-    if torch_geometric.typing.WITH_PT112 and adj.layout == torch.sparse_csc:
+    if adj.layout == torch.sparse_csc:
         col = ptr2index(adj.ccol_indices().detach())
         row = adj.row_indices().detach()
         return torch.stack([row, col], dim=0).long(), adj.values()
@@ -480,7 +472,7 @@ def set_sparse_value(adj: Tensor, value: Tensor) -> Tensor:
             device=value.device,
         )
 
-    if torch_geometric.typing.WITH_PT112 and adj.layout == torch.sparse_csc:
+    if adj.layout == torch.sparse_csc:
         return torch.sparse_csc_tensor(
             ccol_indices=adj.ccol_indices(),
             row_indices=adj.row_indices(),