class_docstr: The extension of MoleculeNet with `MUTAG <https://pubs.acs.org/doi/10.1021/jm00106a046>`_.
  
  The `MoleculeNet benchmark collection <http://moleculenet.ai/datasets-1>`_ from the
  `MoleculeNet: A Benchmark for Molecular Machine Learning <https://arxiv.org/abs/1703.00564>`_
  paper, containing datasets from physical chemistry, biophysics and physiology.
  
  The MoleculeNet datasets come with the additional node and edge features introduced by
  the `Open Graph Benchmark <https://ogb.stanford.edu/docs/graphprop/>`_, and the node features
  in MUTAG dataset are one hot features denoting the atom types.
  
  Args:
      root (string): Root directory where the dataset should be saved.
      name (string): The name of the dataset (:obj:`"MUTAG"`, :obj:`"ESOL"`,
          :obj:`"FreeSolv"`, :obj:`"Lipo"`, :obj:`"PCBA"`, :obj:`"MUV"`,
          :obj:`"HIV"`, :obj:`"BACE"`, :obj:`"BBPB"`, :obj:`"Tox21"`,
          :obj:`"ToxCast"`, :obj:`"SIDER"`, :obj:`"ClinTox"`).
      transform (callable, optional): A function/transform that takes in an
          :obj:`torch_geometric.data.Data` object and returns a transformed
          version. The data object will be transformed before every access.
          (default: :obj:`None`)
      pre_transform (callable, optional): A function/transform that takes in
          an :obj:`torch_geometric.data.Data` object and returns a
          transformed version. The data object will be transformed before
          being saved to disk. (default: :obj:`None`)
      pre_filter (callable, optional): A function that takes in an
          :obj:`torch_geometric.data.Data` object and returns a boolean
          value, indicating whether the data object should be included in the
          final dataset. (default: :obj:`None`)
code: def process(self):
      if self.name.lower() == "MUTAG".lower():
          with open(
              os.path.join(self.raw_dir, "MUTAG_node_labels.txt"), "r"
          ) as f:
              nodes_all_temp = f.read().splitlines()
              nodes_all = [int(i) for i in nodes_all_temp]
  
          adj_all = np.zeros((len(nodes_all), len(nodes_all)))
          with open(
              os.path.join(self.raw_dir, "MUTAG_A.txt"), "r"
          ) as f:
              adj_list = f.read().splitlines()
          for item in adj_list:
              lr = item.split(", ")
              l = int(lr[0])
              r = int(lr[1])
              adj_all[l - 1, r - 1] = 1
  
          with open(
              os.path.join(self.raw_dir, "MUTAG_graph_indicator.txt"),
              "r",
          ) as f:
              graph_indicator_temp = f.read().splitlines()
              graph_indicator = [int(i) for i in graph_indicator_temp]
              graph_indicator = np.array(graph_indicator)
  
          with open(
              os.path.join(self.raw_dir, "MUTAG_graph_labels.txt"), "r"
          ) as f:
              graph_labels_temp = f.read().splitlines()
              graph_labels = [int(i) for i in graph_labels_temp]
  
          data_list = []
          for i in range(1, 189):
              idx = np.where(graph_indicator == i)
              graph_len = len(idx[0])
              adj = adj_all[
                  idx[0][0] : idx[0][0] + graph_len,
                  idx[0][0] : idx[0][0] + graph_len,
              ]
              label = int(graph_labels[i - 1] == 1)
              feature = nodes_all[idx[0][0] : idx[0][0] + graph_len]
              nb_clss = 7
              targets = np.array(feature).reshape(-1)
              one_hot_feature = np.eye(nb_clss)[targets]
              data_example = Data(
                  x=torch.from_numpy(one_hot_feature).float(),
                  edge_index=dense_to_sparse(torch.from_numpy(adj))[0],
                  y=label,
              )
              data_list.append(data_example)
      else:
          with open(self.raw_paths[0], "r") as f:
              dataset = f.read().split("\n")[1:-1]
              dataset = [
                  x for x in dataset if len(x) > 0
              ]  # Filter empty lines.
  
          data_list = []
          for line in dataset:
              line = re.sub(
                  r"\".*\"", "", line
              )  # Replace ".*" strings.
              line = line.split(",")
  
              smiles = line[self.names[self.name][3]]
              ys = line[self.names[self.name][4]]
              ys = ys if isinstance(ys, list) else [ys]
  
              ys = [
                  float(y) if len(y) > 0 else float("NaN") for y in ys
              ]
              y = torch.tensor(ys, dtype=torch.float).view(1, -1)
  
              mol = Chem.MolFromSmiles(smiles)
              if mol is None:
                  continue
  
              xs = []
              for atom in mol.GetAtoms():
                  x = []
                  x.append(
                      x_map["atomic_num"].index(atom.GetAtomicNum())
                  )
                  x.append(
                      x_map["chirality"].index(str(atom.GetChiralTag()))
                  )
                  x.append(x_map["degree"].index(atom.GetTotalDegree()))
                  x.append(
                      x_map["formal_charge"].index(
                          atom.GetFormalCharge()
                      )
                  )
                  x.append(x_map["num_hs"].index(atom.GetTotalNumHs()))
                  x.append(
                      x_map["num_radical_electrons"].index(
                          atom.GetNumRadicalElectrons()
                      )
                  )
                  x.append(
                      x_map["hybridization"].index(
                          str(atom.GetHybridization())
                      )
                  )
                  x.append(
                      x_map["is_aromatic"].index(atom.GetIsAromatic())
                  )
                  x.append(x_map["is_in_ring"].index(atom.IsInRing()))
                  xs.append(x)
  
              x = torch.tensor(xs, dtype=torch.long).view(-1, 9)
  
              edge_indices, edge_attrs = [], []
              for bond in mol.GetBonds():
                  i = bond.GetBeginAtomIdx()
                  j = bond.GetEndAtomIdx()
  
                  e = []
                  e.append(
                      e_map["bond_type"].index(str(bond.GetBondType()))
                  )
                  e.append(e_map["stereo"].index(str(bond.GetStereo())))
                  e.append(
                      e_map["is_conjugated"].index(
                          bond.GetIsConjugated()
                      )
                  )
  
                  edge_indices += [[i, j], [j, i]]
                  edge_attrs += [e, e]
  
              edge_index = torch.tensor(edge_indices)
              edge_index = edge_index.t().to(torch.long).view(2, -1)
              edge_attr = torch.tensor(
                  edge_attrs, dtype=torch.long
              ).view(-1, 3)
  
              # Sort indices.
              if edge_index.numel() > 0:
                  perm = (
                      edge_index[0] * x.size(0) + edge_index[1]
                  ).argsort()
                  edge_index, edge_attr = (
                      edge_index[:, perm],
                      edge_attr[perm],
                  )
  
              data = Data(
                  x=x,
                  edge_index=edge_index,
                  edge_attr=edge_attr,
                  y=y,
                  smiles=smiles,
              )
  
              if self.pre_filter is not None and not self.pre_filter(
                  data
              ):
                  continue
  
              if self.pre_transform is not None:
                  data = self.pre_transform(data)
  
              data_list.append(data)
      torch.save(self.collate(data_list), self.processed_paths[0])
  
imports: import os
  import re
  import torch
  import numpy
  from torch_geometric.utils import dense_to_sparse
  from torch_geometric.data import Data, InMemoryDataset, download_url
  import os.path
  import zipfile
  import gzip
label_desc: Use image node_id 7 for calling the MoleculeDataset obj's underlying member method code with example usage: obj.process() without return types