docs: def get_seqprop_subsequence_from_structchain_property(self,
                                                            property_key, property_value, condition,
                                                            seqprop=None, structprop=None, chain_id=None,
                                                            use_representatives=False,
                                                            return_resnums=False):
          """Get a subsequence as a new SeqProp object given a certain property you want to find in the
          given StructProp's chain's letter_annotation
  
          This is similar to the :func:`ssbio.protein.sequence.seqprop.SeqProp.get_subsequence_from_property` method but instead of
          filtering by the SeqProp's letter_annotation we use the StructProp annotation, and map back to the SeqProp.
  
          Args:
              seqprop (SeqRecord, SeqProp): SeqRecord or SeqProp object that has properties stored in its ``letter_annotations`` attribute
              property_key (str): Property key in the ``letter_annotations`` attribute that you want to filter using
              property_value (object): 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 use_representatives:
              seqprop = self.representative_sequence
              structprop = self.representative_structure
              chain_id = self.representative_chain
              if not structprop:
                  raise ValueError('No representative structure set, please specify sequence, structure, and chain ID')
          else:
              if not seqprop or not structprop or not chain_id:
                  raise ValueError('Please specify sequence, structure, and chain ID')
  
          chain_prop = structprop.chains.get_by_id(chain_id)
  
          # Get the subsequence from the structure
          chain_subseq, subfeat_resnums = chain_prop.get_subsequence_from_property(property_key=property_key,
                                                                                   property_value=property_value,
                                                                                   condition=condition,
                                                                                   return_resnums=True) or (None, [])
          if not chain_subseq:
              return
  
          # Map subsequence feature resnums back to the seqprop
          mapping_dict = self.map_structprop_resnums_to_seqprop_resnums(resnums=subfeat_resnums, structprop=structprop,
                                                                        chain_id=chain_id,
                                                                        seqprop=seqprop,
                                                                        use_representatives=use_representatives)
  
          sub_id = '{}-{}->{}_{}_{}_{}_extracted'.format(structprop.id, chain_id, seqprop.id,
                                                         property_key, condition, property_value)
          seqprop_resnums = [v for k,v in mapping_dict.items()]
  
          new_sp = seqprop.get_subsequence(resnums=seqprop_resnums, new_id=sub_id, copy_letter_annotations=False)
  
          if not new_sp:  # XTODO: investigate errors from subsequence extraction..
              return
  
          try:
              new_sp.letter_annotations = chain_subseq.letter_annotations
          except TypeError:
              # If the length of the mapped sequence does not match, log a warning and don't store letter_annotations
              log.warning('{}: cannot store structure letter annotations in subsequence, lengths do not match. '
                          'Likely a deletion or insertion within the structure!'.format(sub_id))
  
          if return_resnums:
              return new_sp, seqprop_resnums
          else:
              return new_sp