






'''simple docstring'''







from __future__ import annotations





class 						SCREAMING_SNAKE_CASE       :






			def __init__(			self   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      list[list[int]]       )      ->      Union[str, Any]:
							a_		:	List[str]									=   TypeError(
							    '''Matrices must be formed from a list of zero or more lists containing at '''
							    '''least one and the same number of values, each of which must be of type '''
							    '''int or float.'''       )
							if len(__SCREAMING_SNAKE_CASE       ) != 0:
											a_		:	int									=   len(rows[0]       )
											if cols == 0:
															raise error
											for row in rows:
															if len(__SCREAMING_SNAKE_CASE       ) != cols:
																			raise error
															for value in row:
																			if not isinstance(__SCREAMING_SNAKE_CASE	,    (int, float)       ):
																							raise error
											a_		:	Dict									=   rows
							else:
											a_		:	Union[str, Any]									=   []






			def       SCREAMING_SNAKE_CASE   (			self   :      Any       )      ->      list[list[int]]:
							return [[row[i] for row in self.rows] for i in range(len(self.rows[0]       )       )]






			@property
			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[Any]       )      ->      int:
							return len(self.rows       )






			@property
			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      int:
							return len(self.rows[0]       )






			@property
			def       SCREAMING_SNAKE_CASE   (			self   :      Any       )      ->      tuple[int, int]:
							return (self.num_rows, self.num_columns)






			@property
			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      bool:
							return self.order[0] == self.order[1]






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      Matrix:
							a_		:	Tuple									=   [
							    [0 if column_num != row_num else 1 for column_num in range(self.num_rows       )]
							    for row_num in range(self.num_rows       )
							]
							return Matrix(__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]       )      ->      int:
							if not self.is_square:
											return 0
							if self.order == (0, 0):
											return 1
							if self.order == (1, 1):
											return int(self.rows[0][0]       )
							if self.order == (2, 2):
											return int(
											    (self.rows[0][0] * self.rows[1][1])
											    - (self.rows[0][1] * self.rows[1][0])       )
							else:
											return sum(
											    self.rows[0][column] * self.cofactors().rows[0][column]
											    for column in range(self.num_columns       )       )






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      bool:
							return bool(self.determinant()       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      int:
							a_		:	Any									=   [
							    [
							        self.rows[other_row][other_column]
							        for other_column in range(self.num_columns       )
							        if other_column != column
							    ]
							    for other_row in range(self.num_rows       )
							    if other_row != row
							]
							return Matrix(__SCREAMING_SNAKE_CASE       ).determinant()






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      int:
							if (row + column) % 2 == 0:
											return self.get_minor(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       )
							return -1 * self.get_minor(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      Matrix:
							return Matrix(
							    [
							        [self.get_minor(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ) for column in range(self.num_columns       )]
							        for row in range(self.num_rows       )
							    ]       )






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      Matrix:
							return Matrix(
							    [
							        [
							            self.minors().rows[row][column]
							            if (row + column) % 2 == 0
							            else self.minors().rows[row][column] * -1
							            for column in range(self.minors().num_columns       )
							        ]
							        for row in range(self.minors().num_rows       )
							    ]       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      Matrix:
							a_		:	Tuple									=   [
							    [self.cofactors().rows[column][row] for column in range(self.num_columns       )]
							    for row in range(self.num_rows       )
							]
							return Matrix(__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      Matrix:
							a_		:	Any									=   self.determinant()
							if not determinant:
											raise TypeError('''Only matrices with a non-zero determinant have an inverse'''       )
							return self.adjugate() * (1 / determinant)






			def __repr__(			self   :      Optional[Any]       )      ->      str:
							return str(self.rows       )






			def __str__(			self   :      Union[str, Any]       )      ->      str:
							if self.num_rows == 0:
											return "[]"
							if self.num_rows == 1:
											return "[[" + ". ".join(str(self.rows[0]       )       ) + "]]"
							return (
							    "["
							    + "\n ".join(
							        [
							            '''[''' + '''. '''.join([str(__SCREAMING_SNAKE_CASE       ) for value in row]       ) + '''.]'''
							            for row in self.rows
							        ]       )
							    + "]"
							)






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      list[int]	,    __SCREAMING_SNAKE_CASE   :      int | None = None       )      ->      None:
							a_		:	Dict									=   TypeError('''Row must be a list containing all ints and/or floats'''       )
							if not isinstance(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
											raise type_error
							for value in row:
											if not isinstance(__SCREAMING_SNAKE_CASE	,    (int, float)       ):
															raise type_error
							if len(__SCREAMING_SNAKE_CASE       ) != self.num_columns:
											raise ValueError(
											    '''Row must be equal in length to the other rows in the matrix'''       )
							if position is None:
											self.rows.append(__SCREAMING_SNAKE_CASE       )
							else:
											a_		:	Optional[int]									=   self.rows[0:position] + [row] + self.rows[position:]






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      list[int]	,    __SCREAMING_SNAKE_CASE   :      int | None = None       )      ->      None:
							a_		:	Optional[Any]									=   TypeError(
							    '''Column must be a list containing all ints and/or floats'''       )
							if not isinstance(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
											raise type_error
							for value in column:
											if not isinstance(__SCREAMING_SNAKE_CASE	,    (int, float)       ):
															raise type_error
							if len(__SCREAMING_SNAKE_CASE       ) != self.num_rows:
											raise ValueError(
											    '''Column must be equal in length to the other columns in the matrix'''       )
							if position is None:
											a_		:	int									=   [self.rows[i] + [column[i]] for i in range(self.num_rows       )]
							else:
											a_		:	Optional[Any]									=   [
											    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
											    for i in range(self.num_rows       )
											]






			def __eq__(			self   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      object       )      ->      bool:
							if not isinstance(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
											return NotImplemented
							return self.rows == other.rows






			def __ne__(			self   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      object       )      ->      bool:
							return not self == other






			def __neg__(			self   :      Tuple       )      ->      Matrix:
							return self * -1






			def __add__(			self   :      int	,    __SCREAMING_SNAKE_CASE   :      Matrix       )      ->      Matrix:
							if self.order != other.order:
											raise ValueError('''Addition requires matrices of the same order'''       )
							return Matrix(
							    [
							        [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns       )]
							        for i in range(self.num_rows       )
							    ]       )






			def __sub__(			self   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      Matrix       )      ->      Matrix:
							if self.order != other.order:
											raise ValueError('''Subtraction requires matrices of the same order'''       )
							return Matrix(
							    [
							        [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns       )]
							        for i in range(self.num_rows       )
							    ]       )






			def __mul__(			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Matrix | int | float       )      ->      Matrix:
							if isinstance(__SCREAMING_SNAKE_CASE	,    (int, float)       ):
											return Matrix(
											    [[int(element * other       ) for element in row] for row in self.rows]       )
							elif isinstance(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
											if self.num_columns != other.num_rows:
															raise ValueError(
															    '''The number of columns in the first matrix must '''
															    '''be equal to the number of rows in the second'''       )
											return Matrix(
											    [
											        [Matrix.dot_product(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ) for column in other.columns()]
											        for row in self.rows
											    ]       )
							else:
											raise TypeError(
											    '''A Matrix can only be multiplied by an int, float, or another matrix'''       )






			def __pow__(			self   :      int	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      Matrix:
							if not isinstance(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       ):
											raise TypeError('''A Matrix can only be raised to the power of an int'''       )
							if not self.is_square:
											raise ValueError('''Only square matrices can be raised to a power'''       )
							if other == 0:
											return self.identity()
							if other < 0:
											if self.is_invertable():
															return self.inverse() ** (-other)
											raise ValueError(
											    '''Only invertable matrices can be raised to a negative power'''       )
							a_		:	Optional[Any]									=   self
							for _ in range(other - 1       ):
											result *= self
							return result







			@classmethod
			def       SCREAMING_SNAKE_CASE   (			cls   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      list[int]	,    __SCREAMING_SNAKE_CASE   :      list[int]       )      ->      int:
							return sum(row[i] * column[i] for i in range(len(__SCREAMING_SNAKE_CASE       )       )       )


if __name__ == "__main__":
		import doctest

		doctest.testmod()












'''simple docstring'''







# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.whisper import WhisperForConditionalGeneration, WhisperProcessor
from .base import PipelineTool





class 						SCREAMING_SNAKE_CASE       (       SCREAMING_SNAKE_CASE_							):
			snake_case__	=					"openai/whisper-base"
			snake_case__	=					(
			    "This is a tool that transcribes an audio into text. It takes an input named `audio` and returns the "
			    "transcribed text."
			)
			snake_case__	=					"transcriber"
			snake_case__	=					WhisperProcessor
			snake_case__	=					WhisperForConditionalGeneration

			snake_case__	=					["audio"]
			snake_case__	=					["text"]






			def       SCREAMING_SNAKE_CASE   (			self   :      str	,    __SCREAMING_SNAKE_CASE   :      Tuple       )      ->      str:
							return self.pre_processor(__SCREAMING_SNAKE_CASE	,    return_tensors='''pt'''       ).input_features






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]       )      ->      List[str]:
							return self.model.generate(inputs=__SCREAMING_SNAKE_CASE       )







			def       SCREAMING_SNAKE_CASE   (			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Optional[int]       )      ->      Optional[Any]:
							return self.pre_processor.batch_decode(__SCREAMING_SNAKE_CASE	,    skip_special_tokens=__SCREAMING_SNAKE_CASE       )[0]




