

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import TvltImageProcessor





def    _snake_case		(snake_case_				:    Dict						,					snake_case_				:    Optional[int]=10						,					snake_case_				:    Tuple=10						,					snake_case_				:    Any=False						,					snake_case_				:    int=False     )       ->		Optional[Any]:
  __UpperCAmelCase  :     List[Any]		=    []
  for i in range(image_processor_tester.num_frames     ):
    video.append(np.random.randint(255						,					size=(image_processor_tester.num_channels, width, height)						,					dtype=np.uinta     )     )

  if not numpify and not torchify:
    # PIL expects the channel dimension as last dimension
    __UpperCAmelCase  :     Any		=    [Image.fromarray(np.moveaxis(snake_case_						,					0						,					-1     )     ) for frame in video]

  if torchify:
    __UpperCAmelCase  :     Tuple		=    [torch.from_numpy(snake_case_     ) for frame in video]

  return video





def    _snake_case		(snake_case_				:    Any						,					snake_case_				:    str=False						,					snake_case_				:    Dict=False						,					snake_case_				:    Any=False     )       ->		List[Any]:
  assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

  __UpperCAmelCase  :     Dict		=    []
  for i in range(image_processor_tester.batch_size     ):
    if equal_resolution:
      __UpperCAmelCase  :     List[Any]		=    image_processor_tester.max_resolution
    else:
      __UpperCAmelCase, __UpperCAmelCase  :     Optional[int]		=    np.random.choice(
          np.arange(image_processor_tester.min_resolution						,					image_processor_tester.max_resolution     )						,					2     )
      __UpperCAmelCase  :     List[Any]		=    prepare_video(
          image_processor_tester=snake_case_						,					width=snake_case_						,					height=snake_case_						,					numpify=snake_case_						,					torchify=snake_case_						,					)
    video_inputs.append(snake_case_     )

  return video_inputs


class     lowerCamelCase_   ( unittest.TestCase):




 def __init__( self     ,     _UpperCAmelCase     ,     _UpperCAmelCase=7     ,     _UpperCAmelCase=3     ,     _UpperCAmelCase=4     ,     _UpperCAmelCase=18     ,     _UpperCAmelCase=30     ,     _UpperCAmelCase=400     ,     _UpperCAmelCase=True     ,     _UpperCAmelCase=None     ,     _UpperCAmelCase=True     ,     _UpperCAmelCase=[0.5, 0.5, 0.5]     ,     _UpperCAmelCase=[0.5, 0.5, 0.5]     ,     _UpperCAmelCase=True     ,     _UpperCAmelCase=None     ,     ):
   __UpperCAmelCase  :     Optional[int]		=    size if size is not None else {'shortest_edge': 18}
   __UpperCAmelCase  :     List[str]		=    crop_size if crop_size is not None else {'height': 18, 'width': 18}

   __UpperCAmelCase  :     Union[str, Any]		=    parent
   __UpperCAmelCase  :     Optional[Any]		=    batch_size
   __UpperCAmelCase  :     Dict		=    num_channels
   __UpperCAmelCase  :     Optional[int]		=    num_frames
   __UpperCAmelCase  :     int		=    image_size
   __UpperCAmelCase  :     Optional[Any]		=    min_resolution
   __UpperCAmelCase  :     List[str]		=    max_resolution
   __UpperCAmelCase  :     Optional[Any]		=    do_resize
   __UpperCAmelCase  :     Optional[Any]		=    size
   __UpperCAmelCase  :     int		=    do_normalize
   __UpperCAmelCase  :     Optional[Any]		=    image_mean
   __UpperCAmelCase  :     Union[str, Any]		=    image_std
   __UpperCAmelCase  :     int		=    do_center_crop
   __UpperCAmelCase  :     str		=    crop_size




 def 						a					( self       ):
   return {
       "image_mean": self.image_mean,
       "image_std": self.image_std,
       "do_normalize": self.do_normalize,
       "do_resize": self.do_resize,
       "size": self.size,
       "do_center_crop": self.do_center_crop,
       "crop_size": self.crop_size,
   }



@require_torch
@require_vision
class     lowerCamelCase_   ( _lowerCAmelCase  ,							unittest.TestCase):
 _lowerCAmelCase       		=  TvltImageProcessor if is_vision_available() else None




 def 						a					( self       ):
   __UpperCAmelCase  :     List[str]		=    TvltImageProcessorTester(self       )




 @property
 def 						a					( self       ):
   return self.image_processor_tester.prepare_image_processor_dict()




 def 						a					( self       ):
   __UpperCAmelCase  :     Any		=    self.image_processing_class(**self.image_processor_dict       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'image_mean'       )       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'image_std'       )       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'do_normalize'       )       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'do_resize'       )       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'do_center_crop'       )       )
   self.assertTrue(hasattr(_UpperCAmelCase     ,     'size'       )       )




 def 						a					( self       ):
   # Initialize image_processor
   __UpperCAmelCase  :     Tuple		=    self.image_processing_class(**self.image_processor_dict       )
   # create random PIL videos
   __UpperCAmelCase  :     Optional[int]		=    prepare_video_inputs(self.image_processor_tester     ,     equal_resolution=_UpperCAmelCase       )
   for video in video_inputs:
     self.assertIsInstance(_UpperCAmelCase     ,     _UpperCAmelCase       )
     self.assertIsInstance(video[0]     ,     Image.Image       )

   # Test not batched input
   __UpperCAmelCase  :     Dict		=    image_processor(video_inputs[0]     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           1,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )

   # Test batched
   __UpperCAmelCase  :     int		=    image_processor(_UpperCAmelCase     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           self.image_processor_tester.batch_size,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )




 def 						a					( self       ):
   # Initialize image_processor
   __UpperCAmelCase  :     List[str]		=    self.image_processing_class(**self.image_processor_dict       )
   # create random numpy tensors
   __UpperCAmelCase  :     Union[str, Any]		=    prepare_video_inputs(self.image_processor_tester     ,     equal_resolution=_UpperCAmelCase     ,     numpify=_UpperCAmelCase       )
   for video in video_inputs:
     self.assertIsInstance(_UpperCAmelCase     ,     _UpperCAmelCase       )
     self.assertIsInstance(video[0]     ,     np.ndarray       )

   # Test not batched input
   __UpperCAmelCase  :     Optional[Any]		=    image_processor(video_inputs[0]     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           1,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )

   # Test batched
   __UpperCAmelCase  :     Dict		=    image_processor(_UpperCAmelCase     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           self.image_processor_tester.batch_size,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )




 def 						a					( self       ):
   # Initialize image_processor
   __UpperCAmelCase  :     List[str]		=    self.image_processing_class(**self.image_processor_dict       )
   # create random PyTorch tensors
   __UpperCAmelCase  :     Optional[Any]		=    prepare_video_inputs(self.image_processor_tester     ,     equal_resolution=_UpperCAmelCase     ,     torchify=_UpperCAmelCase       )
   for video in video_inputs:
     self.assertIsInstance(_UpperCAmelCase     ,     _UpperCAmelCase       )
     self.assertIsInstance(video[0]     ,     torch.Tensor       )

   # Test not batched input
   __UpperCAmelCase  :     str		=    image_processor(video_inputs[0]     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           1,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )

   # Test batched
   __UpperCAmelCase  :     List[Any]		=    image_processor(_UpperCAmelCase     ,     return_tensors='pt'       ).pixel_values
   self.assertEqual(
       encoded_videos.shape     ,     (
           self.image_processor_tester.batch_size,
           self.image_processor_tester.num_frames,
           self.image_processor_tester.num_channels,
           self.image_processor_tester.crop_size['height'],
           self.image_processor_tester.crop_size['width'],
       )     ,     )








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    _snake_case		()       ->		Optional[int]:
  __UpperCAmelCase  :     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"]:
    __UpperCAmelCase  :     str		=    getattr(transformers.models.auto						,					snake_case_						,					snake_case_     )
    if module is None:
      continue
    # all mappings in a single auto modeling file
    __UpperCAmelCase  :     Dict		=    [
        x
        for x in dir(snake_case_     )
        if x.endswith('_MAPPING_NAMES'     )
        and (x.startswith('MODEL_'     ) or x.startswith('TF_MODEL_'     ) or x.startswith('FLAX_MODEL_'     ))
    ]
    for name in mapping_names:
      __UpperCAmelCase  :     Optional[int]		=    getattr(snake_case_						,					snake_case_     )
      if mapping is not None:
        for v in mapping.values():
          if isinstance(snake_case_						,					(list, tuple)     ):
            model_names.update(snake_case_     )
          elif isinstance(snake_case_						,					snake_case_     ):
            model_names.add(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		()       ->		Any:
  # All model names defined in auto mappings
  __UpperCAmelCase  :     int		=    set(get_all_model_names()     )

  with open('tests/utils/tiny_model_summary.json'     ) as fp:
    __UpperCAmelCase  :     Tuple		=    json.load(snake_case_     )
  __UpperCAmelCase  :     int		=    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.
  __UpperCAmelCase  :     Tuple		=    model_names.difference(snake_case_     )
  for model_name in copy.copy(snake_case_     ):
    if not model_name.startswith('TF'     ) and F"TF{model_name}" in not_on_hub:
      tiny_models_names.remove(snake_case_     )
    elif model_name.startswith('TF'     ) and model_name[2:] in not_on_hub:
      tiny_models_names.remove(snake_case_     )

  return sorted(snake_case_     )





def    _snake_case		(snake_case_				:    List[str]     )       ->		Tuple:
  __UpperCAmelCase  :     Dict		=    COMPOSITE_MODELS.values()

  # All tiny model base names on Hub
  __UpperCAmelCase  :     Optional[int]		=    get_all_model_names()
  __UpperCAmelCase  :     List[Any]		=    hf_api.list_models(
      filter=ModelFilter(
          author='hf-internal-testing'						,					)     )
  __UpperCAmelCase  :     Dict		=    set()
  for x in models:
    __UpperCAmelCase  :     Union[str, Any]		=    x.modelId
    __UpperCAmelCase, __UpperCAmelCase  :     List[str]		=    model.split('/'     )
    if not model.startswith('tiny-random-'     ):
      continue
    __UpperCAmelCase  :     Optional[Any]		=    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(snake_case_     )

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

    __UpperCAmelCase  :     Optional[int]		=    sorted(content['tokenizer_classes']     )
    __UpperCAmelCase  :     List[str]		=    sorted(content['processor_classes']     )
    __UpperCAmelCase  :     Tuple		=    sorted(content['model_classes']     )

    __UpperCAmelCase  :     str		=    content
    with open(os.path.join(snake_case_						,					'hub_tiny_model_summary.json'     )						,					'w'     ) as fp:
      json.dump(snake_case_						,					snake_case_						,					ensure_ascii=snake_case_						,					indent=4     )


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

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

      _SCREAMING_SNAKE_CASE          = '''tiny_models'''
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = None
      _SCREAMING_SNAKE_CASE          = get_tiny_model_names_from_repo()
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = True
      _SCREAMING_SNAKE_CASE          = '''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,
      )





