docs: def get_unique_object_contents(self, location: str) -> Tuple[bool, str, Union[str, Dict[str, str]]]:
          """
          Utility method to find a unique singlefile or multifile object.
          This method throws
          * ObjectNotFoundOnFileSystemError if no file is found
          * ObjectPresentMultipleTimesOnFileSystemError if the object is found multiple times (for example with
          several file extensions, or as a file AND a folder)
          * IllegalContentNameError if a multifile child name is None or empty string.
  
          It relies on the abstract methods of this class (find_simpleobject_file_occurrences and
          find_multifile_object_children) to find the various files present.
  
          :param location: a location identifier compliant with the provided file mapping configuration
          :return: [True, singlefile_ext, singlefile_path] if a unique singlefile object is present ;
          False, MULTIFILE_EXT, complexobject_attributes_found] if a unique multifile object is present, with
          complexobject_attributes_found being a dictionary {name: location}
          """
  
          # First check what is present on the filesystem according to the filemapping
          simpleobjects_found = self.find_simpleobject_file_occurrences(location)
          complexobject_attributes_found = self.find_multifile_object_children(location, no_errors=True)
  
          # Then handle the various cases
          if len(simpleobjects_found) > 1 \
                  or (len(simpleobjects_found) == 1 and len(complexobject_attributes_found) > 0):
              # the object is present several times > error
              u = simpleobjects_found
              u.update(complexobject_attributes_found)
              raise ObjectPresentMultipleTimesOnFileSystemError.create(location, list(u.keys()))
  
          elif len(simpleobjects_found) == 1:
              # a singlefile object > create the output
              is_single_file = True
              ext = list(simpleobjects_found.keys())[0]
              singlefile_object_file_path = simpleobjects_found[ext]
              return is_single_file, ext, singlefile_object_file_path
  
          elif len(complexobject_attributes_found) > 0:
              # a multifile object > create the output
              is_single_file = False
              ext = MULTIFILE_EXT
              if '' in complexobject_attributes_found.keys() or None in complexobject_attributes_found.keys():
                  raise IllegalContentNameError.create(location, complexobject_attributes_found[MULTIFILE_EXT])
              return is_single_file, ext, complexobject_attributes_found
  
          else:
              # handle special case of multifile object with no children (if applicable)
              if self.is_multifile_object_without_children(location):
                  is_single_file = False
                  ext = MULTIFILE_EXT
                  return is_single_file, ext, dict()
              else:
                  # try if by any chance the issue is that location has an extension
                  loc_without_ext = splitext(location)[0]
                  simpleobjects_found = self.find_simpleobject_file_occurrences(loc_without_ext)
                  complexobject_attributes_found = self.find_multifile_object_children(loc_without_ext, no_errors=True)
  
                  # the object was not found in a form that can be parsed
                  raise ObjectNotFoundOnFileSystemError.create(location, simpleobjects_found,
                                                               complexobject_attributes_found)