docs: def _get_target(self, prop, *targets):
          """
          The actual target methods are retrieved (possibly from the list of targets) and a
          wrapper-property is installed on a throwaway type that is specifically created for
          the purpose of holding this property if necessary. In that case, an instance of this type
          (with the wrapper-property forwarding calls to the correct target) is returned so
          that :class:`BoundPV` can do the right thing.
  
          .. seealso:: :meth:`_create_getter`, :meth:`_create_setter`
  
          :param prop: Property, is either 'value' or 'meta'.
          :param targets: List of targets with decreasing priority for finding the wrapped method.
          :return: Target object to be used by :class:`BoundPV`.
          """
  
          if prop is None:
              return None
  
          raw_getter, raw_setter = self._specifications.get(prop, (None, None))
  
          target = None
  
          if isinstance(raw_getter, string_types):
              target = next(
                  (obj for obj in targets if
                   isinstance(
                       getattr(type(obj), raw_getter, None), property)
                   or not callable(
                       getattr(obj, raw_getter, lambda: True))),
                  None)
  
          if target is not None:
              # If the property is an actual property and has no setter, read_only can be
              # set to True at this point automatically.
              target_prop = getattr(type(target), raw_getter, None)
  
              if prop == 'value' and isinstance(target_prop, property) and target_prop.fset is None:
                  self.read_only = True
  
              # Now the target does not need to be constructed, property or meta_data_property
              # needs to change.
              setattr(self, 'property' if prop == 'value' else 'meta_data_property', raw_getter)
              return target
  
          getter = self._create_getter(raw_getter, *targets)
          setter = self._create_setter(raw_setter, *targets)
  
          if getter is None and setter is None:
              return None
  
          if prop == 'value' and setter is None:
              self.read_only = True
  
          return type(prop, (object,), {prop: property(getter, setter)})()