code: def retrieve_and_parse_content(
          guid: str, handle: str, entity_type: str, sender_key_fetcher: Callable[[str], str]=None,
  ):
      
      if not validate_handle(handle):
          return
      _username, domain = handle.split("@")
      url = get_fetch_content_endpoint(domain, entity_type.lower(), guid)
      document, status_code, error = fetch_document(url)
      if status_code == 200:
          request = RequestType(body=document)
          _sender, _protocol, entities = handle_receive(request, sender_key_fetcher=sender_key_fetcher)
          if len(entities) > 1:
              logger.warning("retrieve_and_parse_content - more than one entity parsed from remote even though we"
                             "expected only one! ID %s", guid)
          if entities:
              return entities[0]
          return
      elif status_code == 404:
          logger.warning("retrieve_and_parse_content - remote content %s not found", guid)
          return
      if error:
          raise error
      raise Exception("retrieve_and_parse_content - unknown problem when fetching document: %s, %s, %s" % (
          document, status_code, error,
      ))
docs: Retrieve remote content and return an Entity class instance.
  
      This is basically the inverse of receiving an entity. Instead, we fetch it, then call "handle_receive".
  
      :param sender_key_fetcher: Function to use to fetch sender public key. If not given, network will be used
          to fetch the profile and the key. Function must take handle as only parameter and return a public key.
      :returns: Entity object instance or ``None``