


import sys
import turtle


def     _SCREAMING_SNAKE_CASE      (					SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE			):
  return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2


def     _SCREAMING_SNAKE_CASE      (					SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     SCREAMING_SNAKE_CASE					,     ):
  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>"""
          )
     UpperCamelCase														=      turtle.Turtle()
     my_pen.ht()
     my_pen.speed(5)
     my_pen.pencolor("""red""")

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












from typing import Dict

from .base import GenericTensor, Pipeline
class  _UpperCAmelCase   (			A__      ):

				"""simple docstring"""




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Tuple=None,    lowerCamelCase		:       Union[str, Any]=None,    lowerCamelCase		:       Union[str, Any]=None,    **lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								if tokenize_kwargs is None:
												lowercase__  					=     {}

								if truncation is not None:
												if "truncation" in tokenize_kwargs:
																raise ValueError(
																    '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'''    )
												lowercase__  					=     truncation

								lowercase__  					=     tokenize_kwargs

								lowercase__  					=     {}
								if return_tensors is not None:
												lowercase__  					=     return_tensors

								return preprocess_params, {}, postprocess_params




				def 							lowercase__  (	self		:       Tuple,    lowerCamelCase		:       Optional[int],    **lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     self.framework
								lowercase__  					=     self.tokenizer(lowerCamelCase,    return_tensors=lowerCamelCase,    **lowerCamelCase    )
								return model_inputs




				def 							lowercase__  (	self		:       Union[str, Any],    lowerCamelCase		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     self.model(**lowerCamelCase    )
								return model_outputs




				def 							lowercase__  (	self		:       Union[str, Any],    lowerCamelCase		:       Dict,    lowerCamelCase		:       Tuple=False    ):

								'''simple docstring'''
								# [0] is the first available tensor, logits or last_hidden_state.
								if return_tensors:
												return model_outputs[0]
								if self.framework == "pt":
												return model_outputs[0].tolist()
								elif self.framework == "tf":
												return model_outputs[0].numpy().tolist()




				def __call__(	self		:       List[str],    *lowerCamelCase		:       List[Any],    **lowerCamelCase		:       str    ):

								'''simple docstring'''
								return super().__call__(*lowerCamelCase,    **lowerCamelCase    )




