docs: def keep_vertices(self, indices_to_keep, ret_kept_faces=False):
          '''
          Keep the given vertices and discard the others, and any faces to which
          they may belong.
  
  
          If `ret_kept_faces` is `True`, return the original indices of the kept
          faces. Otherwise return `self` for chaining.
  
          '''
          import numpy as np
  
          if self.v is None:
              return
  
          indices_to_keep = np.array(indices_to_keep, dtype=np.uint32)
  
          initial_num_verts = self.v.shape[0]
          if self.f is not None:
              initial_num_faces = self.f.shape[0]
              f_indices_to_keep = self.all_faces_with_verts(indices_to_keep, as_boolean=True)
  
          # Why do we test this? Don't know. But we do need to test it before we
          # mutate self.v.
          vn_should_update = self.vn is not None and self.vn.shape[0] == initial_num_verts
          vc_should_update = self.vc is not None and self.vc.shape[0] == initial_num_verts
  
          self.v = self.v[indices_to_keep]
  
          if vn_should_update:
              self.vn = self.vn[indices_to_keep]
          if vc_should_update:
              self.vc = self.vc[indices_to_keep]
  
          if self.f is not None:
              v_old_to_new = np.zeros(initial_num_verts, dtype=int)
              f_old_to_new = np.zeros(initial_num_faces, dtype=int)
  
              v_old_to_new[indices_to_keep] = np.arange(len(indices_to_keep), dtype=int)
              self.f = v_old_to_new[self.f[f_indices_to_keep]]
              f_old_to_new[f_indices_to_keep] = np.arange(self.f.shape[0], dtype=int)
  
          else:
              # Make the code below work, in case there is somehow degenerate
              # segm even though there are no faces.
              f_indices_to_keep = []
  
          if self.segm is not None:
              new_segm = {}
              for segm_name, segm_faces in self.segm.items():
                  faces = np.array(segm_faces, dtype=int)
                  valid_faces = faces[f_indices_to_keep[faces]]
                  if len(valid_faces):
                      new_segm[segm_name] = f_old_to_new[valid_faces]
              self.segm = new_segm if new_segm else None
  
          if hasattr(self, '_raw_landmarks') and self._raw_landmarks is not None:
              self.recompute_landmarks()
  
          return np.nonzero(f_indices_to_keep)[0] if ret_kept_faces else self