docs: def _build_parser_for_fileobject_and_desiredtype(self, obj_on_filesystem: PersistedObject, object_typ: Type[T],
                                                       logger: Logger = None) -> Dict[Type, Parser]:
          """
          Builds a parser for each subtype of object_typ
  
          :param obj_on_filesystem:
          :param object_typ:
          :param logger:
          :return:
          """
  
          parsers = OrderedDict()
          errors = OrderedDict()
          try:
              p = self.__build_parser_for_fileobject_and_desiredtype(obj_on_filesystem,
                                                                     object_typ=object_typ,
                                                                     logger=logger)
              parsers[object_typ] = p
          except NoParserFoundForObjectExt as e:
              logger.warning("{} - {}".format(type(e).__name__, e))
              errors[e] = e
          except NoParserFoundForObjectType as f:
              logger.warning("{} - {}".format(type(f).__name__, f))
              errors[f] = f
  
          # do not explore subclasses for collections
          if is_collection(object_typ, strict=True):
              if len(errors) > 0:
                  raise next(iter(errors.values()))
              else:
                  return parsers
  
          # Finally create one such parser for each subclass
          subclasses = get_all_subclasses(object_typ)
  
          # Then for each subclass also try (with a configurable limit in nb of subclasses)
          for subclass in subclasses[0:GLOBAL_CONFIG.dict_to_object_subclass_limit]:
              try:
                  parsers[subclass] = self.__build_parser_for_fileobject_and_desiredtype(obj_on_filesystem,
                                                                                         object_typ=subclass,
                                                                                         logger=logger)
              except NoParserFoundForObjectExt as e:
                  logger.warning("{} - {}".format(type(e).__name__, e))
                  errors[e] = e
              except NoParserFoundForObjectType as f:
                  logger.warning("{} - {}".format(type(f).__name__, f))
                  errors[f] = f
  
          if len(subclasses) > GLOBAL_CONFIG.dict_to_object_subclass_limit:
              warn('Type {} has more than {} subclasses, only {} were tried to convert it, with no success. You '
                   'can raise this limit by setting the appropriate option with `parsyfiles_global_config()`'
                   ''.format(object_typ, len(subclasses), GLOBAL_CONFIG.dict_to_object_subclass_limit))
  
          return parsers