
"""simple docstring"""

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      _UpperCAmelCase							(		unittest.TestCase							):




      def     a_      (							self							)						->					int:
          UpperCAmelCase									=					{
              'task_specific_params': {
                  'summarization': {'length_penalty': 1.0, 'max_length': 1_2_8, 'min_length': 1_2, 'num_beams': 4},
                  'summarization_cnn': {'length_penalty': 2.0, 'max_length': 1_4_2, 'min_length': 5_6, 'num_beams': 4},
                  'summarization_xsum': {'length_penalty': 1.0, 'max_length': 6_2, 'min_length': 1_1, 'num_beams': 6},
              }
          }
          UpperCAmelCase									=					{
              'task_specific_params.summarization.length_penalty': 1.0,
              'task_specific_params.summarization.max_length': 1_2_8,
              'task_specific_params.summarization.min_length': 1_2,
              'task_specific_params.summarization.num_beams': 4,
              'task_specific_params.summarization_cnn.length_penalty': 2.0,
              'task_specific_params.summarization_cnn.max_length': 1_4_2,
              'task_specific_params.summarization_cnn.min_length': 5_6,
              'task_specific_params.summarization_cnn.num_beams': 4,
              'task_specific_params.summarization_xsum.length_penalty': 1.0,
              'task_specific_params.summarization_xsum.max_length': 6_2,
              'task_specific_params.summarization_xsum.min_length': 1_1,
              'task_specific_params.summarization_xsum.num_beams': 6,
          }

          self.assertEqual(flatten_dict(lowercase_							)   ,       lowercase_							)




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          self.assertTrue(np.allclose(transpose(lowercase_							)   ,       x.transpose()							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          self.assertTrue(np.allclose(transpose(lowercase_   ,       axes=(1, 2, 0)							)   ,       x.transpose((1, 2, 0)							)							)							)




      @require_torch
      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_							)   ,       transpose(lowercase_							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_   ,       axes=(1, 2, 0)							)   ,       transpose(lowercase_   ,       axes=(1, 2, 0)							).numpy()							)							)




      @require_tf
      def     a_      (							self							)						->					str:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_							)   ,       transpose(lowercase_							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_   ,       axes=(1, 2, 0)							)   ,       transpose(lowercase_   ,       axes=(1, 2, 0)							).numpy()							)							)




      @require_flax
      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_							)   ,       np.asarray(transpose(lowercase_							)							)							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(transpose(lowercase_   ,       axes=(1, 2, 0)							)   ,       np.asarray(transpose(lowercase_   ,       axes=(1, 2, 0)							)							)							)							)




      def     a_      (							self							)						->					Optional[int]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (4, 3)							)   ,       np.reshape(lowercase_   ,       (4, 3)							)							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (1_2, 5)							)   ,       np.reshape(lowercase_   ,       (1_2, 5)							)							)							)




      @require_torch
      def     a_      (							self							)						->					int:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (4, 3)							)   ,       reshape(lowercase_   ,       (4, 3)							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (1_2, 5)							)   ,       reshape(lowercase_   ,       (1_2, 5)							).numpy()							)							)




      @require_tf
      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (4, 3)							)   ,       reshape(lowercase_   ,       (4, 3)							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (1_2, 5)							)   ,       reshape(lowercase_   ,       (1_2, 5)							).numpy()							)							)




      @require_flax
      def     a_      (							self							)						->					int:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (4, 3)							)   ,       np.asarray(reshape(lowercase_   ,       (4, 3)							)							)							)							)

          UpperCAmelCase									=					np.random.randn(3   ,       4   ,       5							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(reshape(lowercase_   ,       (1_2, 5)							)   ,       np.asarray(reshape(lowercase_   ,       (1_2, 5)							)							)							)							)




      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					np.random.randn(1   ,       3   ,       4							)
          self.assertTrue(np.allclose(squeeze(lowercase_							)   ,       np.squeeze(lowercase_							)							)							)

          UpperCAmelCase									=					np.random.randn(1   ,       4   ,       1   ,       5							)
          self.assertTrue(np.allclose(squeeze(lowercase_   ,       axis=2							)   ,       np.squeeze(lowercase_   ,       axis=2							)							)							)




      @require_torch
      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					np.random.randn(1   ,       3   ,       4							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_							)   ,       squeeze(lowercase_							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(1   ,       4   ,       1   ,       5							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_   ,       axis=2							)   ,       squeeze(lowercase_   ,       axis=2							).numpy()							)							)




      @require_tf
      def     a_      (							self							)						->					str:
          UpperCAmelCase									=					np.random.randn(1   ,       3   ,       4							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_							)   ,       squeeze(lowercase_							).numpy()							)							)

          UpperCAmelCase									=					np.random.randn(1   ,       4   ,       1   ,       5							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_   ,       axis=2							)   ,       squeeze(lowercase_   ,       axis=2							).numpy()							)							)




      @require_flax
      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					np.random.randn(1   ,       3   ,       4							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_							)   ,       np.asarray(squeeze(lowercase_							)							)							)							)

          UpperCAmelCase									=					np.random.randn(1   ,       4   ,       1   ,       5							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(squeeze(lowercase_   ,       axis=2							)   ,       np.asarray(squeeze(lowercase_   ,       axis=2							)							)							)							)




      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          self.assertTrue(np.allclose(expand_dims(lowercase_   ,       axis=1							)   ,       np.expand_dims(lowercase_   ,       axis=1							)							)							)




      @require_torch
      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					torch.tensor(lowercase_							)
          self.assertTrue(np.allclose(expand_dims(lowercase_   ,       axis=1							)   ,       expand_dims(lowercase_   ,       axis=1							).numpy()							)							)




      @require_tf
      def     a_      (							self							)						->					Optional[Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					tf.constant(lowercase_							)
          self.assertTrue(np.allclose(expand_dims(lowercase_   ,       axis=1							)   ,       expand_dims(lowercase_   ,       axis=1							).numpy()							)							)




      @require_flax
      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					np.random.randn(3   ,       4							)
          UpperCAmelCase									=					jnp.array(lowercase_							)
          self.assertTrue(np.allclose(expand_dims(lowercase_   ,       axis=1							)   ,       np.asarray(expand_dims(lowercase_   ,       axis=1							)							)							)							)





"""simple docstring"""

import sys
import turtle




def     lowercase__						(					lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ) ->      tuple[float, float]:






    """simple docstring"""




    return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2




def     lowercase__						(					lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					tuple[float, float] ,				lowerCAmelCase				:					int ,				) ->      None:






    """simple docstring"""




    my_pen.up()
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.down()
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.goto(vertexa[0] ,				vertexa[1] )
    my_pen.goto(vertexa[0] ,				vertexa[1] )

    if depth == 0:
        return

    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )
    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )
    triangle(lowerCAmelCase ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				get_mid(lowerCAmelCase ,				lowerCAmelCase ) ,				depth - 1 )


if __name__ == "__main__":
   if len(sys.argv) != 2:
      raise ValueError(
          '''Correct format for using this script: '''
          '''python fractals.py <int:depth_for_fractal>'''
      )
   SCREAMING_SNAKE_CASE_    					=						turtle.Turtle()
   my_pen.ht()
   my_pen.speed(5)
   my_pen.pencolor('''red''')

   SCREAMING_SNAKE_CASE_    					=						[(-175, -125), (0, 175), (175, -125)]  # vertices of triangle
   triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))



