




'''simple docstring'''


import argparse
import collections
import os
import re
import tempfile

import pandas as pd
from datasets import Dataset
from huggingface_hub import hf_hub_download, upload_folder

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/update_metadata.py
UpperCAmelCase_					=   "src/transformers"


# This is to make sure the transformers module imported is the one in the repo.
UpperCAmelCase_					=   direct_transformers_import(TRANSFORMERS_PATH)


# Regexes that match TF/Flax/PT model names.
UpperCAmelCase_					=   re.compile(r"TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")
UpperCAmelCase_					=   re.compile(r"Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")
# Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes.
UpperCAmelCase_					=   re.compile(r"(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)")


# Fill this with tuples (pipeline_tag, model_mapping, auto_model)
UpperCAmelCase_					=   [
    ("pretraining", "MODEL_FOR_PRETRAINING_MAPPING_NAMES", "AutoModelForPreTraining"),
    ("feature-extraction", "MODEL_MAPPING_NAMES", "AutoModel"),
    ("audio-classification", "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES", "AutoModelForAudioClassification"),
    ("text-generation", "MODEL_FOR_CAUSAL_LM_MAPPING_NAMES", "AutoModelForCausalLM"),
    ("automatic-speech-recognition", "MODEL_FOR_CTC_MAPPING_NAMES", "AutoModelForCTC"),
    ("image-classification", "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES", "AutoModelForImageClassification"),
    ("image-segmentation", "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING_NAMES", "AutoModelForImageSegmentation"),
    ("fill-mask", "MODEL_FOR_MASKED_LM_MAPPING_NAMES", "AutoModelForMaskedLM"),
    ("object-detection", "MODEL_FOR_OBJECT_DETECTION_MAPPING_NAMES", "AutoModelForObjectDetection"),
    (
        "zero-shot-object-detection",
        "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING_NAMES",
        "AutoModelForZeroShotObjectDetection",
    ),
    ("question-answering", "MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES", "AutoModelForQuestionAnswering"),
    ("text2text-generation", "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES", "AutoModelForSeq2SeqLM"),
    ("text-classification", "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES", "AutoModelForSequenceClassification"),
    ("automatic-speech-recognition", "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES", "AutoModelForSpeechSeq2Seq"),
    (
        "table-question-answering",
        "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForTableQuestionAnswering",
    ),
    ("token-classification", "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES", "AutoModelForTokenClassification"),
    ("multiple-choice", "MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES", "AutoModelForMultipleChoice"),
    (
        "next-sentence-prediction",
        "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES",
        "AutoModelForNextSentencePrediction",
    ),
    (
        "audio-frame-classification",
        "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING_NAMES",
        "AutoModelForAudioFrameClassification",
    ),
    ("audio-xvector", "MODEL_FOR_AUDIO_XVECTOR_MAPPING_NAMES", "AutoModelForAudioXVector"),
    (
        "document-question-answering",
        "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForDocumentQuestionAnswering",
    ),
    (
        "visual-question-answering",
        "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING_NAMES",
        "AutoModelForVisualQuestionAnswering",
    ),
    ("image-to-text", "MODEL_FOR_FOR_VISION_2_SEQ_MAPPING_NAMES", "AutoModelForVision2Seq"),
    (
        "zero-shot-image-classification",
        "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING_NAMES",
        "AutoModelForZeroShotImageClassification",
    ),
    ("depth-estimation", "MODEL_FOR_DEPTH_ESTIMATION_MAPPING_NAMES", "AutoModelForDepthEstimation"),
    ("video-classification", "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING_NAMES", "AutoModelForVideoClassification"),
    ("mask-generation", "MODEL_FOR_MASK_GENERATION_MAPPING_NAMES", "AutoModelForMaskGeneration"),
]


def     SCREAMING_SNAKE_CASE							(   a_						:				Any      ):
  __a								=       re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)'					,       a_      )
  return [m.group(0      ) for m in matches]


def     SCREAMING_SNAKE_CASE							(   ):
  __a								=       transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES
  __a								=       {
      config.replace('Config'					,       ''      ): model_type for model_type, config in config_maping_names.items()
  }

  # Dictionaries flagging if each model prefix has a backend in PT/TF/Flax.
  __a								=       collections.defaultdict(a_      )
  __a								=       collections.defaultdict(a_      )
  __a								=       collections.defaultdict(a_      )

  # Let's lookup through all transformers object (once) and find if models are supported by a given backend.
  for attr_name in dir(a_      ):
    __a								=       None
    if _re_tf_models.match(a_      ) is not None:
      __a								=       tf_models
      __a								=       _re_tf_models.match(a_      ).groups()[0]
    elif _re_flax_models.match(a_      ) is not None:
      __a								=       flax_models
      __a								=       _re_flax_models.match(a_      ).groups()[0]
    elif _re_pt_models.match(a_      ) is not None:
      __a								=       pt_models
      __a								=       _re_pt_models.match(a_      ).groups()[0]

    if lookup_dict is not None:
      while len(a_      ) > 0:
        if attr_name in model_prefix_to_model_type:
          __a								=       True
          break
        # Try again after removing the last word in the name
        __a								=       ''.join(camel_case_split(a_      )[:-1]      )

  __a								=       set(list(pt_models.keys()      ) + list(tf_models.keys()      ) + list(flax_models.keys()      )      )
  __a								=       list(a_      )
  all_models.sort()

  __a								=       {'model_type': all_models}
  __a								=       [pt_models[t] for t in all_models]
  __a								=       [tf_models[t] for t in all_models]
  __a								=       [flax_models[t] for t in all_models]

  # Now let's use the auto-mapping names to make sure
  __a								=       {}
  for t in all_models:
    if t in transformers_module.models.auto.processing_auto.PROCESSOR_MAPPING_NAMES:
      __a								=       'AutoProcessor'
    elif t in transformers_module.models.auto.tokenization_auto.TOKENIZER_MAPPING_NAMES:
      __a								=       'AutoTokenizer'
    elif t in transformers_module.models.auto.feature_extraction_auto.FEATURE_EXTRACTOR_MAPPING_NAMES:
      __a								=       'AutoFeatureExtractor'
    else:
      # Default to AutoTokenizer if a model has nothing, for backward compatibility.
      __a								=       'AutoTokenizer'

  __a								=       [processors[t] for t in all_models]

  return pd.DataFrame(a_      )


def     SCREAMING_SNAKE_CASE							(   a_						:				str      ):
  __a								=       [
      transformers_module.models.auto.modeling_auto,
      transformers_module.models.auto.modeling_tf_auto,
      transformers_module.models.auto.modeling_flax_auto,
  ]
  for pipeline_tag, model_mapping, auto_class in PIPELINE_TAGS_AND_AUTO_MODELS:
    __a								=       [model_mapping, f"TF_{model_mapping}", f"FLAX_{model_mapping}"]
    __a								=       [auto_class, f"TF_{auto_class}", f"Flax_{auto_class}"]
    # Loop through all three frameworks
    for module, cls, mapping in zip(a_					,       a_					,       a_      ):
      # The type of pipeline may not exist in this framework
      if not hasattr(a_					,       a_      ):
        continue
      # First extract all model_names
      __a								=       []
      for name in getattr(a_					,       a_      ).values():
        if isinstance(a_					,       a_      ):
          model_names.append(a_      )
        else:
          model_names.extend(list(a_      )      )

            # Add pipeline tag and auto model class for those models
      table.update({model_name: (pipeline_tag, cls) for model_name in model_names}      )

  return table


def     SCREAMING_SNAKE_CASE							(   a_						:				Tuple					,       a_						:				int      ):
  __a								=       get_frameworks_table()
  __a								=       Dataset.from_pandas(a_      )

  __a								=       hf_hub_download(
      'huggingface/transformers-metadata'					,       'pipeline_tags.json'					,       repo_type='dataset'					,       token=a_      )
  __a								=       Dataset.from_json(a_      )
  __a								=       {
      tags_dataset[i]['model_class']: (tags_dataset[i]['pipeline_tag'], tags_dataset[i]['auto_class'])
      for i in range(len(a_      )      )
  }
  __a								=       update_pipeline_and_auto_class_table(a_      )

  # Sort the model classes to avoid some nondeterministic updates to create false update commits.
  __a								=       sorted(table.keys()      )
  __a								=       pd.DataFrame(
      {
          'model_class': model_classes,
          'pipeline_tag': [table[m][0] for m in model_classes],
          'auto_class': [table[m][1] for m in model_classes],
      }      )
  __a								=       Dataset.from_pandas(a_      )

  with tempfile.TemporaryDirectory() as tmp_dir:
    frameworks_dataset.to_json(os.path.join(a_					,       'frameworks.json'      )      )
    tags_dataset.to_json(os.path.join(a_					,       'pipeline_tags.json'      )      )

    if commit_sha is not None:
      __a								=       (
          f"Update with commit {commit_sha}\n\nSee: "
          f"https://github.com/huggingface/transformers/commit/{commit_sha}"
      )
    else:
      __a								=       'Update'

    upload_folder(
        repo_id='huggingface/transformers-metadata'					,       folder_path=a_					,       repo_type='dataset'					,       token=a_					,       commit_message=a_					,       )


def     SCREAMING_SNAKE_CASE							(   ):
  __a								=       {tag: cls for tag, _, cls in PIPELINE_TAGS_AND_AUTO_MODELS}
  __a								=       transformers_module.pipelines.SUPPORTED_TASKS
  __a								=       []
  for key in pipeline_tasks:
    if key not in in_table:
      __a								=       pipeline_tasks[key]['pt']
      if isinstance(a_					,       (list, tuple)      ):
        __a								=       model[0]
      __a								=       model.__name__
      if model not in in_table.values():
        missing.append(a_      )

  if len(a_      ) > 0:
    __a								=       ', '.join(a_      )
    raise ValueError(
        'The following pipeline tags are not present in the `PIPELINE_TAGS_AND_AUTO_MODELS` constant inside '
        f"`utils/update_metadata.py`: {msg}. Please add them!"      )


if __name__ == "__main__":
  UpperCAmelCase_					=   argparse.ArgumentParser()
  parser.add_argument("--token", type=str, help="The token to use to push to the transformers-metadata dataset.")
  parser.add_argument("--commit_sha", type=str, help="The sha of the commit going with this update.")
  parser.add_argument("--check-only", action="store_true", help="Activate to just check all pipelines are present.")
  UpperCAmelCase_					=   parser.parse_args()

  if args.check_only:
    check_pipeline_tags()
  else:
    update_metadata(args.token, args.commit_sha)









'''simple docstring'''


import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate





@dataclass(frozen=__magic_name__			)
class  __lowercase    (	__magic_name__			):
   _a    						=   field(default="""audio-classification"""							,				metadata={"""include_in_asdict_even_if_is_default""": True}			)
   _a    						=   Features({"""audio""": Audio()}			)
   _a    						=   Features({"""labels""": ClassLabel}			)
   _a    						=   "audio"
   _a    						=   "labels"







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     if self.label_column not in features:
       raise ValueError(f"Column {self.label_column} is not present in features."   )
     if not isinstance(features[self.label_column]   ,				UpperCamelCase   ):
       raise ValueError(f"Column {self.label_column} is not a ClassLabel."   )
     __a								=       copy.deepcopy(self   )
     __a								=       self.label_schema.copy()
     __a								=       features[self.label_column]
     __a								=       label_schema
     return task_template







   @property
   def 		UpperCamelCase__      (						self   )					->     Dict[str, str]:
     return {
         self.audio_column: "audio",
         self.label_column: "labels",
     }



