"""simple docstring"""




import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
				from cookiecutter.main import cookiecutter

				__lowerCamelCase											=  True
except ImportError:
				__lowerCamelCase											=  False

__lowerCamelCase											=  logging.get_logger(__name__)  # pylint: disable=invalid-name






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							return AddNewModelCommand(args.testing       ,    args.testing_file       ,    path=args.path				)


class     UpperCamelCase__(			__A ):





						@staticmethod
						def 				snake_case__	(       __UpperCAmelCase     )					->				int:
													A__	     =							parser.add_parser('add-new-model'     )
													add_new_model_parser.add_argument('--testing'		,action='store_true'		,help='If in testing mode.'     )
													add_new_model_parser.add_argument('--testing_file'		,type=__UpperCAmelCase		,help='Configuration file on which to run.'     )
													add_new_model_parser.add_argument(
													    '--path'		,type=__UpperCAmelCase		,help='Path to cookiecutter. Should only be used for testing purposes.'     )
													add_new_model_parser.set_defaults(func=__UpperCAmelCase     )





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase=None		,*__UpperCAmelCase     )					->				Any:
													A__	     =							testing
													A__	     =							testing_file
													A__	     =							path





						def 				snake_case__	(       self     )					->				Optional[int]:
													warnings.warn(
													    'The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. '
													    'It is not actively maintained anymore, so might give a result that won\'t pass all tests and quality '
													    'checks, you should use `transformers-cli add-new-model-like` instead.'     )
													if not _has_cookiecutter:
																				raise ImportError(
																				    'Model creation dependencies are required to use the `add_new_model` command. Install them by running '
																				    'the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n'     )
													# Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
													A__	     =							[directory for directory in os.listdir() if 'cookiecutter-template-' == directory[:22]]
													if len(__UpperCAmelCase     ) > 0:
																				raise ValueError(
																				    'Several directories starting with `cookiecutter-template-` in current working directory. '
																				    'Please clean your directory by removing all folders starting with `cookiecutter-template-` or '
																				    'change your working directory.'     )

													A__	     =							(
													    Path(__UpperCAmelCase     ).parent.parent.parent.parent if self._path is None else Path(self._path     ).parent.parent
													)
													A__	     =							path_to_transformer_root / 'templates' / 'adding_a_new_model'

													# Execute cookiecutter
													if not self._testing:
																				cookiecutter(str(__UpperCAmelCase     )     )
													else:
																				with open(self._testing_file		,'r'     ) as configuration_file:
																											A__	     =							json.load(__UpperCAmelCase     )

																				cookiecutter(
																				    str(path_to_cookiecutter if self._path is None else self._path     )		,no_input=__UpperCAmelCase		,extra_context=__UpperCAmelCase		,)

													A__	     =							[directory for directory in os.listdir() if 'cookiecutter-template-' in directory[:22]][0]

													# Retrieve configuration
													with open(directory + '/configuration.json'		,'r'     ) as configuration_file:
																				A__	     =							json.load(__UpperCAmelCase     )

													A__	     =							configuration['lowercase_modelname']
													A__	     =							configuration['generate_tensorflow_pytorch_and_flax']
													os.remove(f'''{directory}/configuration.json'''     )

													A__	     =							'PyTorch' in generate_tensorflow_pytorch_and_flax
													A__	     =							'TensorFlow' in generate_tensorflow_pytorch_and_flax
													A__	     =							'Flax' in generate_tensorflow_pytorch_and_flax

													A__	     =							f'''{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}'''
													os.makedirs(__UpperCAmelCase		,exist_ok=__UpperCAmelCase     )
													os.makedirs(f'''{path_to_transformer_root}/tests/models/{lowercase_model_name}'''		,exist_ok=__UpperCAmelCase     )

													# Tests require submodules as they have parent imports
													with open(f'''{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py'''		,'w'     ):
																				pass

													shutil.move(
													    f'''{directory}/__init__.py'''		,f'''{model_dir}/__init__.py'''		,)
													shutil.move(
													    f'''{directory}/configuration_{lowercase_model_name}.py'''		,f'''{model_dir}/configuration_{lowercase_model_name}.py'''		,)

													def remove_copy_lines(__UpperCAmelCase     ):
																				with open(__UpperCAmelCase		,'r'     ) as f:
																											A__	     =							f.readlines()
																				with open(__UpperCAmelCase		,'w'     ) as f:
																											for line in lines:
																																		if "# Copied from transformers." not in line:
																																									f.write(__UpperCAmelCase     )

													if output_pytorch:
																				if not self._testing:
																											remove_copy_lines(f'''{directory}/modeling_{lowercase_model_name}.py'''     )

																				shutil.move(
																				    f'''{directory}/modeling_{lowercase_model_name}.py'''		,f'''{model_dir}/modeling_{lowercase_model_name}.py'''		,)

																				shutil.move(
																				    f'''{directory}/test_modeling_{lowercase_model_name}.py'''		,f'''{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py'''		,)
													else:
																				os.remove(f'''{directory}/modeling_{lowercase_model_name}.py'''     )
																				os.remove(f'''{directory}/test_modeling_{lowercase_model_name}.py'''     )

													if output_tensorflow:
																				if not self._testing:
																											remove_copy_lines(f'''{directory}/modeling_tf_{lowercase_model_name}.py'''     )

																				shutil.move(
																				    f'''{directory}/modeling_tf_{lowercase_model_name}.py'''		,f'''{model_dir}/modeling_tf_{lowercase_model_name}.py'''		,)

																				shutil.move(
																				    f'''{directory}/test_modeling_tf_{lowercase_model_name}.py'''		,f'''{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py'''		,)
													else:
																				os.remove(f'''{directory}/modeling_tf_{lowercase_model_name}.py'''     )
																				os.remove(f'''{directory}/test_modeling_tf_{lowercase_model_name}.py'''     )

													if output_flax:
																				if not self._testing:
																											remove_copy_lines(f'''{directory}/modeling_flax_{lowercase_model_name}.py'''     )

																				shutil.move(
																				    f'''{directory}/modeling_flax_{lowercase_model_name}.py'''		,f'''{model_dir}/modeling_flax_{lowercase_model_name}.py'''		,)

																				shutil.move(
																				    f'''{directory}/test_modeling_flax_{lowercase_model_name}.py'''		,f'''{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py'''		,)
													else:
																				os.remove(f'''{directory}/modeling_flax_{lowercase_model_name}.py'''     )
																				os.remove(f'''{directory}/test_modeling_flax_{lowercase_model_name}.py'''     )

													shutil.move(
													    f'''{directory}/{lowercase_model_name}.md'''		,f'''{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md'''		,)

													shutil.move(
													    f'''{directory}/tokenization_{lowercase_model_name}.py'''		,f'''{model_dir}/tokenization_{lowercase_model_name}.py'''		,)

													shutil.move(
													    f'''{directory}/tokenization_fast_{lowercase_model_name}.py'''		,f'''{model_dir}/tokenization_{lowercase_model_name}_fast.py'''		,)

													from os import fdopen, remove
													from shutil import copymode, move
													from tempfile import mkstemp

													def replace(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     ):
																				# Create temp file
																				A__     ,  A__	     =							mkstemp()
																				A__	     =							False
																				with fdopen(__UpperCAmelCase		,'w'     ) as new_file:
																											with open(__UpperCAmelCase     ) as old_file:
																																		for line in old_file:
																																									new_file.write(__UpperCAmelCase     )
																																									if line_to_copy_below in line:
																																																A__	     =							True
																																																for line_to_copy in lines_to_copy:
																																																							new_file.write(__UpperCAmelCase     )

																				if not line_found:
																											raise ValueError(f'''Line {line_to_copy_below} was not found in file.'''     )

																				# Copy the file permissions from the old file to the new file
																				copymode(__UpperCAmelCase		,__UpperCAmelCase     )
																				# Remove original file
																				remove(__UpperCAmelCase     )
																				# Move new file
																				move(__UpperCAmelCase		,__UpperCAmelCase     )

													def skip_units(__UpperCAmelCase     ):
																				return (
																				    ("generating PyTorch" in line and not output_pytorch)
																				    or ("generating TensorFlow" in line and not output_tensorflow)
																				    or ("generating Flax" in line and not output_flax)
																				)

													def replace_in_files(__UpperCAmelCase     ):
																				with open(__UpperCAmelCase     ) as datafile:
																											A__	     =							[]
																											A__	     =							False
																											A__	     =							False
																											for line in datafile:
																																		if "# To replace in: " in line and "##" not in line:
																																									A__	     =							line.split('"'     )[1]
																																									A__	     =							skip_units(__UpperCAmelCase     )
																																		elif "# Below: " in line and "##" not in line:
																																									A__	     =							line.split('"'     )[1]
																																									A__	     =							skip_units(__UpperCAmelCase     )
																																		elif "# End." in line and "##" not in line:
																																									if not skip_file and not skip_snippet:
																																																replace(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )

																																									A__	     =							[]
																																		elif "# Replace with" in line and "##" not in line:
																																									A__	     =							[]
																																		elif "##" not in line:
																																									lines_to_copy.append(__UpperCAmelCase     )

																				remove(__UpperCAmelCase     )

													replace_in_files(f'''{directory}/to_replace_{lowercase_model_name}.py'''     )
													os.rmdir(__UpperCAmelCase     )






"""simple docstring"""




from io import BytesIO
from typing import List, Union

import requests

from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_decord_available():
				import numpy as np
				from decord import VideoReader


if is_torch_available():
				from ..models.auto.modeling_auto import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING

__lowerCamelCase											=  logging.get_logger(__name__)
@add_end_docstrings(__A )
class     UpperCamelCase__(			__A ):





						def __init__(       self		,*__UpperCAmelCase		,**__UpperCAmelCase     )					->				List[Any]:
													super().__init__(*__UpperCAmelCase		,**__UpperCAmelCase     )
													requires_backends(self		,'decord'     )
													self.check_model_type(__UpperCAmelCase     )





						def 				snake_case__	(       self		,__UpperCAmelCase=None		,__UpperCAmelCase=None		,__UpperCAmelCase=None     )					->				Any:
													A__	     =							{}
													if frame_sampling_rate is not None:
																				A__	     =							frame_sampling_rate
													if num_frames is not None:
																				A__	     =							num_frames

													A__	     =							{}
													if top_k is not None:
																				A__	     =							top_k
													return preprocess_params, {}, postprocess_params





						def __call__(       self		,__UpperCAmelCase		,**__UpperCAmelCase     )					->				Optional[int]:
													return super().__call__(__UpperCAmelCase		,**__UpperCAmelCase     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase=None		,__UpperCAmelCase=1     )					->				List[Any]:
													if num_frames is None:
																				A__	     =							self.model.config.num_frames

													if video.startswith('http://'     ) or video.startswith('https://'     ):
																				A__	     =							BytesIO(requests.get(__UpperCAmelCase     ).content     )

													A__	     =							VideoReader(__UpperCAmelCase     )
													videoreader.seek(0     )

													A__	     =							0
													A__	     =							num_frames * frame_sampling_rate - 1
													A__	     =							np.linspace(__UpperCAmelCase		,__UpperCAmelCase		,num=__UpperCAmelCase		,dtype=np.intaa     )

													A__	     =							videoreader.get_batch(__UpperCAmelCase     ).asnumpy()
													A__	     =							list(__UpperCAmelCase     )

													A__	     =							self.image_processor(__UpperCAmelCase		,return_tensors=self.framework     )
													return model_inputs





						def 				snake_case__	(       self		,__UpperCAmelCase     )					->				Optional[int]:
													A__	     =							self.model(**__UpperCAmelCase     )
													return model_outputs





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase=5     )					->				int:
													if top_k > self.model.config.num_labels:
																				A__	     =							self.model.config.num_labels

													if self.framework == "pt":
																				A__	     =							model_outputs.logits.softmax(-1     )[0]
																				A__     ,  A__	     =							probs.topk(__UpperCAmelCase     )
													else:
																				raise ValueError(f'''Unsupported framework: {self.framework}'''     )

													A__	     =							scores.tolist()
													A__	     =							ids.tolist()
													return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(__UpperCAmelCase		,__UpperCAmelCase     )]





