






'''simple docstring'''
import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      LayoutLMvaConfig,
      LayoutLMvaForQuestionAnswering,
      LayoutLMvaForSequenceClassification,
      LayoutLMvaForTokenClassification,
      LayoutLMvaModel,
  )
  from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
  from PIL import Image

  from transformers import LayoutLMvaImageProcessor






class   __SCREAMING_SNAKE_CASE   :




 def __init__(   self						:				Optional[int]       ,   __lowercase						:				int       ,   __lowercase						:				str=2       ,   __lowercase						:				Optional[int]=3       ,   __lowercase						:				Any=4       ,   __lowercase						:				int=2       ,   __lowercase						:				int=7       ,   __lowercase						:				List[Any]=True       ,   __lowercase						:				Optional[int]=True       ,   __lowercase						:				Tuple=True       ,   __lowercase						:				List[str]=True       ,   __lowercase						:				Dict=99       ,   __lowercase						:				Any=36       ,   __lowercase						:				Optional[int]=3       ,   __lowercase						:				List[Any]=4       ,   __lowercase						:				Optional[Any]=37       ,   __lowercase						:				Dict="gelu"       ,   __lowercase						:				Optional[Any]=0.1       ,   __lowercase						:				Optional[Any]=0.1       ,   __lowercase						:				int=5_12       ,   __lowercase						:				Optional[int]=16       ,   __lowercase						:				Dict=2       ,   __lowercase						:				Tuple=0.02       ,   __lowercase						:				List[Any]=6       ,   __lowercase						:				str=6       ,   __lowercase						:				Tuple=3       ,   __lowercase						:				Any=4       ,   __lowercase						:				str=None       ,   __lowercase						:				int=10_00       ,   )						->    Union[str, Any]:
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=parent
       SCREAMING_SNAKE_CASE__  :					List[Any]						=batch_size
       SCREAMING_SNAKE_CASE__  :					Tuple						=num_channels
       SCREAMING_SNAKE_CASE__  :					Tuple						=image_size
       SCREAMING_SNAKE_CASE__  :					Any						=patch_size
       SCREAMING_SNAKE_CASE__  :					List[str]						=text_seq_length
       SCREAMING_SNAKE_CASE__  :					Tuple						=is_training
       SCREAMING_SNAKE_CASE__  :					List[str]						=use_input_mask
       SCREAMING_SNAKE_CASE__  :					List[str]						=use_token_type_ids
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=use_labels
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=vocab_size
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=hidden_size
       SCREAMING_SNAKE_CASE__  :					int						=num_hidden_layers
       SCREAMING_SNAKE_CASE__  :					List[Any]						=num_attention_heads
       SCREAMING_SNAKE_CASE__  :					int						=intermediate_size
       SCREAMING_SNAKE_CASE__  :					List[Any]						=hidden_act
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=hidden_dropout_prob
       SCREAMING_SNAKE_CASE__  :					Tuple						=attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__  :					str						=max_position_embeddings
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=type_vocab_size
       SCREAMING_SNAKE_CASE__  :					List[Any]						=type_sequence_label_size
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=initializer_range
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=coordinate_size
       SCREAMING_SNAKE_CASE__  :					Dict						=shape_size
       SCREAMING_SNAKE_CASE__  :					str						=num_labels
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=num_choices
       SCREAMING_SNAKE_CASE__  :					Tuple						=scope
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=range_bbox

       # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
       SCREAMING_SNAKE_CASE__  :					List[Any]						=text_seq_length
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=(image_size // patch_size) ** 2 + 1
       SCREAMING_SNAKE_CASE__  :					int						=self.text_seq_length + self.image_seq_length




 def   __magic_name__						(   self						:				List[str]   )						->    Optional[Any]:
       SCREAMING_SNAKE_CASE__  :					Tuple						=ids_tensor([self.batch_size, self.text_seq_length]       ,   self.vocab_size   )

       SCREAMING_SNAKE_CASE__  :					List[str]						=ids_tensor([self.batch_size, self.text_seq_length, 4]       ,   self.range_bbox   )
       # Ensure that bbox is legal
       for i in range(bbox.shape[0]   ):
             for j in range(bbox.shape[1]   ):
                   if bbox[i, j, 3] < bbox[i, j, 1]:
                         SCREAMING_SNAKE_CASE__  :					Tuple						=bbox[i, j, 3]
                         SCREAMING_SNAKE_CASE__  :					List[str]						=bbox[i, j, 1]
                         SCREAMING_SNAKE_CASE__  :					Optional[Any]						=t
                   if bbox[i, j, 2] < bbox[i, j, 0]:
                         SCREAMING_SNAKE_CASE__  :					Any						=bbox[i, j, 2]
                         SCREAMING_SNAKE_CASE__  :					Optional[int]						=bbox[i, j, 0]
                         SCREAMING_SNAKE_CASE__  :					str						=t

       SCREAMING_SNAKE_CASE__  :					List[Any]						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

       SCREAMING_SNAKE_CASE__  :					List[Any]						=None
       if self.use_input_mask:
             SCREAMING_SNAKE_CASE__  :					Any						=random_attention_mask([self.batch_size, self.text_seq_length]   )

       SCREAMING_SNAKE_CASE__  :					Tuple						=None
       if self.use_token_type_ids:
             SCREAMING_SNAKE_CASE__  :					Tuple						=ids_tensor([self.batch_size, self.text_seq_length]       ,   self.type_vocab_size   )

       SCREAMING_SNAKE_CASE__  :					List[str]						=None
       SCREAMING_SNAKE_CASE__  :					List[str]						=None
       if self.use_labels:
             SCREAMING_SNAKE_CASE__  :					Optional[int]						=ids_tensor([self.batch_size]       ,   self.type_sequence_label_size   )
             SCREAMING_SNAKE_CASE__  :					Dict						=ids_tensor([self.batch_size, self.text_seq_length]       ,   self.num_labels   )

       SCREAMING_SNAKE_CASE__  :					Any						=LayoutLMvaConfig(
           vocab_size=self.vocab_size       ,   hidden_size=self.hidden_size       ,   num_hidden_layers=self.num_hidden_layers       ,   num_attention_heads=self.num_attention_heads       ,   intermediate_size=self.intermediate_size       ,   hidden_act=self.hidden_act       ,   hidden_dropout_prob=self.hidden_dropout_prob       ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,   max_position_embeddings=self.max_position_embeddings       ,   type_vocab_size=self.type_vocab_size       ,   initializer_range=self.initializer_range       ,   coordinate_size=self.coordinate_size       ,   shape_size=self.shape_size       ,   input_size=self.image_size       ,   patch_size=self.patch_size       ,   )

       return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels




 def   __magic_name__						(   self						:				Optional[int]       ,   __lowercase						:				List[Any]       ,   __lowercase						:				List[Any]       ,   __lowercase						:				Optional[Any]       ,   __lowercase						:				Dict       ,   __lowercase						:				str       ,   __lowercase						:				int       ,   __lowercase						:				List[str]       ,   __lowercase						:				str   )						->    Tuple:
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=LayoutLMvaModel(config=lowerCAmelCase__   )
       model.to(lowerCAmelCase__   )
       model.eval()

       # text + image
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=model(lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__   )
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=model(
           lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__       ,   attention_mask=lowerCAmelCase__       ,   token_type_ids=lowerCAmelCase__   )
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=model(lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__       ,   token_type_ids=lowerCAmelCase__   )
       SCREAMING_SNAKE_CASE__  :					Dict						=model(lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__   )

       self.parent.assertEqual(result.last_hidden_state.shape       ,   (self.batch_size, self.seq_length, self.hidden_size)   )

       # text only
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=model(lowerCAmelCase__   )
       self.parent.assertEqual(
           result.last_hidden_state.shape       ,   (self.batch_size, self.text_seq_length, self.hidden_size)   )

       # image only
       SCREAMING_SNAKE_CASE__  :					List[Any]						=model(pixel_values=lowerCAmelCase__   )
       self.parent.assertEqual(
           result.last_hidden_state.shape       ,   (self.batch_size, self.image_seq_length, self.hidden_size)   )




 def   __magic_name__						(   self						:				Dict       ,   __lowercase						:				Tuple       ,   __lowercase						:				List[str]       ,   __lowercase						:				str       ,   __lowercase						:				Tuple       ,   __lowercase						:				List[str]       ,   __lowercase						:				int       ,   __lowercase						:				Dict       ,   __lowercase						:				Union[str, Any]   )						->    Dict:
       SCREAMING_SNAKE_CASE__  :					List[str]						=self.num_labels
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=LayoutLMvaForSequenceClassification(lowerCAmelCase__   )
       model.to(lowerCAmelCase__   )
       model.eval()
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=model(
           lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__       ,   attention_mask=lowerCAmelCase__       ,   token_type_ids=lowerCAmelCase__       ,   labels=lowerCAmelCase__       ,   )
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)   )




 def   __magic_name__						(   self						:				Optional[Any]       ,   __lowercase						:				List[str]       ,   __lowercase						:				Dict       ,   __lowercase						:				Dict       ,   __lowercase						:				Optional[Any]       ,   __lowercase						:				List[str]       ,   __lowercase						:				str       ,   __lowercase						:				str       ,   __lowercase						:				Union[str, Any]   )						->    Optional[int]:
       SCREAMING_SNAKE_CASE__  :					List[Any]						=self.num_labels
       SCREAMING_SNAKE_CASE__  :					Any						=LayoutLMvaForTokenClassification(config=lowerCAmelCase__   )
       model.to(lowerCAmelCase__   )
       model.eval()
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=model(
           lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__       ,   attention_mask=lowerCAmelCase__       ,   token_type_ids=lowerCAmelCase__       ,   labels=lowerCAmelCase__       ,   )
       self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.text_seq_length, self.num_labels)   )




 def   __magic_name__						(   self						:				Optional[Any]       ,   __lowercase						:				List[Any]       ,   __lowercase						:				List[str]       ,   __lowercase						:				str       ,   __lowercase						:				int       ,   __lowercase						:				List[Any]       ,   __lowercase						:				int       ,   __lowercase						:				str       ,   __lowercase						:				Tuple   )						->    Tuple:
       SCREAMING_SNAKE_CASE__  :					List[Any]						=LayoutLMvaForQuestionAnswering(config=lowerCAmelCase__   )
       model.to(lowerCAmelCase__   )
       model.eval()
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=model(
           lowerCAmelCase__       ,   bbox=lowerCAmelCase__       ,   pixel_values=lowerCAmelCase__       ,   attention_mask=lowerCAmelCase__       ,   token_type_ids=lowerCAmelCase__       ,   start_positions=lowerCAmelCase__       ,   end_positions=lowerCAmelCase__       ,   )
       self.parent.assertEqual(result.start_logits.shape       ,   (self.batch_size, self.seq_length)   )
       self.parent.assertEqual(result.end_logits.shape       ,   (self.batch_size, self.seq_length)   )




 def   __magic_name__						(   self						:				int   )						->    Optional[int]:
       SCREAMING_SNAKE_CASE__  :					int						=self.prepare_config_and_inputs()
       (
           SCREAMING_SNAKE_CASE__			
       )  :					Optional[Any]						=config_and_inputs
       SCREAMING_SNAKE_CASE__  :					List[str]						={
           "input_ids": input_ids,
           "bbox": bbox,
           "pixel_values": pixel_values,
           "token_type_ids": token_type_ids,
           "attention_mask": input_mask,
       }
       return config, inputs_dict






@require_torch
class   __SCREAMING_SNAKE_CASE   (      a__						,					a__						,					unittest.TestCase					):
 snake_case_					=				False
 snake_case_					=				False
 snake_case_					=				False

 snake_case_					=				(
     (
         LayoutLMvaModel,
         LayoutLMvaForSequenceClassification,
         LayoutLMvaForTokenClassification,
         LayoutLMvaForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 snake_case_					=				(
     {"""document-question-answering""": LayoutLMvaForQuestionAnswering, """feature-extraction""": LayoutLMvaModel}
     if is_torch_available()
     else {}
 )




 def   __magic_name__						(   self						:				str       ,   __lowercase						:				List[Any]       ,   __lowercase						:				Dict       ,   __lowercase						:				List[Any]       ,   __lowercase						:				Dict       ,   __lowercase						:				Dict   )						->    List[str]:
       # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
       # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
       # the sequence dimension of the text embedding only.
       # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
       return True




 def   __magic_name__						(   self						:				str   )						->    Optional[Any]:
       SCREAMING_SNAKE_CASE__  :					Any						=LayoutLMvaModelTester(self   )
       SCREAMING_SNAKE_CASE__  :					Optional[Any]						=ConfigTester(self       ,   config_class=lowerCAmelCase__       ,   hidden_size=37   )




 def   __magic_name__						(   self						:				Optional[int]       ,   __lowercase						:				Dict       ,   __lowercase						:				Any       ,   __lowercase						:				Optional[Any]=False   )						->    Dict:
       SCREAMING_SNAKE_CASE__  :					Tuple						=copy.deepcopy(lowerCAmelCase__   )
       if model_class in get_values(lowerCAmelCase__   ):
             SCREAMING_SNAKE_CASE__  :					Optional[Any]						={
                 k: v.unsqueeze(1   ).expand(-1       ,   self.model_tester.num_choices       ,   -1   ).contiguous()
                 if isinstance(lowerCAmelCase__       ,   torch.Tensor   ) and v.ndim > 1
                 else v
                 for k, v in inputs_dict.items()
             }
       if return_labels:
             if model_class in get_values(lowerCAmelCase__   ):
                   SCREAMING_SNAKE_CASE__  :					List[str]						=torch.ones(self.model_tester.batch_size       ,   dtype=torch.long       ,   device=lowerCAmelCase__   )
             elif model_class in get_values(lowerCAmelCase__   ):
                   SCREAMING_SNAKE_CASE__  :					Optional[Any]						=torch.zeros(
                       self.model_tester.batch_size       ,   dtype=torch.long       ,   device=lowerCAmelCase__   )
                   SCREAMING_SNAKE_CASE__  :					Tuple						=torch.zeros(
                       self.model_tester.batch_size       ,   dtype=torch.long       ,   device=lowerCAmelCase__   )
             elif model_class in [
                 *get_values(lowerCAmelCase__   ),
             ]:
                   SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=torch.zeros(
                       self.model_tester.batch_size       ,   dtype=torch.long       ,   device=lowerCAmelCase__   )
             elif model_class in [
                 *get_values(lowerCAmelCase__   ),
             ]:
                   SCREAMING_SNAKE_CASE__  :					Optional[int]						=torch.zeros(
                       (self.model_tester.batch_size, self.model_tester.text_seq_length)       ,   dtype=torch.long       ,   device=lowerCAmelCase__       ,   )

       return inputs_dict




 def   __magic_name__						(   self						:				int   )						->    List[str]:
       self.config_tester.run_common_tests()




 def   __magic_name__						(   self						:				Any   )						->    List[Any]:
       SCREAMING_SNAKE_CASE__  :					Dict						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowerCAmelCase__   )




 def   __magic_name__						(   self						:				Dict   )						->    str:
       SCREAMING_SNAKE_CASE__  :					Dict						=self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
             SCREAMING_SNAKE_CASE__  :					Dict						=type
             self.model_tester.create_and_check_model(*lowerCAmelCase__   )




 def   __magic_name__						(   self						:				Optional[int]   )						->    Optional[Any]:
       SCREAMING_SNAKE_CASE__  :					Dict						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__   )




 def   __magic_name__						(   self						:				List[str]   )						->    List[Any]:
       SCREAMING_SNAKE_CASE__  :					Optional[int]						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__   )




 def   __magic_name__						(   self						:				List[str]   )						->    List[str]:
       SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__   )




 @slow
 def   __magic_name__						(   self						:				List[str]   )						->    int:
       for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             SCREAMING_SNAKE_CASE__  :					Union[str, Any]						=LayoutLMvaModel.from_pretrained(lowerCAmelCase__   )
             self.assertIsNotNone(lowerCAmelCase__   )





def 			_a(	):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__  :					List[str]						=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
      return image







@require_torch
class   __SCREAMING_SNAKE_CASE   (      unittest.TestCase					):




 @cached_property
 def   __magic_name__						(   self						:				Dict   )						->    Tuple:
       return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase__   ) if is_vision_available() else None




 @slow
 def   __magic_name__						(   self						:				Optional[int]   )						->    Any:
       SCREAMING_SNAKE_CASE__  :					int						=LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''   ).to(lowerCAmelCase__   )

       SCREAMING_SNAKE_CASE__  :					List[Any]						=self.default_image_processor
       SCREAMING_SNAKE_CASE__  :					str						=prepare_img()
       SCREAMING_SNAKE_CASE__  :					List[Any]						=image_processor(images=lowerCAmelCase__       ,   return_tensors='''pt'''   ).pixel_values.to(lowerCAmelCase__   )

       SCREAMING_SNAKE_CASE__  :					Dict						=torch.tensor([[1, 2]]   )
       SCREAMING_SNAKE_CASE__  :					Any						=torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]   ).unsqueeze(0   )

       # forward pass
       SCREAMING_SNAKE_CASE__  :					int						=model(
           input_ids=input_ids.to(lowerCAmelCase__   )       ,   bbox=bbox.to(lowerCAmelCase__   )       ,   pixel_values=pixel_values.to(lowerCAmelCase__   )       ,   )

       # verify the logits
       SCREAMING_SNAKE_CASE__  :					int						=torch.Size((1, 1_99, 7_68)   )
       self.assertEqual(outputs.last_hidden_state.shape       ,   lowerCAmelCase__   )

       SCREAMING_SNAKE_CASE__  :					Any						=torch.tensor(
           [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]   ).to(lowerCAmelCase__   )

       self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]       ,   lowerCAmelCase__       ,   atol=1e-4   )   )






"""simple docstring"""




from __future__ import annotations

import matplotlib.pyplot as plt  # type: ignore
import numpy

# initial triangle of Koch snowflake
a		:					int	      =     numpy.array([0, 0])
a		:					Optional[Any]	      =     numpy.array([0.5, 0.866_0254])
a		:					Tuple	      =     numpy.array([1, 0])
a		:					List[str]	      =     [VECTOR_1, VECTOR_2, VECTOR_3, VECTOR_1]






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list[numpy.ndarray]       ,			_lowercase		:       int   )					->list[numpy.ndarray]:






	'''simple docstring'''






	a :						List[str]      =							initial_vectors
	for _ in range(_lowercase   ):
		a :						Optional[Any]      =							iteration_step(_lowercase   )
	return vectors






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list[numpy.ndarray]   )					->list[numpy.ndarray]:






	'''simple docstring'''






	a :						Union[str, Any]      =							[]
	for i, start_vector in enumerate(vectors[:-1]   ):
		a :						str      =							vectors[i + 1]
		new_vectors.append(_lowercase   )
		a :						Optional[int]      =							end_vector - start_vector
		new_vectors.append(start_vector + difference_vector / 3   )
		new_vectors.append(
		    start_vector + difference_vector / 3 + rotate(difference_vector / 3       ,			60   )   )
		new_vectors.append(start_vector + difference_vector * 2 / 3   )
	new_vectors.append(vectors[-1]   )
	return new_vectors






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       numpy.ndarray       ,			_lowercase		:       float   )					->numpy.ndarray:






	'''simple docstring'''






	a :						int      =							numpy.radians(_lowercase   )
	a,			a :						Optional[int]      =							numpy.cos(_lowercase   ), numpy.sin(_lowercase   )
	a :						Dict      =							numpy.array(((c, -s), (s, c))   )
	return numpy.dot(_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list[numpy.ndarray]   )					->None:






	'''simple docstring'''






	a :						Dict      =							plt.gca()
	axes.set_aspect("equal"   )

	# matplotlib.pyplot.plot takes a list of all x-coordinates and a list of all
	# y-coordinates as inputs, which are constructed from the vector-list using
	# zip()
	a,			a :						Any      =							zip(*_lowercase   )
	plt.plot(_lowercase       ,			_lowercase   )
	plt.show()


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		a		:					Optional[int]	      =     iterate(INITIAL_VECTORS, 5)
		plot(processed_vectors)


