code: def get_connected_sites(self, n):
          
  
          connected_sites = set()
  
          out_edges = [(u, v, d) for u, v, d in self.graph.out_edges(n, data=True)]
          in_edges = [(u, v, d) for u, v, d in self.graph.in_edges(n, data=True)]
  
          for u, v, d in out_edges + in_edges:
  
              weight = d.get('weight', None)
  
              if v == n:
                  site = self.molecule[u]
                  dist = self.molecule[v].distance(self.molecule[u])
  
                  connected_site = ConnectedSite(site=site,
                                                 jimage=(0, 0, 0),
                                                 index=u,
                                                 weight=weight,
                                                 dist=dist)
              else:
                  site = self.molecule[v]
                  dist = self.molecule[u].distance(self.molecule[v])
  
                  connected_site = ConnectedSite(site=site,
                                                 jimage=(0, 0, 0),
                                                 index=v,
                                                 weight=weight,
                                                 dist=dist)
  
              connected_sites.add(connected_site)
  
          # return list sorted by closest sites first
          connected_sites = list(connected_sites)
          connected_sites.sort(key=lambda x: x.dist)
  
          return connected_sites
docs: Returns a named tuple of neighbors of site n:
          periodic_site, jimage, index, weight.
          Index is the index of the corresponding site
          in the original structure, weight can be
          None if not defined.
          :param n: index of Site in Molecule
          :param jimage: lattice vector of site
          :return: list of ConnectedSite tuples,
          sorted by closest first