
"""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_			(					)     ->							List[Any]:


     """simple docstring"""







     UpperCAmelCase_						:    int    					=  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_						:    Any    					=  getattr(transformers.models.auto						, _UpperCamelCase						, _UpperCamelCase      )
          if module is None:
               continue
          # all mappings in a single auto modeling file
          UpperCAmelCase_						:    Any    					=  [
              x
              for x in dir(_UpperCamelCase      )
              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[Any]    					=  getattr(_UpperCamelCase						, _UpperCamelCase      )
               if mapping is not None:
                    for v in mapping.values():
                         if isinstance(_UpperCamelCase						, (list, tuple)      ):
                              model_names.update(_UpperCamelCase      )
                         elif isinstance(_UpperCamelCase						, _UpperCamelCase      ):
                              model_names.add(_UpperCamelCase      )

     return sorted(_UpperCamelCase      )




def 			A_			(					)     ->							List[Any]:


     """simple docstring"""







     UpperCAmelCase_						:    int    					=  set(get_all_model_names()      )

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

     return sorted(_UpperCamelCase      )




def 			A_			(					lowercase      )     ->							Tuple:


     """simple docstring"""







     UpperCAmelCase_						:    Tuple    					=  COMPOSITE_MODELS.values()

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

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

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

          UpperCAmelCase_						:    Any    					=  content
          with open(os.path.join(_UpperCamelCase						, """hub_tiny_model_summary.json"""      )						, """w"""      ) as fp:
               json.dump(_UpperCamelCase						, _UpperCamelCase						, ensure_ascii=_UpperCamelCase						, indent=4      )


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

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

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



"""simple docstring"""







from math import radians as angle_to_radians
from math import sin

# Acceleration Constant on Earth (unit m/s^2)
lowercase_						    =					9.8_0665




def 			A_			(					lowercase						, lowercase      )     ->							None:


     """simple docstring"""







     if not isinstance(lowercase						, (int, float)      ):
          raise TypeError("""Invalid velocity. Should be a positive number."""      )

     if not isinstance(lowercase						, (int, float)      ):
          raise TypeError("""Invalid angle. Range is 1-90 degrees."""      )

     # Ensure valid angle
     if angle > 90 or angle < 1:
          raise ValueError("""Invalid angle. Range is 1-90 degrees."""      )

     # Ensure valid velocity
     if init_velocity < 0:
          raise ValueError("""Invalid velocity. Should be a positive number."""      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Any    					=  angle_to_radians(2 * angle      )
     return round(init_velocity**2 * sin(lowercase      ) / g						, 2      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Union[str, Any]    					=  angle_to_radians(lowercase      )
     return round(init_velocity**2 * sin(lowercase      ) ** 2 / (2 * g)						, 2      )




def 			A_			(					lowercase						, lowercase      )     ->							float:


     """simple docstring"""







     check_args(lowercase						, lowercase      )
     UpperCAmelCase_						:    Optional[int]    					=  angle_to_radians(lowercase      )
     return round(2 * init_velocity * sin(lowercase      ) / g						, 2      )




def 			A_			(					)     ->							None:


     """simple docstring"""







     UpperCAmelCase_					,UpperCAmelCase_						:    Optional[int]    					=  25, 20
     assert horizontal_distance(lowercase						, lowercase      ) == 40.97
     assert max_height(lowercase						, lowercase      ) == 3.73
     assert total_time(lowercase						, lowercase      ) == 1.74


if __name__ == "__main__":
       from doctest import testmod

       testmod()

       # Get input from user
       lowercase_						    =					float(input("Initial Velocity: ").strip())

       # Get input from user
       lowercase_						    =					float(input("angle: ").strip())

       # Print results
       print()
       print("Results: ")
       print(f"""Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]""")
       print(f"""Maximum Height: {max_height(init_vel, angle)!s} [m]""")
       print(f"""Total Time: {total_time(init_vel, angle)!s} [s]""")

