

from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
    import numpy as np
    import tensorflow as tf

    from transformers import (
        TF_MODEL_FOR_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_MASKED_LM_MAPPING,
        TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
        TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
        TF_MODEL_FOR_PRETRAINING_MAPPING,
        TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
        TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
        TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
        TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
        TFSharedEmbeddings,
    )

    if _tf_gpu_memory_limit is not None:
        lowerCamelCase_					  =   tf.config.list_physical_devices('''GPU''')
        for gpu in gpus:
            # Restrict TensorFlow to only allocate x GB of memory on the GPUs
            try:
                tf.config.set_logical_device_configuration(
                    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
                )
                lowerCamelCase_					  =   tf.config.list_logical_devices('''GPU''')
                print('''Logical GPUs''', logical_gpus)
            except RuntimeError as e:
                # Virtual devices must be set before GPUs have been initialized
                print(e)







@require_tf
class 					__lowerCamelCase							:
      lowerCamelCase_      : str  			=   None
      lowerCamelCase_      : Dict  			=   ()
      lowerCamelCase_      : Optional[Any]  			=   ()
      lowerCamelCase_      : List[Any]  			=   True
      lowerCamelCase_      : Optional[Any]  			=   True
      lowerCamelCase_      : int  			=   True
      lowerCamelCase_      : Any  			=   False







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase				,    lowerCamelCase=False  )		->			dict:
        snake_case_					= copy.deepcopy(lowerCamelCase  )

        if model_class in get_values(lowerCamelCase  ):
          snake_case_					= {
              k: tf.tile(tf.expand_dims(lowerCamelCase				,    1  )				,    (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)  )
              if isinstance(lowerCamelCase				,    tf.Tensor  ) and v.ndim > 0
              else v
              for k, v in inputs_dict.items()
          }

        if return_labels:
          if model_class in get_values(lowerCamelCase  ):
            snake_case_					= tf.ones(self.model_tester.batch_size				,    dtype=tf.intaa  )
          elif model_class in get_values(lowerCamelCase  ):
            snake_case_					= tf.zeros(self.model_tester.batch_size				,    dtype=tf.intaa  )
            snake_case_					= tf.zeros(self.model_tester.batch_size				,    dtype=tf.intaa  )
          elif model_class in [
              *get_values(lowerCamelCase  ),
              *get_values(lowerCamelCase  ),
          ]:
            snake_case_					= tf.zeros(self.model_tester.batch_size				,    dtype=tf.intaa  )
          elif model_class in get_values(lowerCamelCase  ):
            snake_case_					= tf.zeros(self.model_tester.batch_size				,    dtype=tf.intaa  )
          elif model_class in [
              *get_values(lowerCamelCase  ),
              *get_values(lowerCamelCase  ),
              *get_values(lowerCamelCase  ),
              *get_values(lowerCamelCase  ),
              *get_values(lowerCamelCase  ),
          ]:
            snake_case_					= tf.zeros(
                (self.model_tester.batch_size, self.model_tester.seq_length)				,    dtype=tf.intaa  )
        return inputs_dict







      @slow
      def       lowerCAmelCase_       (	self  )		->			Any:
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
        for model_class in self.all_model_classes[:2]:
          snake_case_					= self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )
          snake_case_					= model_class(lowerCamelCase  )

          @tf.function
          def run_in_graph_mode():
            return model(lowerCamelCase  )

          snake_case_					= run_in_graph_mode()
          self.assertIsNotNone(lowerCamelCase  )







      @slow
      def       lowerCAmelCase_       (	self  )		->			List[str]:
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
        for model_class in self.all_model_classes[:2]:
          snake_case_					= self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )
          snake_case_					= model_class(lowerCamelCase  )

          @tf.function(experimental_compile=lowerCamelCase  )
          def run_in_graph_mode():
            return model(lowerCamelCase  )

          snake_case_					= run_in_graph_mode()
          self.assertIsNotNone(lowerCamelCase  )







      @slow
      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
        for model_class in self.all_model_classes[:2]:
          snake_case_					= model_class(lowerCamelCase  )
          if getattr(lowerCamelCase				,    """hf_compute_loss"""				,    lowerCamelCase  ):
            # Test that model correctly compute the loss with kwargs
            snake_case_					= self._prepare_for_class(inputs_dict.copy()				,    lowerCamelCase				,    return_labels=lowerCamelCase  )
            # Is there a better way to remove these decoder inputs?
            snake_case_					= {
                key: val
                for key, val in prepared_for_class.items()
                if key not in ("""head_mask""", """decoder_head_mask""", """cross_attn_head_mask""", """decoder_input_ids""")
            }

            snake_case_					= {
                """labels""",
                """label""",
                """label_ids""",
                """start_positions""",
                """start_position""",
                """end_positions""",
                """end_position""",
                """next_sentence_label""",
            }
            snake_case_					= possible_label_cols.intersection(set(lowerCamelCase  )  )
            self.assertGreater(len(lowerCamelCase  )				,    0				,    msg="""No matching label names found!"""  )
            snake_case_					= {key: val for key, val in prepared_for_class.items() if key in label_names}
            snake_case_					= {key: val for key, val in prepared_for_class.items() if key not in label_names}
            self.assertGreater(len(lowerCamelCase  )				,    0  )

            # Make sure it works with XLA!
            model.compile(optimizer=tf.keras.optimizers.SGD(0.0  )				,    jit_compile=lowerCamelCase  )
            # Make sure the model fits without crashing regardless of where we pass the labels
            snake_case_					= model.fit(
                lowerCamelCase				,    validation_data=lowerCamelCase				,    steps_per_epoch=1				,    validation_steps=1				,    shuffle=lowerCamelCase				,    verbose=0				,    )
            snake_case_					= history.history["""loss"""][0]
            self.assertTrue(not isnan(lowerCamelCase  )  )
            snake_case_					= history.history["""val_loss"""][0]
            self.assertTrue(not isnan(lowerCamelCase  )  )

            # Now test it with separate labels, to make sure that path works in XLA too.
            snake_case_					= model_class(lowerCamelCase  )
            model.compile(optimizer=tf.keras.optimizers.SGD(0.0  )				,    jit_compile=lowerCamelCase  )
            snake_case_					= model.fit(
                lowerCamelCase				,    lowerCamelCase				,    validation_data=(inputs_minus_labels, labels)				,    steps_per_epoch=1				,    validation_steps=1				,    shuffle=lowerCamelCase				,    verbose=0				,    )

            snake_case_					= history.history["""loss"""][0]
            self.assertTrue(not isnan(lowerCamelCase  )  )
            snake_case_					= history.history["""val_loss"""][0]
            self.assertTrue(not isnan(lowerCamelCase  )  )







      @slow
      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
        snake_case_					= True
        snake_case_					= True

        if hasattr(lowerCamelCase				,    """use_cache"""  ):
          snake_case_					= True

        snake_case_					= getattr(self.model_tester				,    """encoder_seq_length"""				,    self.model_tester.seq_length  )
        snake_case_					= getattr(self.model_tester				,    """key_length"""				,    lowerCamelCase  )

        for model_class in self.all_model_classes[:2]:
          snake_case_					= self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )
          snake_case_					= model_class(lowerCamelCase  )
          model.build()
          snake_case_					= len(model(lowerCamelCase  )  )

          for key in list(class_inputs_dict.keys()  ):
            # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
            if key not in model.input_signature:
              del class_inputs_dict[key]
            # Check it's a tensor, in case the inputs dict has some bools in it too
            elif isinstance(class_inputs_dict[key]				,    tf.Tensor  ) and class_inputs_dict[key].dtype.is_integer:
              snake_case_					= tf.cast(class_inputs_dict[key]				,    tf.intaa  )

          if set(class_inputs_dict.keys()  ) != set(model.input_signature.keys()  ):
            continue  # Some models have inputs that the preparation functions don't create, we skip those

          with tempfile.TemporaryDirectory() as tmpdirname:
            model.save_pretrained(lowerCamelCase				,    saved_model=lowerCamelCase  )
            snake_case_					= os.path.join(lowerCamelCase				,    """saved_model"""				,    """1"""  )
            snake_case_					= tf.keras.models.load_model(lowerCamelCase  )
            snake_case_					= model(lowerCamelCase  )

            if self.is_encoder_decoder:
              snake_case_					= outputs["""encoder_hidden_states"""]
              snake_case_					= outputs["""encoder_attentions"""]
            else:
              snake_case_					= outputs["""hidden_states"""]
              snake_case_					= outputs["""attentions"""]

            self.assertEqual(len(lowerCamelCase  )				,    lowerCamelCase  )

            snake_case_					= getattr(
                self.model_tester				,    """expected_num_hidden_layers"""				,    self.model_tester.num_hidden_layers + 1  )

            self.assertEqual(len(lowerCamelCase  )				,    lowerCamelCase  )
            self.assertListEqual(
                list(output_hidden_states[0].shape[-2:]  )				,    [self.model_tester.seq_length, self.model_tester.hidden_size]				,    )

            self.assertEqual(len(lowerCamelCase  )				,    self.model_tester.num_hidden_layers  )
            self.assertListEqual(
                list(output_attentions[0].shape[-3:]  )				,    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]				,    )







      @slow
      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        tf.keras.mixed_precision.set_global_policy("""mixed_float16"""  )

        # try/finally block to ensure subsequent tests run in float32
        try:
          snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
            snake_case_					= self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )
            snake_case_					= model_class(lowerCamelCase  )
            snake_case_					= model(lowerCamelCase  )

            self.assertIsNotNone(lowerCamelCase  )
        finally:
          tf.keras.mixed_precision.set_global_policy("""float32"""  )







      @slow
      def       lowerCAmelCase_       (	self  )		->			List[str]:
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()
        # head_mask and decoder_head_mask has different shapes than other input args
        if "head_mask" in inputs_dict:
          del inputs_dict["head_mask"]
        if "decoder_head_mask" in inputs_dict:
          del inputs_dict["decoder_head_mask"]
        if "cross_attn_head_mask" in inputs_dict:
          del inputs_dict["cross_attn_head_mask"]
        snake_case_					= {
            module_member
            for model_class in self.all_model_classes
            for module in (import_module(model_class.__module__  ),)
            for module_member_name in dir(lowerCamelCase  )
            if module_member_name.endswith("""MainLayer"""  )
            for module_member in (getattr(lowerCamelCase				,    lowerCamelCase  ),)
            if isinstance(lowerCamelCase				,    lowerCamelCase  )
            and tf.keras.layers.Layer in module_member.__bases__
            and getattr(lowerCamelCase				,    """_keras_serializable"""				,    lowerCamelCase  )
        }

        for main_layer_class in tf_main_layer_classes:
          # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
          if "T5" in main_layer_class.__name__:
            # Take the same values than in TFT5ModelTester for this shared layer
            snake_case_					= TFSharedEmbeddings(self.model_tester.vocab_size				,    self.model_tester.hidden_size				,    name="""shared"""  )
            snake_case_					= False
            snake_case_					= main_layer_class(lowerCamelCase				,    embed_tokens=lowerCamelCase  )
          else:
            snake_case_					= main_layer_class(lowerCamelCase  )

          snake_case_					= {
              name: tf.keras.Input(tensor.shape[1:]				,    dtype=tensor.dtype  ) for name, tensor in inputs_dict.items()
          }

          if hasattr(self.model_tester				,    """num_labels"""  ):
            snake_case_					= self.model_tester.num_labels
          else:
            snake_case_					= 2

          snake_case_					= tf.data.Dataset.from_tensor_slices(
              (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)  ))  ).batch(1  )

          snake_case_					= main_layer(lowerCamelCase  )[0]
          snake_case_					= tf.keras.layers.Dense(lowerCamelCase				,    activation="""softmax"""				,    name="""outputs"""  )(lowerCamelCase  )
          snake_case_					= tf.keras.models.Model(inputs=lowerCamelCase				,    outputs=[outputs]  )

          model.compile(loss="""binary_crossentropy"""				,    optimizer="""adam"""				,    metrics=["""binary_accuracy"""]  )
          model.fit(lowerCamelCase				,    epochs=1  )

          with tempfile.TemporaryDirectory() as tmpdirname:
            snake_case_					= os.path.join(lowerCamelCase				,    """keras_model.h5"""  )
            model.save(lowerCamelCase  )
            if "T5" in main_layer_class.__name__:
              snake_case_					= tf.keras.models.load_model(
                  lowerCamelCase				,    custom_objects={
                      main_layer_class.__name__: main_layer_class,
                      """TFSharedEmbeddings""": TFSharedEmbeddings,
                  }				,    )
            else:
              snake_case_					= tf.keras.models.load_model(
                  lowerCamelCase				,    custom_objects={main_layer_class.__name__: main_layer_class}  )
            assert isinstance(lowerCamelCase				,    tf.keras.Model  )
            model(lowerCamelCase  )







      @slow
      def       lowerCAmelCase_       (	self  )		->			str:
        snake_case_					= self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes[:2]:
          snake_case_					= model_class(lowerCamelCase  )

          snake_case_					= copy.deepcopy(lowerCamelCase  )

          if not self.is_encoder_decoder:
            snake_case_					= inputs["""input_ids"""]
            del inputs["input_ids"]
          else:
            snake_case_					= inputs["""input_ids"""]
            snake_case_					= inputs.get("""decoder_input_ids"""				,    lowerCamelCase  )
            del inputs["input_ids"]
            inputs.pop("""decoder_input_ids"""				,    lowerCamelCase  )

          if not self.is_encoder_decoder:
            snake_case_					= model.get_input_embeddings()(lowerCamelCase  )
          else:
            snake_case_					= model.get_input_embeddings()(lowerCamelCase  )
            snake_case_					= model.get_input_embeddings()(lowerCamelCase  )

          snake_case_					= self._prepare_for_class(lowerCamelCase				,    lowerCamelCase  )

          @tf.function
          def run_in_graph_mode():
            return model(lowerCamelCase  )

          snake_case_					= run_in_graph_mode()
          self.assertIsNotNone(lowerCamelCase  )







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase  )		->			str:
        # special tokens cannot be bad tokens
        snake_case_					= []
        if model.config.bos_token_id is not None:
          special_tokens.append(model.config.bos_token_id  )
        if model.config.pad_token_id is not None:
          special_tokens.append(model.config.pad_token_id  )
        if model.config.eos_token_id is not None:
          special_tokens.append(model.config.eos_token_id  )

        # create random bad tokens that are not special tokens
        snake_case_					= []
        while len(lowerCamelCase  ) < num_bad_tokens:
          snake_case_					= tf.squeeze(ids_tensor((1, 1)				,    self.model_tester.vocab_size  )				,    0  ).numpy()[0]
          if token not in special_tokens:
            bad_tokens.append(lowerCamelCase  )
        return bad_tokens







      def       lowerCAmelCase_       (	self				,    lowerCamelCase  )		->			Union[str, Any]:
        for token_id in output_ids[0].numpy().tolist():
          self.assertGreaterEqual(lowerCamelCase				,    0  )
          self.assertLess(lowerCamelCase				,    self.model_tester.vocab_size  )







      def       lowerCAmelCase_       (	self				,    lowerCamelCase				,    lowerCamelCase  )		->			Tuple:
        # for all bad word tokens
        for bad_word_ids in bad_words_ids:
          # for all slices in batch
          for generated_ids_slice in generated_ids:
            # for all word idx
            for i in range(len(lowerCamelCase  )				,    len(lowerCamelCase  )  ):
              # if tokens match
              if generated_ids_slice[i - len(lowerCamelCase  ) : i] == bad_word_ids:
                return True
        return False




"""simple docstring"""
import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:Any		=     set()
						# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
						for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
												snake_case_					:Union[str, Any]		=     getattr(transformers.models.auto,   _lowercase,   _lowercase      )
												if module is None:
																		continue
												# all mappings in a single auto modeling file
												snake_case_					:int		=     [
												    x
												    for x in dir(_lowercase      )
												    if x.endswith("""_MAPPING_NAMES"""      )
												    and (x.startswith("""MODEL_"""      ) or x.startswith("""TF_MODEL_"""      ) or x.startswith("""FLAX_MODEL_"""      ))
												]
												for name in mapping_names:
																		snake_case_					:Tuple		=     getattr(_lowercase,   _lowercase      )
																		if mapping is not None:
																								for v in mapping.values():
																														if isinstance(_lowercase,   (list, tuple)      ):
																																				model_names.update(_lowercase      )
																														elif isinstance(_lowercase,   _lowercase      ):
																																				model_names.add(_lowercase      )

						return sorted(_lowercase      )
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:List[str]		=     set(get_all_model_names()      )

						with open("""tests/utils/tiny_model_summary.json"""      ) as fp:
												snake_case_					:Any		=     json.load(_lowercase      )
						snake_case_					:Any		=     set()
						for model_base_name in tiny_model_info:
												tiny_models_names.update(tiny_model_info[model_base_name]["""model_classes"""]      )

						# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
						snake_case_					:Any		=     model_names.difference(_lowercase      )
						for model_name in copy.copy(_lowercase      ):
												if not model_name.startswith("""TF"""      ) and f"""TF{model_name}""" in not_on_hub:
																		tiny_models_names.remove(_lowercase      )
												elif model_name.startswith("""TF"""      ) and model_name[2:] in not_on_hub:
																		tiny_models_names.remove(_lowercase      )

						return sorted(_lowercase      )
def   A_    (     _lowercase      ):







						'''simple docstring'''


						snake_case_					:Tuple		=     COMPOSITE_MODELS.values()

						# All tiny model base names on Hub
						snake_case_					:Any		=     get_all_model_names()
						snake_case_					:Dict		=     hf_api.list_models(
						    filter=ModelFilter(
						        author="""hf-internal-testing""",   )      )
						snake_case_					:List[Any]		=     set()
						for x in models:
												snake_case_					:List[Any]		=     x.modelId
												snake_case_,			snake_case_					:Tuple		=     model.split("""/"""      )
												if not model.startswith("""tiny-random-"""      ):
																		continue
												snake_case_					:str		=     model.replace("""tiny-random-""",   """"""      )
												if not model[0].isupper():
																		continue
												if model not in model_names and model not in special_models:
																		continue
												_models.add(_lowercase      )

						snake_case_					:List[str]		=     sorted(_models      )
						# All tiny model names on Hub
						snake_case_					:List[str]		=     {}
						for model in models:
												snake_case_					:List[Any]		=     f"""hf-internal-testing/tiny-random-{model}"""
												snake_case_					:int		=     model.split("""-"""      )[0]
												try:
																		snake_case_					:List[Any]		=     hf_api.repo_info(_lowercase      )
																		snake_case_					:Optional[Any]		=     {
																		    """tokenizer_classes""": set(),
																		    """processor_classes""": set(),
																		    """model_classes""": set(),
																		    """sha""": repo_info.sha,
																		}
												except Exception:
																		continue
												try:
																		time.sleep(1      )
																		snake_case_					:Optional[Any]		=     AutoTokenizer.from_pretrained(_lowercase      )
																		content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:Union[str, Any]		=     AutoTokenizer.from_pretrained(_lowercase,   use_fast=_lowercase      )
																		content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:Any		=     AutoImageProcessor.from_pretrained(_lowercase      )
																		content["processor_classes"].add(img_p.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:List[Any]		=     AutoFeatureExtractor.from_pretrained(_lowercase      )
																		if not isinstance(_lowercase,   _lowercase      ):
																								content["processor_classes"].add(feat_p.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:str		=     getattr(_lowercase,   _lowercase      )
																		snake_case_					:Tuple		=     model_class.from_pretrained(_lowercase      )
																		content["model_classes"].add(m.__class__.__name__      )
												except Exception:
																		pass
												try:
																		time.sleep(1      )
																		snake_case_					:List[Any]		=     getattr(_lowercase,   f"""TF{model}"""      )
																		snake_case_					:List[str]		=     model_class.from_pretrained(_lowercase      )
																		content["model_classes"].add(m.__class__.__name__      )
												except Exception:
																		pass

												snake_case_					:Union[str, Any]		=     sorted(content["""tokenizer_classes"""]      )
												snake_case_					:Dict		=     sorted(content["""processor_classes"""]      )
												snake_case_					:List[str]		=     sorted(content["""model_classes"""]      )

												snake_case_					:Tuple		=     content
												with open(os.path.join(_lowercase,   """hub_tiny_model_summary.json"""      ),   """w"""      ) as fp:
																		json.dump(_lowercase,   _lowercase,   ensure_ascii=_lowercase,   indent=4      )


if __name__ == "__main__":
						__a           =							argparse.ArgumentParser()
						parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
						__a           =							parser.parse_args()

						# This has to be `spawn` to avoid hanging forever!
						multiprocessing.set_start_method("spawn")

						__a           =							"tiny_models"
						__a           =							True
						__a           =							None
						__a           =							get_tiny_model_names_from_repo()
						__a           =							True
						__a           =							True
						__a           =							"hf-internal-testing"

						create_tiny_models(
						    output_path,
						    all,
						    model_types,
						    models_to_skip,
						    no_check,
						    upload,
						    organization,
						    token=os.environ.get("TOKEN", None),
						    num_workers=args.num_workers,
						)
