




"""simple docstring"""


import unittest
from queue import Empty
from threading import Thread

from transformers import AutoTokenizer, TextIteratorStreamer, TextStreamer, is_torch_available
from transformers.testing_utils import CaptureStdout, require_torch, torch_device

from ..test_modeling_common import ids_tensor


if is_torch_available():
  import torch

  from transformers import AutoModelForCausalLM


@require_torch
class _lowerCamelCase    (					unittest.TestCase						):






   def 	_lowerCAmelCase   (		self   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   )
         lowerCAmelCase__      :			List[Any]   =	AutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   ).to(_a   )
         lowerCAmelCase__      :			Tuple   =	-1

         lowerCAmelCase__      :			Any   =	ids_tensor((1, 5)   ,     vocab_size=model.config.vocab_size   ).to(_a   )
         lowerCAmelCase__      :			Tuple   =	model.generate(_a   ,     max_new_tokens=10   ,     do_sample=_a   )
         lowerCAmelCase__      :			str   =	tokenizer.decode(greedy_ids[0]   )

         with CaptureStdout() as cs:
               lowerCAmelCase__      :			Any   =	TextStreamer(_a   )
               model.generate(_a   ,     max_new_tokens=10   ,     do_sample=_a   ,     streamer=_a   )
         # The greedy text should be printed to stdout, except for the final "\n" in the streamer
         lowerCAmelCase__      :			List[Any]   =	cs.out[:-1]

         self.assertEqual(_a   ,     _a   )






   def 	_lowerCAmelCase   (		self   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   )
         lowerCAmelCase__      :			Any   =	AutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   ).to(_a   )
         lowerCAmelCase__      :			Optional[int]   =	-1

         lowerCAmelCase__      :			Union[str, Any]   =	ids_tensor((1, 5)   ,     vocab_size=model.config.vocab_size   ).to(_a   )
         lowerCAmelCase__      :			Optional[int]   =	model.generate(_a   ,     max_new_tokens=10   ,     do_sample=_a   )
         lowerCAmelCase__      :			Optional[int]   =	tokenizer.decode(greedy_ids[0]   )

         lowerCAmelCase__      :			List[str]   =	TextIteratorStreamer(_a   )
         lowerCAmelCase__      :			str   =	{"""input_ids""": input_ids, """max_new_tokens""": 10, """do_sample""": False, """streamer""": streamer}
         lowerCAmelCase__      :			Any   =	Thread(target=model.generate   ,     kwargs=_a   )
         thread.start()
         lowerCAmelCase__      :			Union[str, Any]   =	""""""
         for new_text in streamer:
               streamer_text += new_text

         self.assertEqual(_a   ,     _a   )






   def 	_lowerCAmelCase   (		self   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   )
         lowerCAmelCase__      :			int   =	AutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   ).to(_a   )
         lowerCAmelCase__      :			Union[str, Any]   =	-1

         lowerCAmelCase__      :			List[Any]   =	ids_tensor((1, 5)   ,     vocab_size=model.config.vocab_size   ).to(_a   )
         lowerCAmelCase__      :			Union[str, Any]   =	model.generate(_a   ,     max_new_tokens=10   ,     do_sample=_a   )
         lowerCAmelCase__      :			List[str]   =	greedy_ids[:, input_ids.shape[1] :]
         lowerCAmelCase__      :			Dict   =	tokenizer.decode(new_greedy_ids[0]   )

         with CaptureStdout() as cs:
               lowerCAmelCase__      :			int   =	TextStreamer(_a   ,     skip_prompt=_a   )
               model.generate(_a   ,     max_new_tokens=10   ,     do_sample=_a   ,     streamer=_a   )
         # The greedy text should be printed to stdout, except for the final "\n" in the streamer
         lowerCAmelCase__      :			str   =	cs.out[:-1]

         self.assertEqual(_a   ,     _a   )






   def 	_lowerCAmelCase   (		self   )			->						Optional[int]:

         """simple docstring"""
         # Tests that we can pass `decode_kwargs` to the streamer to control how the tokens are decoded. Must be tested
         # with actual models -- the dummy models' tokenizers are not aligned with their models, and
         # `skip_special_tokens=True` has no effect on them
         lowerCAmelCase__      :			str   =	AutoTokenizer.from_pretrained("""distilgpt2"""   )
         lowerCAmelCase__      :			Any   =	AutoModelForCausalLM.from_pretrained("""distilgpt2"""   ).to(_a   )
         lowerCAmelCase__      :			Optional[Any]   =	-1

         lowerCAmelCase__      :			str   =	torch.ones((1, 5)   ,     device=_a   ).long() * model.config.bos_token_id
         with CaptureStdout() as cs:
               lowerCAmelCase__      :			Union[str, Any]   =	TextStreamer(_a   ,     skip_special_tokens=_a   )
               model.generate(_a   ,     max_new_tokens=1   ,     do_sample=_a   ,     streamer=_a   )

         # The prompt contains a special token, so the streamer should not print it. As such, the output text, when
         # re-tokenized, must only contain one token
         lowerCAmelCase__      :			Tuple   =	cs.out[:-1]  # Remove the final "\n"
         lowerCAmelCase__      :			Union[str, Any]   =	tokenizer(_a   ,     return_tensors="""pt"""   )
         self.assertEqual(streamer_text_tokenized.input_ids.shape   ,     (1, 1)   )






   def 	_lowerCAmelCase   (		self   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   )
         lowerCAmelCase__      :			Dict   =	AutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""   ).to(_a   )
         lowerCAmelCase__      :			Tuple   =	-1

         lowerCAmelCase__      :			Union[str, Any]   =	ids_tensor((1, 5)   ,     vocab_size=model.config.vocab_size   ).to(_a   )
         lowerCAmelCase__      :			Union[str, Any]   =	TextIteratorStreamer(_a   ,     timeout=0.001   )
         lowerCAmelCase__      :			Dict   =	{"""input_ids""": input_ids, """max_new_tokens""": 10, """do_sample""": False, """streamer""": streamer}
         lowerCAmelCase__      :			List[str]   =	Thread(target=model.generate   ,     kwargs=_a   )
         thread.start()

         # The streamer will timeout after 0.001 seconds, so an exception will be raised
         with self.assertRaises(_a   ):
               lowerCAmelCase__      :			int   =	""""""
               for new_text in streamer:
                     streamer_text += new_text











"""simple docstring"""


import unittest

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


class _lowerCamelCase    (					unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		Dict   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Vector([1, 2, 3]   )
         self.assertEqual(x.component(0   )   ,     1   )
         self.assertEqual(x.component(2   )   ,     3   )
         lowerCAmelCase__      :			Union[str, Any]   =	Vector()






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	Vector([0, 0, 0, 0, 0, 1]   )
         self.assertEqual(str(UpperCamelCase   )   ,     """(0,0,0,0,0,1)"""   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			List[Any]   =	Vector([1, 2, 3, 4]   )
         self.assertEqual(len(UpperCamelCase   )   ,     4   )






   def 	_lowerCAmelCase   (		self       :		List[str]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	Vector([1, 2]   )
         lowerCAmelCase__      :			Optional[int]   =	Vector([1, 2, 3, 4, 5]   )
         lowerCAmelCase__      :			Union[str, Any]   =	Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]   )
         lowerCAmelCase__      :			List[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       :		Any   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	Vector([1, 2, 3]   )
         lowerCAmelCase__      :			Optional[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       :		Optional[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	Vector([1, 2, 3]   )
         lowerCAmelCase__      :			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 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	Vector([1, 2, 3]   )
         lowerCAmelCase__      :			Any   =	Vector([2, -1, 4]   )  # for test of dot product
         lowerCAmelCase__      :			Any   =	Vector([1, -2, -1]   )
         self.assertEqual(str(x * 3.0   )   ,     """(3.0,6.0,9.0)"""   )
         self.assertEqual((a * b)   ,     0   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						None:

         """simple docstring"""
         self.assertEqual(str(zero_vector(10   )   ).count("""0"""   )   ,     10   )






   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						None:

         """simple docstring"""
         self.assertEqual(str(unit_basis_vector(3   ,     1   )   )   ,     """(0,1,0)"""   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Vector([1, 2, 3]   )
         lowerCAmelCase__      :			Optional[Any]   =	Vector([1, 0, 1]   )
         self.assertEqual(str(axpy(2   ,     UpperCamelCase   ,     UpperCamelCase   )   )   ,     """(3,4,7)"""   )






   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Vector([1, 0, 0, 0, 0, 0]   )
         lowerCAmelCase__      :			Any   =	x.copy()
         self.assertEqual(str(UpperCamelCase   )   ,     str(UpperCamelCase   )   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Vector([1, 0, 0]   )
         x.change_component(0   ,     0   )
         x.change_component(1   ,     1   )
         self.assertEqual(str(UpperCamelCase   )   ,     """(0,1,0)"""   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						None:

         """simple docstring"""
         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(UpperCamelCase   )   )






   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         lowerCAmelCase__      :			Dict   =	[[-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 	_lowerCAmelCase   (		self       :		List[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         lowerCAmelCase__      :			int   =	[[-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 	_lowerCAmelCase   (		self       :		int   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         self.assertEqual(-5   ,     a.determinant()   )






   def 	_lowerCAmelCase   (		self       :		int   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]   ,     3   ,     3   )
         lowerCAmelCase__      :			Tuple   =	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       :		str   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	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 	_lowerCAmelCase   (		self       :		Tuple   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         self.assertEqual(7   ,     a.component(2   ,     1   )   ,     0.01   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         lowerCAmelCase__      :			List[Any]   =	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 	_lowerCAmelCase   (		self       :		List[Any]   )			->						None:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,     3   ,     3   )
         lowerCAmelCase__      :			Dict   =	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 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						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()





