

"""simple docstring"""





import unittest

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







class 							SCREAMING_SNAKE_CASE   (						unittest.TestCase			):






					"""simple docstring"""



					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Vector([1, 2, 3]						)
						self.assertEqual(x.component(0						)  ,1						)
						self.assertEqual(x.component(2						)  ,3						)
						lowerCAmelCase__      :		int    							=      Vector()







					def 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Vector([0, 0, 0, 0, 0, 1]						)
						self.assertEqual(str(lowercase_						)  ,'''(0,0,0,0,0,1)'''						)







					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						lowerCAmelCase__      :		Dict    							=      Vector([1, 2, 3, 4]						)
						self.assertEqual(len(lowercase_						)  ,4						)







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						lowerCAmelCase__      :		Optional[Any]    							=      Vector([1, 2]						)
						lowerCAmelCase__      :		Any    							=      Vector([1, 2, 3, 4, 5]						)
						lowerCAmelCase__      :		int    							=      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]						)
						lowerCAmelCase__      :		Any    							=      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 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		List[Any]    							=      Vector([1, 2, 3]						)
						lowerCAmelCase__      :		Any    							=      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 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		Tuple    							=      Vector([1, 2, 3]						)
						lowerCAmelCase__      :		Tuple    							=      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 			__lowerCAmelCase					(			self     :							int						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Vector([1, 2, 3]						)
						lowerCAmelCase__      :		List[str]    							=      Vector([2, -1, 4]						)  # for test of dot product
						lowerCAmelCase__      :		Tuple    							=      Vector([1, -2, -1]						)
						self.assertEqual(str(x * 3.0						)  ,'''(3.0,6.0,9.0)'''						)
						self.assertEqual((a * b)  ,0						)







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						self.assertEqual(str(zero_vector(1_0						)						).count('''0'''						)  ,1_0						)







					def 			__lowerCAmelCase					(			self     :							int						):
						self.assertEqual(str(unit_basis_vector(3  ,1						)						)  ,'''(0,1,0)'''						)







					def 			__lowerCAmelCase					(			self     :							Any						):
						lowerCAmelCase__      :		Tuple    							=      Vector([1, 2, 3]						)
						lowerCAmelCase__      :		Optional[Any]    							=      Vector([1, 0, 1]						)
						self.assertEqual(str(axpy(2  ,lowercase_  ,lowercase_						)						)  ,'''(3,4,7)'''						)







					def 			__lowerCAmelCase					(			self     :							str						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Vector([1, 0, 0, 0, 0, 0]						)
						lowerCAmelCase__      :		Any    							=      x.copy()
						self.assertEqual(str(lowercase_						)  ,str(lowercase_						)						)







					def 			__lowerCAmelCase					(			self     :							Optional[int]						):
						lowerCAmelCase__      :		Tuple    							=      Vector([1, 0, 0]						)
						x.change_component(0  ,0						)
						x.change_component(1  ,1						)
						self.assertEqual(str(lowercase_						)  ,'''(0,1,0)'''						)







					def 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		Optional[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(lowercase_						)						)







					def 			__lowerCAmelCase					(			self     :							Tuple						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						lowerCAmelCase__      :		str    							=      [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
						for x in range(a.height()						):
							for y in range(a.width()						):
								self.assertEqual(minors[x][y]  ,a.minor(lowercase_  ,lowercase_						)						)







					def 			__lowerCAmelCase					(			self     :							List[Any]						):
						lowerCAmelCase__      :		Union[str, Any]    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						lowerCAmelCase__      :		Tuple    							=      [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
						for x in range(a.height()						):
							for y in range(a.width()						):
								self.assertEqual(cofactors[x][y]  ,a.cofactor(lowercase_  ,lowercase_						)						)







					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						lowerCAmelCase__      :		List[Any]    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						self.assertEqual(-5  ,a.determinant()						)







					def 			__lowerCAmelCase					(			self     :							Optional[int]						):
						lowerCAmelCase__      :		Optional[int]    							=      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]  ,3  ,3						)
						lowerCAmelCase__      :		List[Any]    							=      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 			__lowerCAmelCase					(			self     :							Optional[int]						):
						lowerCAmelCase__      :		int    							=      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(lowercase_						)						)







					def 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		Any    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						self.assertEqual(7  ,a.component(2  ,1						)  ,0.01						)







					def 			__lowerCAmelCase					(			self     :							Dict						):
						lowerCAmelCase__      :		int    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						lowerCAmelCase__      :		Any    							=      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]  ,3  ,3						)
						self.assertEqual('''|2,4,10|\n|4,8,10|\n|12,14,18|\n'''  ,str(a + b						)						)







					def 			__lowerCAmelCase					(			self     :							List[str]						):
						lowerCAmelCase__      :		Optional[int]    							=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,3  ,3						)
						lowerCAmelCase__      :		str    							=      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]  ,3  ,3						)
						self.assertEqual('''|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'''  ,str(a - b						)						)







					def 			__lowerCAmelCase					(			self     :							str						):
						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"""





# 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 typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
							from PIL import Image







class 							SCREAMING_SNAKE_CASE   (						a_			):






					"""simple docstring"""



					lowercase__												=			"Salesforce/blip-image-captioning-base"
					lowercase__												=			(
					    "This is a tool that generates a description of an image. It takes an input named `image` which should be the "
					    "image to caption, and returns a text that contains the description in English."
					)
					lowercase__												=			"image_captioner"
					lowercase__												=			AutoModelForVisionaSeq

					lowercase__												=			["image"]
					lowercase__												=			["text"]







					def __init__(			self     :							int  ,*lowercase_     :							int  ,**lowercase_     :							List[str]						):
						requires_backends(self  ,['''vision''']						)
						super().__init__(*lowercase_  ,**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							List[str]  ,lowercase_     :							"Image"						):
						return self.pre_processor(images=lowercase_  ,return_tensors='''pt'''						)







					def 			__lowerCAmelCase					(			self     :							List[Any]  ,lowercase_     :							Any						):
						return self.model.generate(**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Dict  ,lowercase_     :							Union[str, Any]						):
						return self.pre_processor.batch_decode(lowercase_  ,skip_special_tokens=lowercase_						)[0].strip()




