




"""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

A_						=				logging.get_logger(__name__)






@add_end_docstrings(__a )
class 					lowercase(     __a ):







 '''simple docstring'''





 def __init__(				self:		Optional[Any],      *a_:		Dict,      **a_:		int		):




   '''simple docstring'''



   super().__init__(*a_,      **a_		)
   requires_backends(self,      """decord"""		)
   self.check_model_type(a_		)


 def  UpperCamelCase_   (				self:		Union[str, Any],      a_:		str=None,      a_:		Any=None,      a_:		Optional[int]=None		):




   '''simple docstring'''



   _snake_case							:		List[str]								=  {}
   if frame_sampling_rate is not None:
     _snake_case							:		str								=  frame_sampling_rate
   if num_frames is not None:
     _snake_case							:		List[str]								=  num_frames

   _snake_case							:		Optional[Any]								=  {}
   if top_k is not None:
     _snake_case							:		Tuple								=  top_k
   return preprocess_params, {}, postprocess_params


 def __call__(				self:		Union[str, Any],      a_:		Union[str, List[str]],      **a_:		Tuple		):




   '''simple docstring'''



   return super().__call__(a_,      **a_		)


 def  UpperCamelCase_   (				self:		Union[str, Any],      a_:		List[str],      a_:		Optional[int]=None,      a_:		Optional[int]=1		):




   '''simple docstring'''



   if num_frames is None:
     _snake_case							:		Optional[Any]								=  self.model.config.num_frames

   if video.startswith("""http://"""		) or video.startswith("""https://"""		):
     _snake_case							:		Tuple								=  BytesIO(requests.get(a_		).content		)

   _snake_case							:		Union[str, Any]								=  VideoReader(a_		)
   videoreader.seek(0		)

   _snake_case							:		Union[str, Any]								=  0
   _snake_case							:		List[str]								=  num_frames * frame_sampling_rate - 1
   _snake_case							:		Dict								=  np.linspace(a_,      a_,      num=a_,      dtype=np.intaa		)

   _snake_case							:		str								=  videoreader.get_batch(a_		).asnumpy()
   _snake_case							:		Union[str, Any]								=  list(a_		)

   _snake_case							:		Union[str, Any]								=  self.image_processor(a_,      return_tensors=self.framework		)
   return model_inputs


 def  UpperCamelCase_   (				self:		str,      a_:		str		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  self.model(**a_		)
   return model_outputs


 def  UpperCamelCase_   (				self:		Union[str, Any],      a_:		List[str],      a_:		str=5		):




   '''simple docstring'''



   if top_k > self.model.config.num_labels:
     _snake_case							:		Optional[int]								=  self.model.config.num_labels

   if self.framework == "pt":
     _snake_case							:		Tuple								=  model_outputs.logits.softmax(-1		)[0]
     _snake_case		,					_snake_case							:		List[Any]								=  probs.topk(a_		)
   else:
     raise ValueError(f"Unsupported framework: {self.framework}"		)

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







def        a						(      _UpperCAmelCase							:					Any						):







		'''simple docstring'''





		__UpperCAmelCase    :     Any													=	0
		__UpperCAmelCase    :     str													=	len(_UpperCAmelCase						)

		for i in range(n - 1						):
				for j in range(i + 1 ,   _UpperCAmelCase						):
						if arr[i] > arr[j]:
								num_inversions += 1

		return num_inversions

def        a						(      _UpperCAmelCase							:					str						):







		'''simple docstring'''





		if len(_UpperCAmelCase						) <= 1:
				return arr, 0
		__UpperCAmelCase    :     Dict													=	len(_UpperCAmelCase						) // 2
		__UpperCAmelCase    :     Union[str, Any]													=	arr[0:mid]
		__UpperCAmelCase    :     Optional[Any]													=	arr[mid:]

		__UpperCAmelCase							,					__UpperCAmelCase    :     Tuple													=	count_inversions_recursive(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     Optional[Any]													=	count_inversions_recursive(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	_count_cross_inversions(_UpperCAmelCase ,   _UpperCAmelCase						)

		__UpperCAmelCase    :     List[str]													=	inversion_p + inversions_q + cross_inversions
		return c, num_inversions

def        a						(      _UpperCAmelCase							:					List[str] ,   _UpperCAmelCase							:					Any						):







		'''simple docstring'''





		__UpperCAmelCase    :     List[Any]													=	[]
		__UpperCAmelCase    :     Any													=	0
		while i < len(_UpperCAmelCase						) and j < len(_UpperCAmelCase						):
				if p[i] > q[j]:
						# if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
						# These are all inversions. The claim emerges from the
						# property that P is sorted.
						num_inversion += len(_UpperCAmelCase						) - i
						r.append(q[j]						)
						j += 1
				else:
						r.append(p[i]						)
						i += 1

		if i < len(_UpperCAmelCase						):
				r.extend(p[i:]						)
		else:
				r.extend(q[j:]						)

		return r, num_inversion

def        a						(      ):







		'''simple docstring'''





		__UpperCAmelCase    :     Optional[Any]													=	[10, 2, 1, 5, 5, 2, 11]

		# this arr has 8 inversions:
		# (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

		__UpperCAmelCase    :     List[str]													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     Tuple													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 8

		print('''number of inversions = ''' ,   _UpperCAmelCase						)

		# testing an array with zero inversion (a sorted arr_1)

		arr_a.sort()
		__UpperCAmelCase    :     Any													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 0
		print('''number of inversions = ''' ,   _UpperCAmelCase						)

		# an empty list should also have zero inversions
		__UpperCAmelCase    :     Tuple													=	[]
		__UpperCAmelCase    :     Union[str, Any]													=	count_inversions_bf(_UpperCAmelCase						)
		__UpperCAmelCase							,					__UpperCAmelCase    :     int													=	count_inversions_recursive(_UpperCAmelCase						)

		assert num_inversions_bf == num_inversions_recursive == 0
		print('''number of inversions = ''' ,   _UpperCAmelCase						)


if __name__ == "__main__":
				main()





