[Misc] Move many deprecated codes to the deprecate folder (#1893)

* some file movements

* move some codes to deprecated

* more deprecation

* lint

* remove useless test

python/dgl/backend/tensorflow/tensor.py

@@ -11,7 +11,7 @@ import numpy as np
 import os
 
 from ... import ndarray as nd
-from ... import kernel as K
+from ..._deprecate import kernel as K
 from ...function.base import TargetCode
 
 if not os.getenv("USE_TFDLPACK", False):

python/dgl/contrib/graph_store.py

@@ -11,7 +11,7 @@ from collections.abc import MutableMapping
 
 from ..base import ALL, is_all, DGLError, dgl_warning
 from .. import backend as F
-from ..graph import DGLGraph
+from .._deprecate.graph import DGLGraph
 from .. import utils
 from ..graph_index import GraphIndex, create_graph_index, from_shared_mem_graph_index
 from .._ffi.ndarray import empty_shared_mem

python/dgl/contrib/sampling/sampler.py

@@ -10,9 +10,9 @@ from ..._ffi.function import _init_api
 from ..._ffi.object import register_object, ObjectBase
 from ..._ffi.ndarray import empty
 from ... import utils
-from ...nodeflow import NodeFlow
+from ..._deprecate.nodeflow import NodeFlow
 from ... import backend as F
-from ...graph import DGLGraph as DGLGraphStale
+from ..._deprecate.graph import DGLGraph as DGLGraphStale
 from ...base import NID, EID, dgl_warning
 
 try:

python/dgl/data/bitcoinotc.py

@@ -5,7 +5,7 @@ import datetime
 
 from .utils import get_download_dir, download, extract_archive
 from ..utils import retry_method_with_fix
-from ..graph import DGLGraph
+from .. import convert
 
 
 class BitcoinOTC(object):
@@ -49,12 +49,10 @@ class BitcoinOTC(object):
         time_index = np.around(
             (data[:, 3] - data[:, 3].min())/delta).astype(np.int64)
         for i in range(time_index.max()):
-            g = DGLGraph()
-            g.add_nodes(num_nodes)
             row_mask = time_index <= i
             edges = data[row_mask][:, 0:2]
             rate = data[row_mask][:, 2]
-            g.add_edges(edges[:, 0], edges[:, 1])
+            g = convert.graph((edges[:, 0], edges[:, 1]))
             g.edata['h'] = rate.reshape(-1, 1)
             self.graphs.append(g)
 

python/dgl/data/gdelt.py

@@ -5,7 +5,7 @@ import datetime
 
 from .utils import get_download_dir, download, extract_archive, loadtxt
 from ..utils import retry_method_with_fix
-from ..graph import DGLGraph
+from .. import convert
 
 
 class GDELT(object):
@@ -78,12 +78,10 @@ class GDELT(object):
         if idx >= len(self) or idx < 0:
             raise IndexError("Index out of range")
         i = idx + self.start_time
-        g = DGLGraph()
-        g.add_nodes(self.num_nodes)
         row_mask = self.time_index <= i
         edges = self.data[row_mask][:, [0, 2]]
         rate = self.data[row_mask][:, 1]
-        g.add_edges(edges[:, 0], edges[:, 1])
+        g = convert.graph((edges[:, 0], edges[:, 1]))
         g.edata['rel_type'] = rate.reshape(-1, 1)
         return g
 

python/dgl/data/gnn_benckmark.py

@@ -3,7 +3,7 @@ import numpy as np
 import os
 from .utils import download, extract_archive, get_download_dir, _get_dgl_url
 from ..utils import retry_method_with_fix
-from ..graph import DGLGraph
+from .. import convert
 
 __all__=["AmazonCoBuy", "Coauthor", 'CoraFull']
 
@@ -59,10 +59,9 @@ class GNNBenchmarkDataset(object):
                 labels = loader['labels']
             else:
                 labels = None
-        g = DGLGraph()
-        g.add_nodes(num_nodes)
-        g.add_edges(adj_matrix.row, adj_matrix.col)
-        g.add_edges(adj_matrix.col, adj_matrix.row)
+        row = np.hstack([adj_matrix.row, adj_matrix.col])
+        col = np.hstack([adj_matrix.col, adj_matrix.row])
+        g = convert.graph((row, col))
         g.ndata['feat'] = attr_matrix
         g.ndata['label'] = labels
         return g     

python/dgl/data/graph_serialize.py

 """For Graph Serialization"""
 from __future__ import absolute_import
 import os
-from ..graph import DGLGraph
+from .._deprecate.graph import DGLGraph
 from ..heterograph import DGLHeteroGraph
 from .._ffi.object import ObjectBase, register_object
 from .._ffi.function import _init_api

python/dgl/data/icews18.py

@@ -6,7 +6,7 @@ import warnings
 
 from .utils import get_download_dir, download, extract_archive, loadtxt
 from ..utils import retry_method_with_fix
-from ..graph import DGLGraph
+from .. import convert
 
 
 class ICEWS18(object):
@@ -75,12 +75,10 @@ class ICEWS18(object):
         start_time = time_index[time_index != -1].min()
         end_time = time_index.max()
         for i in range(start_time, end_time+1):
-            g = DGLGraph()
-            g.add_nodes(num_nodes)
             row_mask = time_index <= i
             edges = data[row_mask][:, [0, 2]]
             rate = data[row_mask][:, 1]
-            g.add_edges(edges[:, 0], edges[:, 1])
+            g = convert.graph((edges[:, 0], edges[:, 1]))
             g.edata['rel_type'] = rate.reshape(-1, 1)
             self.graphs.append(g)
 

python/dgl/data/karate.py

@@ -2,7 +2,7 @@
 """
 import numpy as np
 import networkx as nx
-from ..graph import DGLGraph
+from .. import convert
 
 
 class KarateClub(object):
@@ -19,7 +19,7 @@ class KarateClub(object):
         kG = nx.karate_club_graph()
         self.label = np.asarray(
             [kG.nodes[i]['club'] != 'Mr. Hi' for i in kG.nodes]).astype(np.int64)
-        g = DGLGraph(kG)
+        g = convert.graph(kG)
         g.ndata['label'] = self.label
         self.data = [g]
 

python/dgl/data/qm7b.py

@@ -4,7 +4,7 @@ import os
 
 from .utils import get_download_dir, download
 from ..utils import retry_method_with_fix
-from ..graph import DGLGraph
+from .. import convert
 
 class QM7b(object):
     """
@@ -36,11 +36,8 @@ class QM7b(object):
         num_graphs = labels.shape[0]
         self.label = labels
         for i in range(num_graphs):
-            g = DGLGraph()
             edge_list = feats[i].nonzero()
-            num_nodes = np.max(edge_list) + 1
-            g.add_nodes(num_nodes)
-            g.add_edges(edge_list[0], edge_list[1])
+            g = convert.graph(edge_list)
             g.edata['h'] = feats[i][edge_list[0], edge_list[1]].reshape(-1, 1)
             self.graphs.append(g)
         

python/dgl/function/message.py

@@ -5,8 +5,8 @@ import sys
 from itertools import product
 
 from .base import BuiltinFunction, TargetCode
-from ..runtime import ir
-from ..runtime.ir import var
+from .._deprecate.runtime import ir
+from .._deprecate.runtime.ir import var
 
 
 __all__ = ["src_mul_edge", "copy_src", "copy_edge", "copy_u", "copy_e"]

python/dgl/function/reducer.py

@@ -5,8 +5,8 @@ from __future__ import absolute_import
 import sys
 
 from .base import BuiltinFunction, TargetCode
-from ..runtime import ir
-from ..runtime.ir import var
+from .._deprecate.runtime import ir
+from .._deprecate.runtime.ir import var
 
 
 class ReduceFunction(BuiltinFunction):

python/dgl/heterograph.py

@@ -12,7 +12,7 @@ from . import graph_index
 from . import heterograph_index
 from . import utils
 from . import backend as F
-from .runtime import ir, scheduler, Runtime, GraphAdapter
+from ._deprecate.runtime import ir, scheduler, Runtime, GraphAdapter
 from .frame import Frame, FrameRef, frame_like
 from .view import HeteroNodeView, HeteroNodeDataView, HeteroEdgeView, HeteroEdgeDataView
 from .base import ALL, SLICE_FULL, NTYPE, NID, ETYPE, EID, is_all, DGLError, dgl_warning
@@ -4344,7 +4344,7 @@ class DGLHeteroGraph(object):
                 return F.nonzero_1d(mask)
             else:
                 v = utils.prepare_tensor(self, nodes, 'nodes')
-                return F.boolean_mask(v, mask[v])
+                return F.boolean_mask(v, F.gather_row(mask, v))
 
     def filter_edges(self, predicate, edges=ALL, etype=None):
         """Return a tensor of edge IDs with the given edge type that satisfy
@@ -4391,7 +4391,7 @@ class DGLHeteroGraph(object):
                     e = self.edge_ids(edges[0], edges[1], etype=etype)
                 else:
                     e = utils.prepare_tensor(self, edges, 'edges')
-                return F.boolean_mask(e, mask[e])
+                return F.boolean_mask(e, F.gather_row(mask, e))
 
     def readonly(self, readonly_state=True):
         """Deprecated: DGLGraph will always be mutable."""

python/dgl/network.py

@@ -7,7 +7,7 @@ from collections import namedtuple
 
 import dgl.backend as F
 from ._ffi.function import _init_api
-from .nodeflow import NodeFlow
+from ._deprecate.nodeflow import NodeFlow
 from . import utils
 
 _init_api("dgl.network")

python/dgl/segment.py → python/dgl/ops/segment.py

 """Segment aggregation operators implemented using DGL graph."""
 
-from .base import DGLError
-from . import backend as F
-from . import convert
-from . import function as fn
+from ..base import DGLError
+from .. import backend as F
+from .. import convert
+from .. import function as fn
 
 def segment_reduce(seglen, value, reducer='sum'):
     """Segment reduction operator.

python/dgl/readout.py

@@ -3,7 +3,7 @@ from __future__ import absolute_import
 
 from .base import DGLError
 from . import backend as F
-from . import segment
+from .ops import segment
 
 __all__ = ['readout_nodes', 'readout_edges',
            'sum_nodes', 'sum_edges', 'mean_nodes', 'mean_edges',

python/dgl/transform.py

@@ -18,7 +18,7 @@ from .partition import partition_graph_with_halo as hetero_partition_graph_with_
 from .partition import metis_partition as hetero_metis_partition
 
 # TO BE DEPRECATED
-from .graph import DGLGraph as DGLGraphStale
+from ._deprecate.graph import DGLGraph as DGLGraphStale
 from .graph_index import _get_halo_subgraph_inner_node
 
 __all__ = [

python/dgl/view.py

@@ -4,250 +4,12 @@ from __future__ import absolute_import
 from collections import namedtuple
 from collections.abc import MutableMapping
 
-import numpy as np
-
-from .base import ALL, is_all, DGLError
+from .base import ALL, DGLError
 from . import backend as F
 
 NodeSpace = namedtuple('NodeSpace', ['data'])
 EdgeSpace = namedtuple('EdgeSpace', ['data'])
 
-class NodeView(object):
-    """A NodeView class to act as G.nodes for a DGLGraph.
-
-    Can be used to get a list of current nodes and get and set node data.
-
-    See Also
-    --------
-    dgl.DGLGraph.nodes
-    """
-    __slots__ = ['_graph']
-
-    def __init__(self, graph):
-        self._graph = graph
-
-    def __len__(self):
-        return self._graph.number_of_nodes()
-
-    def __getitem__(self, nodes):
-        if isinstance(nodes, slice):
-            # slice
-            if not (nodes.start is None and nodes.stop is None
-                    and nodes.step is None):
-                raise DGLError('Currently only full slice ":" is supported')
-            return NodeSpace(data=NodeDataView(self._graph, ALL))
-        else:
-            return NodeSpace(data=NodeDataView(self._graph, nodes))
-
-    def __call__(self):
-        """Return the nodes."""
-        return F.copy_to(F.arange(0, len(self)), F.cpu())
-
-class NodeDataView(MutableMapping):
-    """The data view class when G.nodes[...].data is called.
-
-    See Also
-    --------
-    dgl.DGLGraph.nodes
-    """
-    __slots__ = ['_graph', '_nodes']
-
-    def __init__(self, graph, nodes):
-        self._graph = graph
-        self._nodes = nodes
-
-    def __getitem__(self, key):
-        return self._graph.get_n_repr(self._nodes)[key]
-
-    def __setitem__(self, key, val):
-        if isinstance(val, np.ndarray):
-            val = F.zerocopy_from_numpy(val)
-        self._graph.set_n_repr({key : val}, self._nodes)
-
-    def __delitem__(self, key):
-        if not is_all(self._nodes):
-            raise DGLError('Delete feature data is not supported on only a subset'
-                           ' of nodes. Please use `del G.ndata[key]` instead.')
-        self._graph.pop_n_repr(key)
-
-    def __len__(self):
-        return len(self._graph._node_frame)
-
-    def __iter__(self):
-        return iter(self._graph._node_frame)
-
-    def __repr__(self):
-        data = self._graph.get_n_repr(self._nodes)
-        return repr({key : data[key] for key in self._graph._node_frame})
-
-class EdgeView(object):
-    """A EdgeView class to act as G.edges for a DGLGraph.
-
-    Can be used to get a list of current edges and get and set edge data.
-
-    See Also
-    --------
-    dgl.DGLGraph.edges
-    """
-    __slots__ = ['_graph']
-
-    def __init__(self, graph):
-        self._graph = graph
-
-    def __len__(self):
-        return self._graph.number_of_edges()
-
-    def __getitem__(self, edges):
-        if isinstance(edges, slice):
-            # slice
-            if not (edges.start is None and edges.stop is None
-                    and edges.step is None):
-                raise DGLError('Currently only full slice ":" is supported')
-            return EdgeSpace(data=EdgeDataView(self._graph, ALL))
-        else:
-            return EdgeSpace(data=EdgeDataView(self._graph, edges))
-
-    def __call__(self, *args, **kwargs):
-        """Return all the edges."""
-        return self._graph.all_edges(*args, **kwargs)
-
-class EdgeDataView(MutableMapping):
-    """The data view class when G.edges[...].data is called.
-
-    See Also
-    --------
-    dgl.DGLGraph.edges
-    """
-    __slots__ = ['_graph', '_edges']
-
-    def __init__(self, graph, edges):
-        self._graph = graph
-        self._edges = edges
-
-    def __getitem__(self, key):
-        return self._graph.get_e_repr(self._edges)[key]
-
-    def __setitem__(self, key, val):
-        if isinstance(val, np.ndarray):
-            val = F.zerocopy_from_numpy(val)
-        self._graph.set_e_repr({key : val}, self._edges)
-
-    def __delitem__(self, key):
-        if not is_all(self._edges):
-            raise DGLError('Delete feature data is not supported on only a subset'
-                           ' of nodes. Please use `del G.edata[key]` instead.')
-        self._graph.pop_e_repr(key)
-
-    def __len__(self):
-        return len(self._graph._edge_frame)
-
-    def __iter__(self):
-        return iter(self._graph._edge_frame)
-
-    def __repr__(self):
-        data = self._graph.get_e_repr(self._edges)
-        return repr({key : data[key] for key in self._graph._edge_frame})
-
-class LayerView(object):
-    """A LayerView class to act as nflow.layers for a NodeFlow.
-
-    Can be used to get a list of current nodes and get and set node data.
-    """
-    __slots__ = ['_graph']
-
-    def __init__(self, graph):
-        self._graph = graph
-
-    def __len__(self):
-        return self._graph.num_layers()
-
-    def __getitem__(self, layer):
-        if not isinstance(layer, int):
-            raise DGLError('Currently we only support the view of one layer')
-        return NodeSpace(data=LayerDataView(self._graph, layer))
-
-    def __call__(self):
-        """Return the nodes."""
-        return F.arange(0, len(self))
-
-class LayerDataView(MutableMapping):
-    """The data view class when G.layers[...].data is called.
-    """
-    __slots__ = ['_graph', '_layer']
-
-    def __init__(self, graph, layer):
-        self._graph = graph
-        self._layer = layer
-
-    def __getitem__(self, key):
-        return self._graph._node_frames[self._layer][key]
-
-    def __setitem__(self, key, val):
-        self._graph._node_frames[self._layer][key] = val
-
-    def __delitem__(self, key):
-        del self._graph._node_frames[self._layer][key]
-
-    def __len__(self):
-        return len(self._graph._node_frames[self._layer])
-
-    def __iter__(self):
-        return iter(self._graph._node_frames[self._layer])
-
-    def __repr__(self):
-        data = self._graph._node_frames[self._layer]
-        return repr({key : data[key] for key in data})
-
-class BlockView(object):
-    """A BlockView class to act as nflow.blocks for a NodeFlow.
-
-    Can be used to get a list of current edges and get and set edge data.
-    """
-    __slots__ = ['_graph']
-
-    def __init__(self, graph):
-        self._graph = graph
-
-    def __len__(self):
-        return self._graph.num_blocks
-
-    def __getitem__(self, flow):
-        if not isinstance(flow, int):
-            raise DGLError('Currently we only support the view of one flow')
-        return EdgeSpace(data=BlockDataView(self._graph, flow))
-
-    def __call__(self, *args, **kwargs):
-        """Return all the edges."""
-        return self._graph.all_edges(*args, **kwargs)
-
-class BlockDataView(MutableMapping):
-    """The data view class when G.blocks[...].data is called.
-    """
-    __slots__ = ['_graph', '_flow']
-
-    def __init__(self, graph, flow):
-        self._graph = graph
-        self._flow = flow
-
-    def __getitem__(self, key):
-        return self._graph._edge_frames[self._flow][key]
-
-    def __setitem__(self, key, val):
-        self._graph._edge_frames[self._flow][key] = val
-
-    def __delitem__(self, key):
-        del self._graph._edge_frames[self._flow][key]
-
-    def __len__(self):
-        return len(self._graph._edge_frames[self._flow])
-
-    def __iter__(self):
-        return iter(self._graph._edge_frames[self._flow])
-
-    def __repr__(self):
-        data = self._graph._edge_frames[self._flow]
-        return repr({key : data[key] for key in data})
-
 class HeteroNodeView(object):
     """A NodeView class to act as G.nodes for a DGLHeteroGraph."""
     __slots__ = ['_graph', '_typeid_getter']

src/graph/nodeflow.cc

@@ -77,7 +77,7 @@ std::vector<IdArray> GetNodeFlowSlice(const ImmutableGraph &graph, const std::st
   }
 }
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetBlockAdj")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetBlockAdj")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     GraphRef g = args[0];
     std::string format = args[1];

src/graph/sampler.cc

@@ -596,31 +596,31 @@ NodeFlow SampleSubgraph(const ImmutableGraph *graph,
 
 }  // namespace
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetGraph")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetGraph")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     NodeFlow nflow = args[0];
     *rv = nflow->graph;
   });
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetNodeMapping")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetNodeMapping")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     NodeFlow nflow = args[0];
     *rv = nflow->node_mapping;
   });
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetEdgeMapping")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetEdgeMapping")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     NodeFlow nflow = args[0];
     *rv = nflow->edge_mapping;
   });
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetLayerOffsets")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetLayerOffsets")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     NodeFlow nflow = args[0];
     *rv = nflow->layer_offsets;
   });
 
-DGL_REGISTER_GLOBAL("nodeflow._CAPI_NodeFlowGetBlockOffsets")
+DGL_REGISTER_GLOBAL("_deprecate.nodeflow._CAPI_NodeFlowGetBlockOffsets")
 .set_body([] (DGLArgs args, DGLRetValue* rv) {
     NodeFlow nflow = args[0];
     *rv = nflow->flow_offsets;