

import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)






class _UpperCamelCase							(							unittest.TestCase      ):
			'''simple docstring'''







			def 							__UpperCamelCase       (	self							:       Dict		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					int    =				Vector([1, 2, 3]		)
				self.assertEqual(x.component(0		)					,					1		)
				self.assertEqual(x.component(2		)					,					3		)
				SCREAMING_SNAKE_CASE      :					Dict    =				Vector()
			def 							__UpperCamelCase       (	self							:       List[Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					str    =				Vector([0, 0, 0, 0, 0, 1]		)
				self.assertEqual(str(__UpperCAmelCase		)					,					"(0,0,0,0,0,1)"		)
			def 							__UpperCamelCase       (	self							:       Any		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				Vector([1, 2, 3, 4]		)
				self.assertEqual(len(__UpperCAmelCase		)					,					4		)
			def 							__UpperCamelCase       (	self							:       Optional[Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[Any]    =				Vector([1, 2]		)
				SCREAMING_SNAKE_CASE      :					Dict    =				Vector([1, 2, 3, 4, 5]		)
				SCREAMING_SNAKE_CASE      :					int    =				Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]		)
				SCREAMING_SNAKE_CASE      :					Tuple    =				Vector([1, -1, 1, -1, 2, -3, 4, -5]		)
				self.assertAlmostEqual(x.euclidean_length()					,					2.236					,					3		)
				self.assertAlmostEqual(y.euclidean_length()					,					7.416					,					3		)
				self.assertEqual(z.euclidean_length()					,					0		)
				self.assertAlmostEqual(w.euclidean_length()					,					7.616					,					3		)
			def 							__UpperCamelCase       (	self							:       List[str]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Vector([1, 2, 3]		)
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				Vector([1, 1, 1]		)
				self.assertEqual((x + y).component(0		)					,					2		)
				self.assertEqual((x + y).component(1		)					,					3		)
				self.assertEqual((x + y).component(2		)					,					4		)
			def 							__UpperCamelCase       (	self							:       Tuple		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Tuple    =				Vector([1, 2, 3]		)
				SCREAMING_SNAKE_CASE      :					Dict    =				Vector([1, 1, 1]		)
				self.assertEqual((x - y).component(0		)					,					0		)
				self.assertEqual((x - y).component(1		)					,					1		)
				self.assertEqual((x - y).component(2		)					,					2		)
			def 							__UpperCamelCase       (	self							:       Any		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					str    =				Vector([1, 2, 3]		)
				SCREAMING_SNAKE_CASE      :					str    =				Vector([2, -1, 4]		)  # for test of dot product
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				Vector([1, -2, -1]		)
				self.assertEqual(str(x * 3.0		)					,					"(3.0,6.0,9.0)"		)
				self.assertEqual((a * b)					,					0		)
			def 							__UpperCamelCase       (	self							:       List[str]		)							->				None:

				"""simple docstring"""

				self.assertEqual(str(zero_vector(10		)		).count("0"		)					,					10		)
			def 							__UpperCamelCase       (	self							:       Any		)							->				None:

				"""simple docstring"""

				self.assertEqual(str(unit_basis_vector(3					,					1		)		)					,					"(0,1,0)"		)
			def 							__UpperCamelCase       (	self							:       Union[str, Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Dict    =				Vector([1, 2, 3]		)
				SCREAMING_SNAKE_CASE      :					Tuple    =				Vector([1, 0, 1]		)
				self.assertEqual(str(axpy(2					,					__UpperCAmelCase					,					__UpperCAmelCase		)		)					,					"(3,4,7)"		)
			def 							__UpperCamelCase       (	self							:       Optional[Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Vector([1, 0, 0, 0, 0, 0]		)
				SCREAMING_SNAKE_CASE      :					Tuple    =				x.copy()
				self.assertEqual(str(__UpperCAmelCase		)					,					str(__UpperCAmelCase		)		)
			def 							__UpperCamelCase       (	self							:       Tuple		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					int    =				Vector([1, 0, 0]		)
				x.change_component(0					,					0		)
				x.change_component(1					,					1		)
				self.assertEqual(str(__UpperCAmelCase		)					,					"(0,1,0)"		)
			def 							__UpperCamelCase       (	self							:       Dict		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					int    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"					,					str(__UpperCAmelCase		)		)
			def 							__UpperCamelCase       (	self							:       List[Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				SCREAMING_SNAKE_CASE      :					Any    =				[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
				for x in range(a.height()		):
					for y in range(a.width()		):
						self.assertEqual(minors[x][y]					,					a.minor(__UpperCAmelCase					,					__UpperCAmelCase		)		)
			def 							__UpperCamelCase       (	self							:       Dict		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					int    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				SCREAMING_SNAKE_CASE      :					List[str]    =				[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
				for x in range(a.height()		):
					for y in range(a.width()		):
						self.assertEqual(cofactors[x][y]					,					a.cofactor(__UpperCAmelCase					,					__UpperCAmelCase		)		)
			def 							__UpperCamelCase       (	self							:       Union[str, Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					str    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				self.assertEqual(-5					,					a.determinant()		)
			def 							__UpperCamelCase       (	self							:       Tuple		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[str]    =				Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]					,					3					,					3		)
				SCREAMING_SNAKE_CASE      :					int    =				Vector([1, 2, 3]		)
				self.assertEqual("(14,32,50)"					,					str(a * x		)		)
				self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"					,					str(a * 2		)		)
			def 							__UpperCamelCase       (	self							:       str		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				a.change_component(0					,					2					,					5		)
				self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"					,					str(__UpperCAmelCase		)		)
			def 							__UpperCamelCase       (	self							:       Dict		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				self.assertEqual(7					,					a.component(2					,					1		)					,					0.01		)
			def 							__UpperCamelCase       (	self							:       List[Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				SCREAMING_SNAKE_CASE      :					Dict    =				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]					,					3					,					3		)
				self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"					,					str(a + b		)		)
			def 							__UpperCamelCase       (	self							:       Union[str, Any]		)							->				None:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,					3					,					3		)
				SCREAMING_SNAKE_CASE      :					Any    =				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]					,					3					,					3		)
				self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"					,					str(a - b		)		)






			def 							__UpperCamelCase       (	self							:       int		)							->				None:

				"""simple docstring"""

				self.assertEqual(
				    "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"					,					str(square_zero_matrix(5		)		)					,					)


if __name__ == "__main__":
			unittest.main()
"""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   )    -> Tuple:
													super().__init__(*__UpperCAmelCase						,**__UpperCAmelCase   )
													requires_backends(self						,'decord'   )
													self.check_model_type(__UpperCAmelCase   )





						def  snake_case__		(				self						,__UpperCAmelCase=None						,__UpperCAmelCase=None						,__UpperCAmelCase=None   )    -> int:
													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   )    -> Dict:
													return super().__call__(__UpperCAmelCase						,**__UpperCAmelCase   )





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase=None						,__UpperCAmelCase=1   )    -> Union[str, 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   )    -> Dict:
													A__		   =							self.model(**__UpperCAmelCase   )
													return model_outputs





						def  snake_case__		(				self						,__UpperCAmelCase						,__UpperCAmelCase=5   )    -> Union[str, Any]:
													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   )]





