Formatted using yapf and Example in comments

from deepchem.utils.data_utils import download_url, get_data_dir

class LCNNFeaturizer(Featurizer):

  """

    Calculates the 2-D Surface graph features in 6 diffrent permutaions-

    return {"X_Sites": np.array(xSites), "X_NSs": np.array(xNSs)}

def InputReader(text, template=False):

  """Read Input Files

    list of local_env : list of local_env class

    """

  s = text.rstrip('\n').split('\n')

  nl = 0

  # read comment

  else:

    datum = True

  # load cell and pbc

  cell = np.zeros((3, 3))

  pbc = np.array([True, True, True])

    dists = cdist([[0, 0, 0]], pos - np.mean(pos, 0))[0]

    sdists = np.sort(dists)

    #https://stackoverflow.com/questions/37847053/uniquify-an-array-list-with-a-tolerance-in-python-uniquetol-equivalent

        uniquedists = sdists[~(np.triu(np.abs(sdists[:,None]-sdists)<=self.grtol,1)).any(0)]

    uniquedists = sdists[

        ~(np.triu(np.abs(sdists[:, None] - sdists) <= self.grtol, 1)).any(0)]

    orderfromcenter = np.digitize(dists, uniquedists)

    # Add nodes

    for i, o in enumerate(orderfromcenter):

      G.add_node(i, n=str(o) + sitetypes[i])

    # Add edge. distance is edge attribute

        dists = pdist(pos); n=0

    dists = pdist(pos)

    n = 0

    for i in range(len(sitetypes)):

      for j in range(i + 1, len(sitetypes)):

        if dists[n] < self.mindists[frozenset((sitetypes[i],sitetypes[j]))] or\

          G.add_edge(i, j, d=dists[n])

        n += 1

    return G

  def __repr__(self):

    s = '<' + self.sitetypes[0]+\

        '|%i active neighbors'%(len([s for s in self.sitetypes if 'A' in s])-1)+\

    if not isinstance(o, SiteEnvironment):

      raise ValueError

    return self.sitetypes[0] == o.sitetypes[0]

  def __ne__(self, o):

    """Local environment comparison is done by comparing represented site

        """

        xyz[i, :] = env['pos'][am[i], :]

      R = self._kabsch(self.pos, xyz)

      #RMSD

            rmsd.append(np.sqrt(np.mean(np.linalg.norm(np.dot(self.pos,R)-xyz,axis=1)**2)))

      rmsd.append(

          np.sqrt(

              np.mean(np.linalg.norm(np.dot(self.pos, R) - xyz, axis=1)**2)))

    mini = np.argmin(rmsd)

    minrmsd = rmsd[mini]

    if minrmsd < self.tol:

class SiteEnvironments(object):

  def __init__(self, site_envs, ns, na, aos, eigen_tol, pbc, cutoff):

    """Initialize

        n += 1

    # Get Neighbors

    ## Read Data

        site_envs = self._GetSiteEnvironments(coord,cell,st,self.cutoff*cutoff_factor,

            self.pbc,get_permutations=False,eigen_tol=self.eigen_tol)

    site_envs = self._GetSiteEnvironments(

        coord,

        cell,

        st,

        self.cutoff * cutoff_factor,

        self.pbc,

        get_permutations=False,

        eigen_tol=self.eigen_tol)

    XNSs = [[] for _ in range(len(self.site_envs))]

    for env in site_envs:

      i = self.unique_site_types.index(env['sitetypes'][0])

      # get map between two environment

      mapping = self.site_envs[i].GetMapping(env)

      # align input to the primitive cell (reference)

            aligned_idx = [env['env2config'][mapping[i]] for i in range(len(env['env2config']))]

      aligned_idx = [

          env['env2config'][mapping[i]] for i in range(len(env['env2config']))

      ]

      # apply permutations

      nni_perm = np.take(aligned_idx, self.site_envs[i].permutations)

      # remove spectators

      nni_perm = np.vectorize(alltoactive.__getitem__)(nni_perm)

      XNSs[i].append(nni_perm.tolist())

    return XSites.tolist(), XNSs

  @classmethod

  def _truncate(cls, env_ref, env):

    """When cutoff_factor is used, it will pool more site than cutoff factor specifies.

    env['pos'] = [env['pos'][i] for i in range(len(env['pos'])) if i in siteidx]

    env['pos'] = np.subtract(env['pos'], np.mean(env['pos'], 0))

        env['sitetypes'] = [env['sitetypes'][i] for i in range(len(env['sitetypes'])) if i in siteidx]

    env['sitetypes'] = [

        env['sitetypes'][i]

        for i in range(len(env['sitetypes']))

        if i in siteidx

    ]

    env['env2config'] = [env['env2config'][i] for i in siteidx]

    del env['dist']

    return env

        """

    cell, pbc, coord, st, ns, na, aos = InputReader(path, template=True)

        site_envs = cls._GetSiteEnvironments(coord,cell,st,cutoff,pbc,True,eigen_tol=eigen_tol)

        site_envs = [SiteEnvironment(e['pos'],e['sitetypes'],e['env2config'],

                     e['permutations'],cutoff) for e in site_envs]

    site_envs = cls._GetSiteEnvironments(

        coord, cell, st, cutoff, pbc, True, eigen_tol=eigen_tol)

    site_envs = [

        SiteEnvironment(e['pos'], e['sitetypes'], e['env2config'],

                        e['permutations'], cutoff) for e in site_envs

    ]

    ust = [env.sitetypes[0] for env in site_envs]

    usi = np.unique(ust, return_index=True)[1]

    return cls(site_envs, ns, na, aos, eigen_tol, pbc, cutoff)

  @classmethod

    def _GetSiteEnvironments(cls,coord,cell,SiteTypes,cutoff,pbc,get_permutations=True,eigen_tol=1e-5):

  def _GetSiteEnvironments(cls,

                           coord,

                           cell,

                           SiteTypes,

                           cutoff,

                           pbc,

                           get_permutations=True,

                           eigen_tol=1e-5):

    """Extract local environments from primitive cell

        Parameters

      perm = []

      if get_permutations:

                finder = PointGroupAnalyzer(Molecule(local_env_sym,local_env_xyz),eigen_tolerance=eigen_tol)

        finder = PointGroupAnalyzer(

            Molecule(local_env_sym, local_env_xyz), eigen_tolerance=eigen_tol)

        pg = finder.get_pointgroup()

        for i, op in enumerate(pg):

          newpos = op.operate_multi(local_env_xyz)

          perm.append(np.argmin(cdist(local_env_xyz, newpos), axis=1).tolist())

            site_env = {'pos':local_env_xyz,'sitetypes':[SymSiteMap[s] for s in local_env_sym],

                        'env2config':local_env_sitemap,'permutations':perm,

                        'dist':local_env_dist}

      site_env = {

          'pos': local_env_xyz,

          'sitetypes': [SymSiteMap[s] for s in local_env_sym],

          'env2config': local_env_sitemap,

          'permutations': perm,

          'dist': local_env_dist

      }

      site_envs.append(site_env)

    return site_envs

def _chunks(l, n):

  """Yield successive n-sized chunks from l."""

  for i in range(0, len(l), n):

    yield l[i:i + n]

"""

Platinum Adsorbtion structure for N and NO along with their formation energies

"""

DEFAULT_SPLITTERS = {k: DEFAULT_SPLITTERS[k] for k in mydataset_splitters}

def load_Platinum_Adsorption(

    featurizer= DEFAULT_FEATURIZERS['LCNNFeaturizer'],

def load_Platinum_Adsorption(featurizer=DEFAULT_FEATURIZERS['LCNNFeaturizer'],

                             transformers: List = [],

                             splitter=DEFAULT_SPLITTERS['RandomSplitter'],

                             reload: bool = True,

  Examples

  --------

  >> import deepchem as dc

  >> tasks, datasets, transformers = dc.molnet.load_Platinum_Adsorption(reload=False)

  >> train_dataset, val_dataset, test_dataset = datasets

  >> n_tasks = len(tasks)

  >> n_features = train_dataset.get_data_shape()[0]

  >> model = dc.models.LCNNRegressor()

  """

  >> feat_args = {"cutoff": np.around(6.00, 2), "input_file_path": os.join.path(data_path,'input.in') }

  >> tasks, datasets, transformers = load_Platinum_Adsorption(

      reload=True,

      data_dir=data_path,

      save_dir=data_path,

      featurizer_kwargs=feat_args)

  >> train_dataset, val_dataset, test_dataset = datasets

  """

  # Featurize mydataset

  logger.info("About to featurize Platinum Adsorption dataset.")

    save_dir = DEFAULT_DIR

  if 'cutoff' not in featurizer_kwargs:

    raise TypeError("Cuttoff not there")

    raise TypeError("cutoff argument needs to be given")

  if 'input_file_path' not in featurizer_kwargs:

    raise TypeError("input_file_path not there")

    raise TypeError("input_file_path argument needs to be given")

  #Download the data if does'nt exist

  dataset_file = os.path.join(data_dir, 'Platinum_Adsorption.json')

  if not os.path.exists(dataset_file):

    deepchem.utils.data_utils.download_url(

        url=PLATINUM_URL, dest_dir=data_dir)

    deepchem.utils.data_utils.download_url(url=PLATINUM_URL, dest_dir=data_dir)

    deepchem.utils.data_utils.untargz_file(

        os.path.join(data_dir, 'platinum_adsorption.tar.gz'), data_dir)

  if issubclass(featurizer, Featurizer):

    featurizer = featurizer(**featurizer_kwargs)

  else:

    raise TypeError(

        "featurizer must be a subclass of Featurizer.")

    raise TypeError("featurizer must be a subclass of Featurizer.")

  if issubclass(splitter, Splitter):

    splitter = splitter()

  else:

    raise TypeError("splitter must be a subclass of Splitter.")

  # Reload from disk

  if reload:

    featurizer_name = str(featurizer.__class__.__name__)

    splitter_name = str(splitter.__class__.__name__)

    save_folder = os.path.join(save_dir, "Platinum_dataset",

                               featurizer_name, splitter_name)

    save_folder = os.path.join(save_dir, "Platinum_dataset", featurizer_name,

                               splitter_name)

    loaded, all_dataset, transformers = deepchem.utils.data_utils.load_dataset_from_disk(

        save_folder)

      return my_tasks, all_dataset, transformers

  # First type of supported featurizers

  supported_featurizers: List[str] = ['LCNNFeaturizer']  # type: List[Featurizer]

  supported_featurizers: List[str] = ['LCNNFeaturizer'

                                     ]  # type: List[Featurizer]

  # If featurizer requires a non-CSV file format, load .tar.gz file

  if featurizer.__class__.__name__ in supported_featurizers:

    dataset_file = os.path.join(data_dir, 'Platinum_Adsorption.json')

    # Changer loader to match featurizer and data file type

    loader = deepchem.data.JsonLoader(

        tasks=my_tasks,

  return my_tasks, (train_dataset, valid_dataset, test_dataset), transformers

if __name__ == "__main__":

    data_path = "/home/vignesh/Desktop/making_tars/"

    input_file = "/home/vignesh/Desktop/making_tars" #temp.json 

    cutoff = 6.00

    cutoff = np.around(cutoff,2)

    submit_args = {"cutoff": cutoff, "input_file_path":  data_path + 'input.in' }

    _ , train_sample , _ = load_Platinum_Adsorption(reload=True , data_dir= input_file ,save_dir = input_file , featurizer_kwargs = submit_args)

train , val , test = train_sample

print(test)

 No newline at end of file