docs: def get_subsequence_from_property(self, property_key, property_value, condition,
                                        return_resnums=False, copy_letter_annotations=True):
          """Get a subsequence as a new SeqProp object given a certain property you want to find in the
          original SeqProp's letter_annotation
  
          This can be used to do something like extract the subsequence of exposed residues, so you can can run
          calculations on that subsequence. Useful if you have questions like "are there any predicted surface exposed
          cysteines in my protein sequence?"
  
          Example:
              >>> sp = SeqProp(id='tester', seq='MQSLE')
              >>> sp.letter_annotations['a_key'] = [2, 2, 3, 1, 0]
              >>> pk = 'a_key'
              >>> pv = 2
              >>> cond = '<'
              >>> new_sp = sp.get_subsequence_from_property(pk, pv, cond)
              >>> new_sp.letter_annotations[pk]
              [1, 0]
              >>> new_sp
              SeqProp(seq=Seq('LE', ExtendedIUPACProtein()), id='tester_a_key_<_2_extracted', name='<unknown name>', description='<unknown description>', dbxrefs=[])
  
          Args:
              property_key (str): Property key in the ``letter_annotations`` attribute that you want to filter using
              property_value (str): Property value that you want to filter by
              condition (str): ``<``, ``=``, ``>``, ``>=``, or ``<=`` to filter the values by
  
          Returns:
              SeqProp: New SeqProp object that you can run computations on or just extract its properties
  
          """
  
          if property_key not in self.letter_annotations:
              log.error('{}: {} not contained in the letter annotations'.format(self.id, property_key))
              return
  
          if condition == 'in':
              subfeat_indices = list(locate(self.letter_annotations[property_key],
                                            lambda x: x in property_value))
          else:
              subfeat_indices = list(
                  locate(self.letter_annotations[property_key], lambda x: ssbio.utils.check_condition(x, condition, property_value)))
          subfeat_resnums = [x+1 for x in subfeat_indices]
  
          new_sp = self.get_subsequence(resnums=subfeat_resnums, new_id='{}_{}_{}_{}_extracted'.format(self.id,
                                                                                                      property_key,
                                                                                                      condition,
                                                                                                      property_value),
                                        copy_letter_annotations=copy_letter_annotations)
  
          if return_resnums:
              return new_sp, subfeat_resnums
          else:
              return new_sp