docs: def equivalent_sites(self, scaled_positions, ondublicates='error', 
                           symprec=1e-3):
          """Returns the scaled positions and all their equivalent sites.
  
          Parameters:
  
          scaled_positions: list | array
              List of non-equivalent sites given in unit cell coordinates.
          ondublicates : 'keep' | 'replace' | 'warn' | 'error'
              Action if `scaled_positions` contain symmetry-equivalent
              positions:
              
              'keep'
                 ignore additional symmetry-equivalent positions
              'replace'
                  replace
              'warn'
                  like 'keep', but issue an UserWarning
              'error'
                  raises a SpacegroupValueError
                      
          symprec: float
              Minimum "distance" betweed two sites in scaled coordinates
              before they are counted as the same site.
  
          Returns:
  
          sites: array
              A NumPy array of equivalent sites.
          kinds: list
              A list of integer indices specifying which input site is 
              equivalent to the corresponding returned site.
  
          Example:
  
          >>> from ase.lattice.spacegroup import Spacegroup
          >>> sg = Spacegroup(225)  # fcc
          >>> sites, kinds = sg.equivalent_sites([[0, 0, 0], [0.5, 0.0, 0.0]])
          >>> sites
          array([[ 0. ,  0. ,  0. ],
                 [ 0. ,  0.5,  0.5],
                 [ 0.5,  0. ,  0.5],
                 [ 0.5,  0.5,  0. ],
                 [ 0.5,  0. ,  0. ],
                 [ 0. ,  0.5,  0. ],
                 [ 0. ,  0. ,  0.5],
                 [ 0.5,  0.5,  0.5]])
          >>> kinds
          [0, 0, 0, 0, 1, 1, 1, 1]
          """
          kinds = []
          sites = []
          symprec2 = symprec**2
          scaled = np.array(scaled_positions, ndmin=2)
          for kind, pos in enumerate(scaled):
              for rot, trans in self.get_symop():
                  site = np.mod(np.dot(rot, pos) + trans, 1.)
                  if not sites:
                      sites.append(site)
                      kinds.append(kind)
                      continue
                  t = site - sites
                  mask = np.sum(t*t, 1) < symprec2
                  if np.any(mask):
                      ind = np.argwhere(mask)[0][0]
                      if kinds[ind] == kind:
                          pass
                      elif ondublicates == 'keep':
                          pass
                      elif ondublicates == 'replace':
                          kinds[ind] = kind
                      elif ondublicates == 'warn':
                          warnings.warn('scaled_positions %d and %d '
                                        'are equivalent'%(kinds[ind], kind))
                      elif ondublicates == 'error':
                          raise SpacegroupValueError(
                              'scaled_positions %d and %d are equivalent'%(
                                  kinds[ind], kind))
                      else:
                          raise SpacegroupValueError(
                              'Argument "ondublicates" must be one of: '
                              '"keep", "replace", "warn" or "error".')
                  else:
                      sites.append(site)
                      kinds.append(kind)
          return np.array(sites), kinds