
import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
				import jax.numpy as jnp

if is_tf_available():
				import tensorflow as tf

if is_torch_available():
				import torch




class 						lowercase__  (						unittest.TestCase  ):
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= {
						    'task_specific_params': {
						        'summarization': {'length_penalty': 1.0, 'max_length': 128, 'min_length': 12, 'num_beams': 4},
						        'summarization_cnn': {'length_penalty': 2.0, 'max_length': 142, 'min_length': 56, 'num_beams': 4},
						        'summarization_xsum': {'length_penalty': 1.0, 'max_length': 62, 'min_length': 11, 'num_beams': 6},
						    }
						}
						SCREAMING_SNAKE_CASE__													= {
						    'task_specific_params.summarization.length_penalty': 1.0,
						    'task_specific_params.summarization.max_length': 128,
						    'task_specific_params.summarization.min_length': 12,
						    'task_specific_params.summarization.num_beams': 4,
						    'task_specific_params.summarization_cnn.length_penalty': 2.0,
						    'task_specific_params.summarization_cnn.max_length': 142,
						    'task_specific_params.summarization_cnn.min_length': 56,
						    'task_specific_params.summarization_cnn.num_beams': 4,
						    'task_specific_params.summarization_xsum.length_penalty': 1.0,
						    'task_specific_params.summarization_xsum.max_length': 62,
						    'task_specific_params.summarization_xsum.min_length': 11,
						    'task_specific_params.summarization_xsum.num_beams': 6,
						}

						self.assertEqual(flatten_dict(UpperCAmelCase_							)       ,   UpperCAmelCase_							)
	def      A_				(			self							:   str							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_							)       ,   x.transpose()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							)       ,   x.transpose((1, 2, 0)							)							)							)
	@require_torch
	def      A_				(			self							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_							)       ,   transpose(UpperCAmelCase_							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							)       ,   transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							).numpy()							)							)
	@require_tf
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_							)       ,   transpose(UpperCAmelCase_							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							)       ,   transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							).numpy()							)							)
	@require_flax
	def      A_				(			self							:   Any							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_							)       ,   np.asarray(transpose(UpperCAmelCase_							)							)							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							)       ,   np.asarray(transpose(UpperCAmelCase_       ,   axes=(1, 2, 0)							)							)							)							)
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (4, 3)							)       ,   np.reshape(UpperCAmelCase_       ,   (4, 3)							)							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (12, 5)							)       ,   np.reshape(UpperCAmelCase_       ,   (12, 5)							)							)							)
	@require_torch
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (4, 3)							)       ,   reshape(UpperCAmelCase_       ,   (4, 3)							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (12, 5)							)       ,   reshape(UpperCAmelCase_       ,   (12, 5)							).numpy()							)							)
	@require_tf
	def      A_				(			self							:   List[Any]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (4, 3)							)       ,   reshape(UpperCAmelCase_       ,   (4, 3)							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (12, 5)							)       ,   reshape(UpperCAmelCase_       ,   (12, 5)							).numpy()							)							)
	@require_flax
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (4, 3)							)       ,   np.asarray(reshape(UpperCAmelCase_       ,   (4, 3)							)							)							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4       ,   5							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(reshape(UpperCAmelCase_       ,   (12, 5)							)       ,   np.asarray(reshape(UpperCAmelCase_       ,   (12, 5)							)							)							)							)
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   3       ,   4							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_							)       ,   np.squeeze(UpperCAmelCase_							)							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   4       ,   1       ,   5							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_       ,   axis=2							)       ,   np.squeeze(UpperCAmelCase_       ,   axis=2							)							)							)
	@require_torch
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   3       ,   4							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_							)       ,   squeeze(UpperCAmelCase_							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   4       ,   1       ,   5							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_       ,   axis=2							)       ,   squeeze(UpperCAmelCase_       ,   axis=2							).numpy()							)							)
	@require_tf
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   3       ,   4							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_							)       ,   squeeze(UpperCAmelCase_							).numpy()							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   4       ,   1       ,   5							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_       ,   axis=2							)       ,   squeeze(UpperCAmelCase_       ,   axis=2							).numpy()							)							)
	@require_flax
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   3       ,   4							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_							)       ,   np.asarray(squeeze(UpperCAmelCase_							)							)							)							)

						SCREAMING_SNAKE_CASE__													= np.random.randn(1       ,   4       ,   1       ,   5							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(squeeze(UpperCAmelCase_       ,   axis=2							)       ,   np.asarray(squeeze(UpperCAmelCase_       ,   axis=2							)							)							)							)
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_       ,   axis=1							)       ,   np.expand_dims(UpperCAmelCase_       ,   axis=1							)							)							)
	@require_torch
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= torch.tensor(UpperCAmelCase_							)
						self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_       ,   axis=1							)       ,   expand_dims(UpperCAmelCase_       ,   axis=1							).numpy()							)							)
	@require_tf
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= tf.constant(UpperCAmelCase_							)
						self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_       ,   axis=1							)       ,   expand_dims(UpperCAmelCase_       ,   axis=1							).numpy()							)							)





	@require_flax
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= np.random.randn(3       ,   4							)
						SCREAMING_SNAKE_CASE__													= jnp.array(UpperCAmelCase_							)
						self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_       ,   axis=1							)       ,   np.asarray(expand_dims(UpperCAmelCase_       ,   axis=1							)							)							)							)







def 							_lowercase							(     UpperCamelCase_	,	UpperCamelCase_		)		->		str:
					'''simple docstring'''


					if not isinstance(UpperCamelCase_	,	UpperCamelCase_		):
										raise ValueError('iterations must be defined as integers'		)
					if not isinstance(UpperCamelCase_	,	UpperCamelCase_		) or not number >= 1:
										raise ValueError(
										    'starting number must be\n                         and integer and be more than 0'		)
					if not iterations >= 1:
										raise ValueError('Iterations must be done more than 0 times to play FizzBuzz'		)

					SCREAMING_SNAKE_CASE__													= ''
					while number <= iterations:
										if number % 3 == 0:
															out += "Fizz"
										if number % 5 == 0:
															out += "Buzz"
										if 0 not in (number % 3, number % 5):
															out += str(UpperCamelCase_		)

										# print(out)
										number += 1
										out += " "
					return out


if __name__ == "__main__":
				import doctest

				doctest.testmod()





