docs: def validate_catalog(catalog, only_errors=False, fmt="dict",
                       export_path=None, validator=None):
      """Analiza un data.json registrando los errores que encuentra.
  
      Chequea que el data.json tiene todos los campos obligatorios y que
      tanto los campos obligatorios como los opcionales siguen la estructura
      definida en el schema.
  
      Args:
          catalog (str o dict): Catálogo (dict, JSON o XLSX) a ser validado.
          only_errors (bool): Si es True sólo se reportan los errores.
          fmt (str): Indica el formato en el que se desea el reporte.
              "dict" es el reporte más verborrágico respetando la
                  estructura del data.json.
              "list" devuelve un dict con listas de errores formateados para
                  generar tablas.
          export_path (str): Path donde exportar el reporte generado (en
              formato XLSX o CSV). Si se especifica, el método no devolverá
              nada, a pesar de que se pase algún argumento en `fmt`.
  
      Returns:
          dict: Diccionario resumen de los errores encontrados::
  
              {
                  "status": "OK",  # resultado de la validación global
                  "error": {
                      "catalog": {
                          "status": "OK",
                          "errors": []
                          "title": "Título Catalog"},
                      "dataset": [
                          {
                              "status": "OK",
                              "errors": [],
                              "title": "Titulo Dataset 1"
                          },
                          {
                              "status": "ERROR",
                              "errors": [error1_info, error2_info, ...],
                              "title": "Titulo Dataset 2"
                          }
                      ]
                  }
              }
  
          Donde errorN_info es un dict con la información del N-ésimo
          error encontrado, con las siguientes claves: "path", "instance",
          "message", "validator", "validator_value", "error_code".
  
      """
      catalog = readers.read_catalog(catalog)
  
      # La respuesta por default se devuelve si no hay errores
      default_response = {
          "status": "OK",
          "error": {
              "catalog": {
                  "status": "OK",
                  "title": catalog.get("title"),
                  "errors": []
              },
              # "dataset" contiene lista de rtas default si el catálogo
              # contiene la clave "dataset" y además su valor es una lista.
              # En caso contrario "dataset" es None.
              "dataset": [
                  {
                      "status": "OK",
                      "title": dataset.get("title"),
                      "identifier": dataset.get("identifier"),
                      "list_index": index,
                      "errors": []
                  } for index, dataset in enumerate(catalog["dataset"])
              ] if ("dataset" in catalog and
                    isinstance(catalog["dataset"], list)) else None
          }
      }
  
      # Genero la lista de errores en la instancia a validar
      if not validator:
          if hasattr(catalog, "validator"):
              validator = catalog.validator
          else:
              validator = create_validator()
      jsonschema_errors = list(validator.iter_errors(catalog))
      custom_errors = list(iter_custom_errors(catalog))
  
      errors = jsonschema_errors + custom_errors
  
      response = default_response.copy()
      for error in errors:
          response = _update_validation_response(
              error, response)
  
      # filtra los resultados que están ok, para hacerlo más compacto
      if only_errors:
          response["error"]["dataset"] = [
              dataset for dataset in response["error"]["dataset"] if
              dataset["status"] == "ERROR"]
  
      # elige el formato del resultado
      if export_path:
          validation_lists = _catalog_validation_to_list(response)
  
          # config styles para reportes en excel
          alignment = Alignment(
              wrap_text=True,
              shrink_to_fit=True,
              vertical="center"
          )
          column_styles = {
              "catalog": {
                  "catalog_status": {"width": 20},
                  "catalog_error_location": {"width": 40},
                  "catalog_error_message": {"width": 40},
                  "catalog_title": {"width": 20},
              },
              "dataset": {
                  "dataset_error_location": {"width": 20},
                  "dataset_identifier": {"width": 40},
                  "dataset_status": {"width": 20},
                  "dataset_title": {"width": 40},
                  "dataset_list_index": {"width": 20},
                  "dataset_error_message": {"width": 40},
              }
          }
          cell_styles = {
              "catalog": [
                  {"alignment": Alignment(vertical="center")},
                  {"row": 1, "font": Font(bold=True)},
              ],
              "dataset": [
                  {"alignment": Alignment(vertical="center")},
                  {"row": 1, "font": Font(bold=True)},
              ]
          }
  
          # crea tablas en un sólo excel o varios CSVs
          writers.write_tables(
              tables=validation_lists, path=export_path,
              column_styles=column_styles, cell_styles=cell_styles
          )
  
      elif fmt == "dict":
          return response
  
      elif fmt == "list":
          return _catalog_validation_to_list(response)
  
      # Comentado porque requiere una extensión pesada nueva para pydatajson
      # elif fmt == "df":
      #     validation_lists = self._catalog_validation_to_list(response)
      #     return {
      #         "catalog": pd.DataFrame(validation_lists["catalog"]),
      #         "dataset": pd.DataFrame(validation_lists["dataset"])
      #     }
  
      else:
          raise Exception("No se reconoce el formato {}".format(fmt))