pyg-nightly 2.6.0.dev20240511__py3-none-any.whl → 2.7.0.dev20250114__py3-none-any.whl

{pyg_nightly-2.6.0.dev20240511.dist-info → pyg_nightly-2.7.0.dev20250114.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.10.1
 Root-Is-Purelib: true
 Tag: py3-none-any

torch_geometric/__init__.py

@@ -1,8 +1,15 @@
+from collections import defaultdict
+
+import torch
+import torch_geometric.typing
+
 from ._compile import compile, is_compiling
+from ._onnx import is_in_onnx_export
 from .index import Index
 from .edge_index import EdgeIndex
 from .seed import seed_everything
 from .home import get_home_dir, set_home_dir
+from .device import is_mps_available, is_xpu_available, device
 from .isinstance import is_torch_instance
 from .debug import is_debug_enabled, debug, set_debug
 
@@ -23,7 +30,7 @@ from .lazy_loader import LazyLoader
 contrib = LazyLoader('contrib', globals(), 'torch_geometric.contrib')
 graphgym = LazyLoader('graphgym', globals(), 'torch_geometric.graphgym')
 
-__version__ = '2.6.0.dev20240511'
+__version__ = '2.7.0.dev20250114'
 
 __all__ = [
     'Index',
@@ -33,6 +40,10 @@ __all__ = [
     'set_home_dir',
     'compile',
     'is_compiling',
+    'is_in_onnx_export',
+    'is_mps_available',
+    'is_xpu_available',
+    'device',
     'is_torch_instance',
     'is_debug_enabled',
     'debug',
@@ -43,3 +54,17 @@ __all__ = [
     'torch_geometric',
     '__version__',
 ]
+
+# Serialization ###############################################################
+
+if torch_geometric.typing.WITH_PT24:
+    torch.serialization.add_safe_globals([
+        dict,
+        list,
+        defaultdict,
+        Index,
+        torch_geometric.index.CatMetadata,
+        EdgeIndex,
+        torch_geometric.edge_index.SortOrder,
+        torch_geometric.edge_index.CatMetadata,
+    ])

torch_geometric/_compile.py

@@ -10,6 +10,8 @@ def is_compiling() -> bool:
     r"""Returns :obj:`True` in case :pytorch:`PyTorch` is compiling via
     :meth:`torch.compile`.
     """
+    if torch_geometric.typing.WITH_PT23:
+        return torch.compiler.is_compiling()
     if torch_geometric.typing.WITH_PT21:
         return torch._dynamo.is_compiling()
     return False  # pragma: no cover
@@ -25,10 +27,15 @@ def compile(
     This function has the same signature as :meth:`torch.compile` (see
     `here <https://pytorch.org/docs/stable/generated/torch.compile.html>`__).
 
+    Args:
+        model: The model to compile.
+        *args: Additional arguments of :meth:`torch.compile`.
+        **kwargs: Additional keyword arguments of :meth:`torch.compile`.
+
     .. note::
         :meth:`torch_geometric.compile` is deprecated in favor of
         :meth:`torch.compile`.
     """
     warnings.warn("'torch_geometric.compile' is deprecated in favor of "
                   "'torch.compile'")
-    return torch.compile(model, *args, **kwargs)
+    return torch.compile(model, *args, **kwargs)  # type: ignore

torch_geometric/_onnx.py

@@ -0,0 +1,14 @@
+import torch
+
+from torch_geometric import is_compiling
+
+
+def is_in_onnx_export() -> bool:
+    r"""Returns :obj:`True` in case :pytorch:`PyTorch` is exporting to ONNX via
+    :meth:`torch.onnx.export`.
+    """
+    if is_compiling():
+        return False
+    if torch.jit.is_scripting():
+        return False
+    return torch.onnx.is_in_onnx_export()

torch_geometric/config_mixin.py

@@ -0,0 +1,113 @@
+import inspect
+from dataclasses import fields, is_dataclass
+from importlib import import_module
+from typing import Any, Dict
+
+from torch_geometric.config_store import (
+    class_from_dataclass,
+    dataclass_from_class,
+)
+from torch_geometric.isinstance import is_torch_instance
+
+
+class ConfigMixin:
+    r"""Enables a class to serialize/deserialize itself to a dataclass."""
+    def config(self) -> Any:
+        r"""Creates a serializable configuration of the class."""
+        data_cls = dataclass_from_class(self.__class__)
+        if data_cls is None:
+            raise ValueError(f"Could not find the configuration class that "
+                             f"belongs to '{self.__class__.__name__}'. Please "
+                             f"register it in the configuration store.")
+
+        kwargs: Dict[str, Any] = {}
+        for field in fields(data_cls):
+            if not hasattr(self, field.name):
+                continue
+            kwargs[field.name] = _recursive_config(getattr(self, field.name))
+        return data_cls(**kwargs)
+
+    @classmethod
+    def from_config(cls, cfg: Any, *args: Any, **kwargs: Any) -> Any:
+        r"""Instantiates the class from a serializable configuration."""
+        if getattr(cfg, '_target_', None):
+            cls = _locate_cls(cfg._target_)
+        elif isinstance(cfg, dict) and '_target_' in cfg:
+            cls = _locate_cls(cfg['_target_'])
+
+        data_cls = cfg.__class__
+        if not is_dataclass(data_cls):
+            data_cls = dataclass_from_class(cls)
+            if data_cls is None:
+                raise ValueError(f"Could not find the configuration class "
+                                 f"that belongs to '{cls.__name__}'. Please "
+                                 f"register it in the configuration store.")
+
+        field_names = {field.name for field in fields(data_cls)}
+        if isinstance(cfg, dict):
+            _kwargs = {k: v for k, v in cfg.items() if k in field_names}
+            cfg = data_cls(**_kwargs)
+        assert is_dataclass(cfg)
+
+        if len(args) > 0:  # Convert `*args` to `**kwargs`:
+            param_names = list(inspect.signature(cls).parameters.keys())
+            if 'args' in param_names:
+                param_names.remove('args')
+            if 'kwargs' in param_names:
+                param_names.remove('kwargs')
+
+            for name, arg in zip(param_names, args):
+                kwargs[name] = arg
+
+        for key in field_names:
+            if key not in kwargs and key != '_target_':
+                kwargs[key] = _recursive_from_config(getattr(cfg, key))
+
+        return cls(**kwargs)
+
+
+def _recursive_config(value: Any) -> Any:
+    if isinstance(value, ConfigMixin):
+        return value.config()
+    if is_torch_instance(value, ConfigMixin):
+        return value.config()
+    if isinstance(value, (tuple, list)):
+        return [_recursive_config(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _recursive_config(v) for k, v in value.items()}
+    return value
+
+
+def _recursive_from_config(value: Any) -> Any:
+    cls: Any = None
+    if is_dataclass(value):
+        if getattr(value, '_target_', None):
+            try:
+                cls = _locate_cls(value._target_)  # type: ignore
+            except ImportError:
+                pass  # Keep the dataclass as it is.
+        else:
+            cls = class_from_dataclass(value.__class__)
+    elif isinstance(value, dict) and '_target_' in value:
+        cls = _locate_cls(value['_target_'])
+
+    if cls is not None and issubclass(cls, ConfigMixin):
+        return cls.from_config(value)
+    if isinstance(value, (tuple, list)):
+        return [_recursive_from_config(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _recursive_from_config(v) for k, v in value.items()}
+    return value
+
+
+def _locate_cls(qualname: str) -> Any:
+    parts = qualname.split('.')
+
+    if len(parts) <= 1:
+        raise ValueError(f"Qualified name is missing a dot (got '{qualname}')")
+
+    if any([len(part) == 0 for part in parts]):
+        raise ValueError(f"Relative imports not supported (got '{qualname}')")
+
+    module_name, cls_name = '.'.join(parts[:-1]), parts[-1]
+    return getattr(import_module(module_name), cls_name)

torch_geometric/config_store.py

@@ -76,7 +76,7 @@ else:
 
         def __call__(cls, *args: Any, **kwargs: Any) -> Any:
             if cls not in cls._instances:
-                instance = super(Singleton, cls).__call__(*args, **kwargs)
+                instance = super().__call__(*args, **kwargs)
                 cls._instances[cls] = instance
                 return instance
             return cls._instances[cls]
@@ -238,7 +238,7 @@ def to_dataclass(
     if strict:  # Check that keys in map_args or exclude_args are present.
         keys = set() if map_args is None else set(map_args.keys())
         if exclude_args is not None:
-            keys |= set([arg for arg in exclude_args if isinstance(arg, str)])
+            keys |= {arg for arg in exclude_args if isinstance(arg, str)}
         diff = keys - set(params.keys())
         if len(diff) > 0:
             raise ValueError(f"Expected input argument(s) {diff} in "
@@ -413,13 +413,13 @@ def fill_config_store() -> None:
 
     # Register `torch_geometric.transforms` ###################################
     transforms = torch_geometric.transforms
-    for cls_name in set(transforms.__all__) - set([
+    for cls_name in set(transforms.__all__) - {
             'BaseTransform',
             'Compose',
             'ComposeFilters',
             'LinearTransformation',
             'AddMetaPaths',  # TODO
-    ]):
+    }:
         cls = to_dataclass(getattr(transforms, cls_name), base_cls=Transform)
         # We use an explicit additional nesting level inside each config to
         # allow for applying multiple transformations.
@@ -433,7 +433,7 @@ def fill_config_store() -> None:
         'pre_transform': (Dict[str, Transform], field(default_factory=dict)),
     }
 
-    for cls_name in set(datasets.__all__) - set([]):
+    for cls_name in set(datasets.__all__) - set():
         cls = to_dataclass(getattr(datasets, cls_name), base_cls=Dataset,
                            map_args=map_dataset_args,
                            exclude_args=['pre_filter'])
@@ -441,32 +441,34 @@ def fill_config_store() -> None:
 
     # Register `torch_geometric.models` #######################################
     models = torch_geometric.nn.models.basic_gnn
-    for cls_name in set(models.__all__) - set([]):
+    for cls_name in set(models.__all__) - set():
         cls = to_dataclass(getattr(models, cls_name), base_cls=Model)
         config_store.store(cls_name, group='model', node=cls)
 
     # Register `torch.optim.Optimizer` ########################################
-    for cls_name in set([
-            key for key, cls in torch.optim.__dict__.items()
+    for cls_name in {
+            key
+            for key, cls in torch.optim.__dict__.items()
             if inspect.isclass(cls) and issubclass(cls, torch.optim.Optimizer)
-    ]) - set([
+    } - {
             'Optimizer',
-    ]):
+    }:
         cls = to_dataclass(getattr(torch.optim, cls_name), base_cls=Optimizer,
                            exclude_args=['params'])
         config_store.store(cls_name, group='optimizer', node=cls)
 
     # Register `torch.optim.lr_scheduler` #####################################
-    for cls_name in set([
-            key for key, cls in torch.optim.lr_scheduler.__dict__.items()
+    for cls_name in {
+            key
+            for key, cls in torch.optim.lr_scheduler.__dict__.items()
             if inspect.isclass(cls)
-    ]) - set([
+    } - {
             'Optimizer',
             '_LRScheduler',
             'Counter',
             'SequentialLR',
             'ChainedScheduler',
-    ]):
+    }:
         cls = to_dataclass(getattr(torch.optim.lr_scheduler, cls_name),
                            base_cls=LRScheduler, exclude_args=['optimizer'])
         config_store.store(cls_name, group='lr_scheduler', node=cls)

torch_geometric/data/__init__.py

@@ -1,7 +1,10 @@
 # flake8: noqa
 
+import torch
+import torch_geometric.typing
+
 from .feature_store import FeatureStore, TensorAttr
-from .graph_store import GraphStore, EdgeAttr
+from .graph_store import GraphStore, EdgeAttr, EdgeLayout
 from .data import Data
 from .hetero_data import HeteroData
 from .batch import Batch
@@ -13,6 +16,7 @@ from .on_disk_dataset import OnDiskDataset
 from .makedirs import makedirs
 from .download import download_url, download_google_url
 from .extract import extract_tar, extract_zip, extract_bz2, extract_gz
+from .large_graph_indexer import LargeGraphIndexer, TripletLike, get_features_for_triplets, get_features_for_triplets_groups
 
 from torch_geometric.lazy_loader import LazyLoader
 
@@ -24,6 +28,8 @@ data_classes = [
     'Dataset',
     'InMemoryDataset',
     'OnDiskDataset',
+    'LargeGraphIndexer',
+    'TripletLike',
 ]
 
 remote_backend_classes = [
@@ -47,6 +53,8 @@ helper_functions = [
     'extract_zip',
     'extract_bz2',
     'extract_gz',
+    'get_features_for_triplets',
+    "get_features_for_triplets_groups",
 ]
 
 __all__ = data_classes + remote_backend_classes + helper_functions
@@ -68,6 +76,21 @@ from torch_geometric.loader import DataLoader
 from torch_geometric.loader import DataListLoader
 from torch_geometric.loader import DenseDataLoader
 
+# Serialization ###############################################################
+
+if torch_geometric.typing.WITH_PT24:
+    torch.serialization.add_safe_globals([
+        Data,
+        HeteroData,
+        TemporalData,
+        ClusterData,
+        TensorAttr,
+        EdgeAttr,
+        EdgeLayout,
+    ])
+
+# Deprecations ################################################################
+
 NeighborSampler = deprecated(  # type: ignore
     details="use 'loader.NeighborSampler' instead",
     func_name='data.NeighborSampler',

torch_geometric/data/batch.py

@@ -118,8 +118,8 @@ class Batch(metaclass=DynamicInheritance):
         """
         if not hasattr(self, '_slice_dict'):
             raise RuntimeError(
-                ("Cannot reconstruct 'Data' object from 'Batch' because "
-                 "'Batch' was not created via 'Batch.from_data_list()'"))
+                "Cannot reconstruct 'Data' object from 'Batch' because "
+                "'Batch' was not created via 'Batch.from_data_list()'")
 
         data = separate(
             cls=self.__class__.__bases__[-1],

torch_geometric/data/data.py

@@ -291,13 +291,14 @@ class BaseData:
         self,
         start_time: Union[float, int],
         end_time: Union[float, int],
+        attr: str = 'time',
     ) -> Self:
         r"""Returns a snapshot of :obj:`data` to only hold events that occurred
         in period :obj:`[start_time, end_time]`.
         """
         out = copy.copy(self)
         for store in out.stores:
-            store.snapshot(start_time, end_time)
+            store.snapshot(start_time, end_time, attr)
         return out
 
     def up_to(self, end_time: Union[float, int]) -> Self:
@@ -645,7 +646,7 @@ class Data(BaseData, FeatureStore, GraphStore):
         return self
 
     def __cat_dim__(self, key: str, value: Any, *args, **kwargs) -> Any:
-        if is_sparse(value) and 'adj' in key:
+        if is_sparse(value) and ('adj' in key or 'edge_index' in key):
             return (0, 1)
         elif 'index' in key or key == 'face':
             return -1
@@ -658,7 +659,13 @@ class Data(BaseData, FeatureStore, GraphStore):
                 return value.get_dim_size()
             return int(value.max()) + 1
         elif 'index' in key or key == 'face':
-            return self.num_nodes
+            num_nodes = self.num_nodes
+            if num_nodes is None:
+                raise RuntimeError(f"Unable to infer 'num_nodes' from the "
+                                   f"attribute '{key}'. Please explicitly set "
+                                   f"'num_nodes' as an attribute of 'data' to "
+                                   f"prevent this error")
+            return num_nodes
         else:
             return 0
 
@@ -937,16 +944,14 @@ class Data(BaseData, FeatureStore, GraphStore):
         r"""Iterates over all attributes in the data, yielding their attribute
         names and values.
         """
-        for key, value in self._store.items():
-            yield key, value
+        yield from self._store.items()
 
     def __call__(self, *args: str) -> Iterable:
         r"""Iterates over all attributes :obj:`*args` in the data, yielding
         their attribute names and values.
         If :obj:`*args` is not given, will iterate over all attributes.
         """
-        for key, value in self._store.items(*args):
-            yield key, value
+        yield from self._store.items(*args)
 
     @property
     def x(self) -> Optional[Tensor]:
@@ -1166,7 +1171,7 @@ def size_repr(key: Any, value: Any, indent: int = 0) -> str:
                f'[{value.num_rows}, {value.num_cols}])')
     elif isinstance(value, str):
         out = f"'{value}'"
-    elif isinstance(value, Sequence):
+    elif isinstance(value, (Sequence, set)):
         out = str([len(value)])
     elif isinstance(value, Mapping) and len(value) == 0:
         out = '{}'

torch_geometric/data/database.py

@@ -1,4 +1,4 @@
-import pickle
+import io
 import warnings
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -115,11 +115,9 @@ class Database(ABC):
         r"""Connects to the database.
         Databases will automatically connect on instantiation.
         """
-        pass
 
     def close(self) -> None:
         r"""Closes the connection to the database."""
-        pass
 
     @abstractmethod
     def insert(self, index: int, data: Any) -> None:
@@ -498,7 +496,9 @@ class SQLiteDatabase(Database):
                 out.append(col)
 
             else:
-                out.append(pickle.dumps(col))
+                buffer = io.BytesIO()
+                torch.save(col, buffer)
+                out.append(buffer.getvalue())
 
         return out
 
@@ -561,7 +561,10 @@ class SQLiteDatabase(Database):
                 out_dict[key] = value
 
             else:
-                out_dict[key] = pickle.loads(value)
+                out_dict[key] = torch.load(
+                    io.BytesIO(value),
+                    weights_only=False,
+                )
 
         # In case `0` exists as integer in the schema, this means that the
         # schema was passed as either a single entry or a tuple:
@@ -646,7 +649,12 @@ class RocksDatabase(Database):
         # Ensure that data is not a view of a larger tensor:
         if isinstance(row, Tensor):
             row = row.clone()
-        return pickle.dumps(row)
+        buffer = io.BytesIO()
+        torch.save(row, buffer)
+        return buffer.getvalue()
 
     def _deserialize(self, row: bytes) -> Any:
-        return pickle.loads(row)
+        return torch.load(
+            io.BytesIO(row),
+            weights_only=False,
+        )

torch_geometric/data/dataset.py

@@ -235,7 +235,8 @@ class Dataset(torch.utils.data.Dataset):
 
     def _process(self):
         f = osp.join(self.processed_dir, 'pre_transform.pt')
-        if osp.exists(f) and torch.load(f) != _repr(self.pre_transform):
+        if osp.exists(f) and torch.load(f, weights_only=False) != _repr(
+                self.pre_transform):
             warnings.warn(
                 "The `pre_transform` argument differs from the one used in "
                 "the pre-processed version of this dataset. If you want to "
@@ -243,7 +244,8 @@ class Dataset(torch.utils.data.Dataset):
                 "`force_reload=True` explicitly to reload the dataset.")
 
         f = osp.join(self.processed_dir, 'pre_filter.pt')
-        if osp.exists(f) and torch.load(f) != _repr(self.pre_filter):
+        if osp.exists(f) and torch.load(f, weights_only=False) != _repr(
+                self.pre_filter):
             warnings.warn(
                 "The `pre_filter` argument differs from the one used in "
                 "the pre-processed version of this dataset. If you want to "
@@ -367,15 +369,21 @@ class Dataset(torch.utils.data.Dataset):
         from torch_geometric.data.summary import Summary
         return Summary.from_dataset(self)
 
-    def print_summary(self) -> None:
-        r"""Prints summary statistics of the dataset to the console."""
-        print(str(self.get_summary()))
+    def print_summary(self, fmt: str = "psql") -> None:
+        r"""Prints summary statistics of the dataset to the console.
+
+        Args:
+            fmt (str, optional): Summary tables format. Available table formats
+                can be found `here <https://github.com/astanin/python-tabulate?
+                tab=readme-ov-file#table-format>`__. (default: :obj:`"psql"`)
+        """
+        print(self.get_summary().format(fmt=fmt))
 
     def to_datapipe(self) -> Any:
         r"""Converts the dataset into a :class:`torch.utils.data.DataPipe`.
 
         The returned instance can then be used with :pyg:`PyG's` built-in
-        :class:`DataPipes` for baching graphs as follows:
+        :class:`DataPipes` for batching graphs as follows:
 
         .. code-block:: python
 

torch_geometric/data/feature_store.py

@@ -74,13 +74,6 @@ class TensorAttr(CastMixin):
         r"""Whether the :obj:`TensorAttr` has no unset fields."""
         return all([self.is_set(key) for key in self.__dataclass_fields__])
 
-    def fully_specify(self) -> 'TensorAttr':
-        r"""Sets all :obj:`UNSET` fields to :obj:`None`."""
-        for key in self.__dataclass_fields__:
-            if not self.is_set(key):
-                setattr(self, key, None)
-        return self
-
     def update(self, attr: 'TensorAttr') -> 'TensorAttr':
         r"""Updates an :class:`TensorAttr` with set attributes from another
         :class:`TensorAttr`.
@@ -230,10 +223,11 @@ class AttrView(CastMixin):
 
             store[group_name, attr_name]()
         """
-        # Set all UNSET values to None:
-        out = copy.copy(self)
-        out._attr.fully_specify()
-        return out._store.get_tensor(out._attr)
+        attr = copy.copy(self._attr)
+        for key in attr.__dataclass_fields__:  # Set all UNSET values to None.
+            if not attr.is_set(key):
+                setattr(attr, key, None)
+        return self._store.get_tensor(attr)
 
     def __copy__(self) -> 'AttrView':
         out = self.__class__.__new__(self.__class__)
@@ -283,7 +277,6 @@ class FeatureStore(ABC):
     @abstractmethod
     def _put_tensor(self, tensor: FeatureTensorType, attr: TensorAttr) -> bool:
         r"""To be implemented by :class:`FeatureStore` subclasses."""
-        pass
 
     def put_tensor(self, tensor: FeatureTensorType, *args, **kwargs) -> bool:
         r"""Synchronously adds a :obj:`tensor` to the :class:`FeatureStore`.
@@ -309,7 +302,6 @@ class FeatureStore(ABC):
     @abstractmethod
     def _get_tensor(self, attr: TensorAttr) -> Optional[FeatureTensorType]:
         r"""To be implemented by :class:`FeatureStore` subclasses."""
-        pass
 
     def get_tensor(
         self,
@@ -394,7 +386,6 @@ class FeatureStore(ABC):
     @abstractmethod
     def _remove_tensor(self, attr: TensorAttr) -> bool:
         r"""To be implemented by :obj:`FeatureStore` subclasses."""
-        pass
 
     def remove_tensor(self, *args, **kwargs) -> bool:
         r"""Removes a tensor from the :class:`FeatureStore`.
@@ -452,7 +443,6 @@ class FeatureStore(ABC):
     @abstractmethod
     def get_all_tensor_attrs(self) -> List[TensorAttr]:
         r"""Returns all registered tensor attributes."""
-        pass
 
     # `AttrView` methods ######################################################
 
@@ -483,9 +473,7 @@ class FeatureStore(ABC):
         # CastMixin will handle the case of key being a tuple or TensorAttr
         # object:
         key = self._tensor_attr_cls.cast(key)
-        # We need to fully-specify the key for __setitem__ as it does not make
-        # sense to work with a view here:
-        key.fully_specify()
+        assert key.is_fully_specified()
         self.put_tensor(value, key)
 
     def __getitem__(self, key: TensorAttr) -> Any:
@@ -507,13 +495,16 @@ class FeatureStore(ABC):
         # If the view is not fully-specified, return a :class:`AttrView`:
         return self.view(attr)
 
-    def __delitem__(self, key: TensorAttr):
+    def __delitem__(self, attr: TensorAttr):
         r"""Supports :obj:`del store[tensor_attr]`."""
         # CastMixin will handle the case of key being a tuple or TensorAttr
         # object:
-        key = self._tensor_attr_cls.cast(key)
-        key.fully_specify()
-        self.remove_tensor(key)
+        attr = self._tensor_attr_cls.cast(attr)
+        attr = copy.copy(attr)
+        for key in attr.__dataclass_fields__:  # Set all UNSET values to None.
+            if not attr.is_set(key):
+                setattr(attr, key, None)
+        self.remove_tensor(attr)
 
     def __iter__(self):
         raise NotImplementedError

torch_geometric/data/graph_store.py

@@ -116,7 +116,6 @@ class GraphStore(ABC):
     def _put_edge_index(self, edge_index: EdgeTensorType,
                         edge_attr: EdgeAttr) -> bool:
         r"""To be implemented by :class:`GraphStore` subclasses."""
-        pass
 
     def put_edge_index(self, edge_index: EdgeTensorType, *args,
                        **kwargs) -> bool:
@@ -137,7 +136,6 @@ class GraphStore(ABC):
     @abstractmethod
     def _get_edge_index(self, edge_attr: EdgeAttr) -> Optional[EdgeTensorType]:
         r"""To be implemented by :class:`GraphStore` subclasses."""
-        pass
 
     def get_edge_index(self, *args, **kwargs) -> EdgeTensorType:
         r"""Synchronously obtains an :obj:`edge_index` tuple from the
@@ -160,7 +158,6 @@ class GraphStore(ABC):
     @abstractmethod
     def _remove_edge_index(self, edge_attr: EdgeAttr) -> bool:
         r"""To be implemented by :class:`GraphStore` subclasses."""
-        pass
 
     def remove_edge_index(self, *args, **kwargs) -> bool:
         r"""Synchronously deletes an :obj:`edge_index` tuple from the
@@ -177,7 +174,6 @@ class GraphStore(ABC):
     @abstractmethod
     def get_all_edge_attrs(self) -> List[EdgeAttr]:
         r"""Returns all registered edge attributes."""
-        pass
 
     # Layout Conversion #######################################################