





import json
import os
import pickle
import shutil
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
from datasets import Dataset

from transformers import is_faiss_available
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bart.tokenization_bart import BartTokenizer
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.dpr.tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer
from transformers.models.rag.configuration_rag import RagConfig
from transformers.models.rag.retrieval_rag import CustomHFIndex, RagRetriever
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_sentencepiece, require_tokenizers, require_torch


if is_faiss_available():
					import faiss


@require_faiss
class 					__a      (_snake_case     ):

							def     UpperCAmelCase__	(							self							:     List[str]   )					->       Union[str, Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      int     						=  tempfile.mkdtemp()
													UpperCAmelCase_			:      Dict     						=  8

													# DPR tok
													UpperCAmelCase_			:      str     						=  [
													    '''[UNK]''',
													    '''[CLS]''',
													    '''[SEP]''',
													    '''[PAD]''',
													    '''[MASK]''',
													    '''want''',
													    '''##want''',
													    '''##ed''',
													    '''wa''',
													    '''un''',
													    '''runn''',
													    '''##ing''',
													    ''',''',
													    '''low''',
													    '''lowest''',
													]
													UpperCAmelCase_			:      int     						=  os.path.join(self.tmpdirname       ,     '''dpr_tokenizer'''   )
													os.makedirs(__magic_name__       ,     exist_ok=__magic_name__   )
													UpperCAmelCase_			:      Any     						=  os.path.join(__magic_name__       ,     DPR_VOCAB_FILES_NAMES['''vocab_file''']   )
													with open(self.vocab_file       ,     '''w'''       ,     encoding='''utf-8'''   ) as vocab_writer:
																			vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]   )   )

													# BART tok
													UpperCAmelCase_			:      Optional[Any]     						=  [
													    '''l''',
													    '''o''',
													    '''w''',
													    '''e''',
													    '''r''',
													    '''s''',
													    '''t''',
													    '''i''',
													    '''d''',
													    '''n''',
													    '''\u0120''',
													    '''\u0120l''',
													    '''\u0120n''',
													    '''\u0120lo''',
													    '''\u0120low''',
													    '''er''',
													    '''\u0120lowest''',
													    '''\u0120newer''',
													    '''\u0120wider''',
													    '''<unk>''',
													]
													UpperCAmelCase_			:      Optional[Any]     						=  dict(zip(__magic_name__       ,     range(len(__magic_name__   )   )   )   )
													UpperCAmelCase_			:      List[Any]     						=  ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
													UpperCAmelCase_			:      str     						=  {'''unk_token''': '''<unk>'''}

													UpperCAmelCase_			:      List[Any]     						=  os.path.join(self.tmpdirname       ,     '''bart_tokenizer'''   )
													os.makedirs(__magic_name__       ,     exist_ok=__magic_name__   )
													UpperCAmelCase_			:      str     						=  os.path.join(__magic_name__       ,     BART_VOCAB_FILES_NAMES['''vocab_file''']   )
													UpperCAmelCase_			:      List[str]     						=  os.path.join(__magic_name__       ,     BART_VOCAB_FILES_NAMES['''merges_file''']   )
													with open(self.vocab_file       ,     '''w'''       ,     encoding='''utf-8'''   ) as fp:
																			fp.write(json.dumps(__magic_name__   ) + '''\n'''   )
													with open(self.merges_file       ,     '''w'''       ,     encoding='''utf-8'''   ) as fp:
																			fp.write('''\n'''.join(__magic_name__   )   )

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







													"""simple docstring"""
													return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname       ,     '''dpr_tokenizer'''   )   )

							def     UpperCAmelCase__	(							self							:     str   )					->       Tuple:







													"""simple docstring"""
													return DPRContextEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname       ,     '''dpr_tokenizer'''   )   )

							def     UpperCAmelCase__	(							self							:     str   )					->       str:







													"""simple docstring"""
													return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname       ,     '''bart_tokenizer'''   )   )

							def     UpperCAmelCase__	(							self							:     Dict   )					->       Union[str, Any]:







													"""simple docstring"""
													shutil.rmtree(self.tmpdirname   )

							def     UpperCAmelCase__	(							self							:     List[str]   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      Tuple     						=  Dataset.from_dict(
													    {
													        '''id''': ['''0''', '''1'''],
													        '''text''': ['''foo''', '''bar'''],
													        '''title''': ['''Foo''', '''Bar'''],
													        '''embeddings''': [np.ones(self.retrieval_vector_size   ), 2 * np.ones(self.retrieval_vector_size   )],
													    }   )
													dataset.add_faiss_index('''embeddings'''       ,     string_factory='''Flat'''       ,     metric_type=faiss.METRIC_INNER_PRODUCT   )
													return dataset

							def     UpperCAmelCase__	(							self							:     List[Any]   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      Any     						=  self.get_dummy_dataset()
													UpperCAmelCase_			:      int     						=  RagConfig(
													    retrieval_vector_size=self.retrieval_vector_size       ,     question_encoder=DPRConfig().to_dict()       ,     generator=BartConfig().to_dict()       ,     )
													with patch('''transformers.models.rag.retrieval_rag.load_dataset'''   ) as mock_load_dataset:
																			UpperCAmelCase_			:      Optional[Any]     						=  dataset
																			UpperCAmelCase_			:      Dict     						=  RagRetriever(
																			    __magic_name__       ,     question_encoder_tokenizer=self.get_dpr_tokenizer()       ,     generator_tokenizer=self.get_bart_tokenizer()       ,     )
													return retriever

							def     UpperCAmelCase__	(							self							:     Optional[Any]       ,     __magic_name__							:     bool   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  self.get_dummy_dataset()
													UpperCAmelCase_			:      str     						=  RagConfig(
													    retrieval_vector_size=self.retrieval_vector_size       ,     question_encoder=DPRConfig().to_dict()       ,     generator=BartConfig().to_dict()       ,     index_name='''custom'''       ,     )
													if from_disk:
																			UpperCAmelCase_			:      Tuple     						=  os.path.join(self.tmpdirname       ,     '''dataset'''   )
																			UpperCAmelCase_			:      Optional[int]     						=  os.path.join(self.tmpdirname       ,     '''index.faiss'''   )
																			dataset.get_index('''embeddings'''   ).save(os.path.join(self.tmpdirname       ,     '''index.faiss'''   )   )
																			dataset.drop_index('''embeddings'''   )
																			dataset.save_to_disk(os.path.join(self.tmpdirname       ,     '''dataset'''   )   )
																			del dataset
																			UpperCAmelCase_			:      Union[str, Any]     						=  RagRetriever(
																			    __magic_name__       ,     question_encoder_tokenizer=self.get_dpr_tokenizer()       ,     generator_tokenizer=self.get_bart_tokenizer()       ,     )
													else:
																			UpperCAmelCase_			:      Optional[Any]     						=  RagRetriever(
																			    __magic_name__       ,     question_encoder_tokenizer=self.get_dpr_tokenizer()       ,     generator_tokenizer=self.get_bart_tokenizer()       ,     index=CustomHFIndex(config.retrieval_vector_size       ,     __magic_name__   )       ,     )
													return retriever

							def     UpperCAmelCase__	(							self							:     Any   )					->       int:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  Dataset.from_dict(
													    {
													        '''id''': ['''0''', '''1'''],
													        '''text''': ['''foo''', '''bar'''],
													        '''title''': ['''Foo''', '''Bar'''],
													        '''embeddings''': [np.ones(self.retrieval_vector_size + 1   ), 2 * np.ones(self.retrieval_vector_size + 1   )],
													    }   )
													dataset.add_faiss_index('''embeddings'''       ,     string_factory='''Flat'''       ,     metric_type=faiss.METRIC_INNER_PRODUCT   )

													UpperCAmelCase_			:      str     						=  os.path.join(self.tmpdirname       ,     '''hf_bert_base.hnswSQ8_correct_phi_128.c_index'''   )
													dataset.save_faiss_index('''embeddings'''       ,     index_file_name + '''.index.dpr'''   )
													pickle.dump(dataset['''id''']       ,     open(index_file_name + '''.index_meta.dpr'''       ,     '''wb'''   )   )

													UpperCAmelCase_			:      Tuple     						=  os.path.join(self.tmpdirname       ,     '''psgs_w100.tsv.pkl'''   )
													UpperCAmelCase_			:      List[str]     						=  {sample['''id''']: [sample['''text'''], sample['''title''']] for sample in dataset}
													pickle.dump(__magic_name__       ,     open(__magic_name__       ,     '''wb'''   )   )

													UpperCAmelCase_			:      Tuple     						=  RagConfig(
													    retrieval_vector_size=self.retrieval_vector_size       ,     question_encoder=DPRConfig().to_dict()       ,     generator=BartConfig().to_dict()       ,     index_name='''legacy'''       ,     index_path=self.tmpdirname       ,     )
													UpperCAmelCase_			:      int     						=  RagRetriever(
													    __magic_name__       ,     question_encoder_tokenizer=self.get_dpr_tokenizer()       ,     generator_tokenizer=self.get_bart_tokenizer()   )
													return retriever

							def     UpperCAmelCase__	(							self							:     Optional[int]   )					->       Union[str, Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      List[Any]     						=  1
													UpperCAmelCase_			:      Dict     						=  self.get_dummy_canonical_hf_index_retriever()
													UpperCAmelCase_			:      Tuple     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      Optional[Any]     						=  retriever.retrieve(__magic_name__       ,     n_docs=__magic_name__   )
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertEqual(len(__magic_name__   )       ,     2   )
													self.assertEqual(sorted(doc_dicts[0]   )       ,     ['''embeddings''', '''id''', '''text''', '''title''']   )
													self.assertEqual(len(doc_dicts[0]['''id''']   )       ,     __magic_name__   )
													self.assertEqual(doc_dicts[0]['''id'''][0]       ,     '''1'''   )  # max inner product is reached with second doc
													self.assertEqual(doc_dicts[1]['''id'''][0]       ,     '''0'''   )  # max inner product is reached with first doc
													self.assertListEqual(doc_ids.tolist()       ,     [[1], [0]]   )

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







													"""simple docstring"""
													UpperCAmelCase_			:      int     						=  self.get_dummy_canonical_hf_index_retriever()
													with tempfile.TemporaryDirectory() as tmp_dirname:
																			with patch('''transformers.models.rag.retrieval_rag.load_dataset'''   ) as mock_load_dataset:
																									UpperCAmelCase_			:      int     						=  self.get_dummy_dataset()
																									retriever.save_pretrained(__magic_name__   )
																									UpperCAmelCase_			:      Tuple     						=  RagRetriever.from_pretrained(__magic_name__   )
																									self.assertIsInstance(__magic_name__       ,     __magic_name__   )
																									UpperCAmelCase_			:      Any     						=  np.array(
																									    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
																									UpperCAmelCase_			:      List[str]     						=  retriever.retrieve(__magic_name__       ,     n_docs=1   )
																									self.assertTrue(out is not None   )

							def     UpperCAmelCase__	(							self							:     int   )					->       Tuple:







													"""simple docstring"""
													UpperCAmelCase_			:      Dict     						=  1
													UpperCAmelCase_			:      Dict     						=  self.get_dummy_custom_hf_index_retriever(from_disk=__magic_name__   )
													UpperCAmelCase_			:      Tuple     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      Any     						=  retriever.retrieve(__magic_name__       ,     n_docs=__magic_name__   )
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertEqual(len(__magic_name__   )       ,     2   )
													self.assertEqual(sorted(doc_dicts[0]   )       ,     ['''embeddings''', '''id''', '''text''', '''title''']   )
													self.assertEqual(len(doc_dicts[0]['''id''']   )       ,     __magic_name__   )
													self.assertEqual(doc_dicts[0]['''id'''][0]       ,     '''1'''   )  # max inner product is reached with second doc
													self.assertEqual(doc_dicts[1]['''id'''][0]       ,     '''0'''   )  # max inner product is reached with first doc
													self.assertListEqual(doc_ids.tolist()       ,     [[1], [0]]   )

							def     UpperCAmelCase__	(							self							:     Any   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  self.get_dummy_custom_hf_index_retriever(from_disk=__magic_name__   )
													with tempfile.TemporaryDirectory() as tmp_dirname:
																			retriever.save_pretrained(__magic_name__   )
																			UpperCAmelCase_			:      int     						=  RagRetriever.from_pretrained(__magic_name__   )
																			self.assertIsInstance(__magic_name__       ,     __magic_name__   )
																			UpperCAmelCase_			:      Any     						=  np.array(
																			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
																			UpperCAmelCase_			:      Optional[int]     						=  retriever.retrieve(__magic_name__       ,     n_docs=1   )
																			self.assertTrue(out is not None   )

							def     UpperCAmelCase__	(							self							:     int   )					->       List[Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      str     						=  1
													UpperCAmelCase_			:      Optional[Any]     						=  self.get_dummy_custom_hf_index_retriever(from_disk=__magic_name__   )
													UpperCAmelCase_			:      List[Any]     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      List[Any]     						=  retriever.retrieve(__magic_name__       ,     n_docs=__magic_name__   )
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertEqual(len(__magic_name__   )       ,     2   )
													self.assertEqual(sorted(doc_dicts[0]   )       ,     ['''embeddings''', '''id''', '''text''', '''title''']   )
													self.assertEqual(len(doc_dicts[0]['''id''']   )       ,     __magic_name__   )
													self.assertEqual(doc_dicts[0]['''id'''][0]       ,     '''1'''   )  # max inner product is reached with second doc
													self.assertEqual(doc_dicts[1]['''id'''][0]       ,     '''0'''   )  # max inner product is reached with first doc
													self.assertListEqual(doc_ids.tolist()       ,     [[1], [0]]   )

							def     UpperCAmelCase__	(							self							:     List[Any]   )					->       str:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[int]     						=  self.get_dummy_custom_hf_index_retriever(from_disk=__magic_name__   )
													with tempfile.TemporaryDirectory() as tmp_dirname:
																			retriever.save_pretrained(__magic_name__   )
																			UpperCAmelCase_			:      str     						=  RagRetriever.from_pretrained(__magic_name__   )
																			self.assertIsInstance(__magic_name__       ,     __magic_name__   )
																			UpperCAmelCase_			:      Optional[int]     						=  np.array(
																			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
																			UpperCAmelCase_			:      List[Any]     						=  retriever.retrieve(__magic_name__       ,     n_docs=1   )
																			self.assertTrue(out is not None   )

							def     UpperCAmelCase__	(							self							:     List[Any]   )					->       Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_			:      str     						=  1
													UpperCAmelCase_			:      int     						=  self.get_dummy_legacy_index_retriever()
													UpperCAmelCase_			:      str     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      Optional[Any]     						=  retriever.retrieve(__magic_name__       ,     n_docs=__magic_name__   )
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertEqual(len(__magic_name__   )       ,     2   )
													self.assertEqual(sorted(doc_dicts[0]   )       ,     ['''text''', '''title''']   )
													self.assertEqual(len(doc_dicts[0]['''text''']   )       ,     __magic_name__   )
													self.assertEqual(doc_dicts[0]['''text'''][0]       ,     '''bar'''   )  # max inner product is reached with second doc
													self.assertEqual(doc_dicts[1]['''text'''][0]       ,     '''foo'''   )  # max inner product is reached with first doc
													self.assertListEqual(doc_ids.tolist()       ,     [[1], [0]]   )

							def     UpperCAmelCase__	(							self							:     int   )					->       Dict:







													"""simple docstring"""
													UpperCAmelCase_			:      Dict     						=  self.get_dummy_legacy_index_retriever()
													with tempfile.TemporaryDirectory() as tmp_dirname:
																			retriever.save_pretrained(__magic_name__   )
																			UpperCAmelCase_			:      Tuple     						=  RagRetriever.from_pretrained(__magic_name__   )
																			self.assertIsInstance(__magic_name__       ,     __magic_name__   )
																			UpperCAmelCase_			:      Tuple     						=  np.array(
																			    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
																			UpperCAmelCase_			:      Union[str, Any]     						=  retriever.retrieve(__magic_name__       ,     n_docs=1   )
																			self.assertTrue(out is not None   )

							@require_torch
							@require_tokenizers
							@require_sentencepiece
							def     UpperCAmelCase__	(							self							:     int   )					->       str:







													"""simple docstring"""
													import torch

													UpperCAmelCase_			:      str     						=  1
													UpperCAmelCase_			:      Dict     						=  self.get_dummy_canonical_hf_index_retriever()
													UpperCAmelCase_			:      int     						=  [[5, 7], [10, 11]]
													UpperCAmelCase_			:      str     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_			:      Any     						=  retriever(__magic_name__       ,     __magic_name__       ,     prefix=retriever.config.generator.prefix       ,     n_docs=__magic_name__   )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      Union[str, Any]     						=  (
													    out['''context_input_ids'''],
													    out['''context_attention_mask'''],
													    out['''retrieved_doc_embeds'''],
													)
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertIsInstance(__magic_name__       ,     __magic_name__   )
													self.assertIsInstance(__magic_name__       ,     __magic_name__   )
													self.assertIsInstance(__magic_name__       ,     np.ndarray   )

													UpperCAmelCase_			:      Optional[Any]     						=  retriever(
													    __magic_name__       ,     __magic_name__       ,     prefix=retriever.config.generator.prefix       ,     n_docs=__magic_name__       ,     return_tensors='''pt'''       ,     )
													UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_			:      Dict     						=  (  # noqa: F841
													    out['''context_input_ids'''],
													    out['''context_attention_mask'''],
													    out['''retrieved_doc_embeds'''],
													    out['''doc_ids'''],
													)
													self.assertEqual(retrieved_doc_embeds.shape       ,     (2, n_docs, self.retrieval_vector_size)   )
													self.assertIsInstance(__magic_name__       ,     torch.Tensor   )
													self.assertIsInstance(__magic_name__       ,     torch.Tensor   )
													self.assertIsInstance(__magic_name__       ,     torch.Tensor   )



							@require_torch
							@require_tokenizers
							@require_sentencepiece
							def     UpperCAmelCase__	(							self							:     Tuple   )					->       Any:







													"""simple docstring"""
													UpperCAmelCase_			:      Union[str, Any]     						=  self.get_dpr_ctx_encoder_tokenizer()
													UpperCAmelCase_			:      Any     						=  1
													UpperCAmelCase_			:      Dict     						=  self.get_dummy_custom_hf_index_retriever(from_disk=__magic_name__   )
													retriever.set_ctx_encoder_tokenizer(__magic_name__   )

													UpperCAmelCase_			:      Any     						=  [[5, 7], [10, 11]]
													UpperCAmelCase_			:      List[str]     						=  np.array(
													    [np.ones(self.retrieval_vector_size   ), -np.ones(self.retrieval_vector_size   )]       ,     dtype=np.floataa   )
													UpperCAmelCase_			:      str     						=  retriever(__magic_name__       ,     __magic_name__       ,     prefix=retriever.config.generator.prefix       ,     n_docs=__magic_name__   )

													self.assertEqual(
													    len(__magic_name__   )       ,     6   )  # check whether the retriever output consist of 6 attributes including tokenized docs
													self.assertEqual(
													    all(k in out for k in ('''tokenized_doc_ids''', '''tokenized_doc_attention_mask''')   )       ,     __magic_name__   )  # check for doc token related keys in dictionary.












'''simple docstring'''







import sys
import turtle





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float]   ) ->	tuple[float, float]:
						return (pa[0] + pa[0]) / 2, (pa[1] + pa[1]) / 2





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			tuple[float, float],			SCREAMING_SNAKE_CASE__      :			int,			) ->	None:
						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(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			depth - 1   )
						triangle(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			depth - 1   )
						triangle(SCREAMING_SNAKE_CASE__,			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			get_mid(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   ),			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>"
										)
					snake_case_     :       Any						=  turtle.Turtle()
					my_pen.ht()
					my_pen.speed(5)
					my_pen.pencolor("red")

					snake_case_     :       Tuple						=  [(-1_75, -1_25), (0, 1_75), (1_75, -1_25)]  # vertices of triangle
					triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))





