



from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
				    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
				    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
				    LayoutLMvaConfig,
				    TFLayoutLMvaForQuestionAnswering,
				    TFLayoutLMvaForSequenceClassification,
				    TFLayoutLMvaForTokenClassification,
				    TFLayoutLMvaModel,
				)

if is_vision_available():
				from PIL import Image

				from transformers import LayoutLMvaImageProcessor






class     __a			:



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

						# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
						__lowerCAmelCase						 =text_seq_length
						__lowerCAmelCase						 =(image_size // patch_size) ** 2 + 1
						__lowerCAmelCase						 =self.text_seq_length + self.image_seq_length



	def 		UpperCamelCase				(    self				:     Dict)->				Optional[int]:
						__lowerCAmelCase						 =ids_tensor([self.batch_size, self.text_seq_length]					,						self.vocab_size)

						__lowerCAmelCase						 =ids_tensor([self.batch_size, self.text_seq_length, 4]					,						self.range_bbox)
						__lowerCAmelCase						 =bbox.numpy()
						# 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]:
																					__lowerCAmelCase						 =bbox[i, j, 3]
																					__lowerCAmelCase						 =bbox[i, j, 1]
																					__lowerCAmelCase						 =tmp_coordinate
																if bbox[i, j, 2] < bbox[i, j, 0]:
																					__lowerCAmelCase						 =bbox[i, j, 2]
																					__lowerCAmelCase						 =bbox[i, j, 0]
																					__lowerCAmelCase						 =tmp_coordinate
						__lowerCAmelCase						 =tf.constant(snake_case_)

						__lowerCAmelCase						 =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

						__lowerCAmelCase						 =None
						if self.use_input_mask:
											__lowerCAmelCase						 =random_attention_mask([self.batch_size, self.text_seq_length])

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

						__lowerCAmelCase						 =None
						__lowerCAmelCase						 =None
						if self.use_labels:
											__lowerCAmelCase						 =ids_tensor([self.batch_size]					,						self.type_sequence_label_size)
											__lowerCAmelCase						 =ids_tensor([self.batch_size, self.text_seq_length]					,						self.num_labels)

						__lowerCAmelCase						 =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 		UpperCamelCase				(    self				:     List[str]					,						snake_case_				:     int					,						snake_case_				:     Any					,						snake_case_				:     Union[str, Any]					,						snake_case_				:     Optional[int]					,						snake_case_				:     int					,						snake_case_				:     Optional[int])->				Tuple:
						__lowerCAmelCase						 =TFLayoutLMvaModel(config=snake_case_)

						# text + image
						__lowerCAmelCase						 =model(snake_case_					,						pixel_values=snake_case_					,						training=snake_case_)
						__lowerCAmelCase						 =model(
						    snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						attention_mask=snake_case_					,						token_type_ids=snake_case_					,						training=snake_case_					,						)
						__lowerCAmelCase						 =model(snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						training=snake_case_)

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

						# text only
						__lowerCAmelCase						 =model(snake_case_					,						training=snake_case_)
						self.parent.assertEqual(
						    result.last_hidden_state.shape					,						(self.batch_size, self.text_seq_length, self.hidden_size))

						# image only
						__lowerCAmelCase						 =model({"""pixel_values""": pixel_values}					,						training=snake_case_)
						self.parent.assertEqual(
						    result.last_hidden_state.shape					,						(self.batch_size, self.image_seq_length, self.hidden_size))



	def 		UpperCamelCase				(    self				:     Optional[Any]					,						snake_case_				:     Optional[int]					,						snake_case_				:     str					,						snake_case_				:     Any					,						snake_case_				:     Union[str, Any]					,						snake_case_				:     Optional[Any]					,						snake_case_				:     List[str]					,						snake_case_				:     Union[str, Any])->				str:
						__lowerCAmelCase						 =self.num_labels
						__lowerCAmelCase						 =TFLayoutLMvaForSequenceClassification(config=snake_case_)
						__lowerCAmelCase						 =model(
						    snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						attention_mask=snake_case_					,						token_type_ids=snake_case_					,						labels=snake_case_					,						training=snake_case_					,						)
						self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_labels))



	def 		UpperCamelCase				(    self				:     Union[str, Any]					,						snake_case_				:     Dict					,						snake_case_				:     Optional[int]					,						snake_case_				:     Optional[int]					,						snake_case_				:     List[Any]					,						snake_case_				:     Dict					,						snake_case_				:     Any					,						snake_case_				:     str)->				str:
						__lowerCAmelCase						 =self.num_labels
						__lowerCAmelCase						 =TFLayoutLMvaForTokenClassification(config=snake_case_)
						__lowerCAmelCase						 =model(
						    snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						attention_mask=snake_case_					,						token_type_ids=snake_case_					,						labels=snake_case_					,						training=snake_case_					,						)
						self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.text_seq_length, self.num_labels))



	def 		UpperCamelCase				(    self				:     List[str]					,						snake_case_				:     int					,						snake_case_				:     Optional[Any]					,						snake_case_				:     List[Any]					,						snake_case_				:     Optional[Any]					,						snake_case_				:     Optional[int]					,						snake_case_				:     Optional[int]					,						snake_case_				:     str)->				List[Any]:
						__lowerCAmelCase						 =2
						__lowerCAmelCase						 =TFLayoutLMvaForQuestionAnswering(config=snake_case_)
						__lowerCAmelCase						 =model(
						    snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						attention_mask=snake_case_					,						token_type_ids=snake_case_					,						start_positions=snake_case_					,						end_positions=snake_case_					,						training=snake_case_					,						)
						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 		UpperCamelCase				(    self				:     Optional[int])->				str:
						__lowerCAmelCase						 =self.prepare_config_and_inputs()
						((__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase) ,						(__lowerCAmelCase))						 =config_and_inputs
						__lowerCAmelCase						 ={
						    """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_tf
class     __a			(  SCREAMING_SNAKE_CASE						,     SCREAMING_SNAKE_CASE						,     unittest.TestCase					):
	SCREAMING_SNAKE_CASE  	=							(
	    (
	        TFLayoutLMvaModel,
	        TFLayoutLMvaForQuestionAnswering,
	        TFLayoutLMvaForSequenceClassification,
	        TFLayoutLMvaForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE  	=							(
	    {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
	    if is_tf_available()
	    else {}
	)

	SCREAMING_SNAKE_CASE  	=							False
	SCREAMING_SNAKE_CASE  	=							False
	SCREAMING_SNAKE_CASE  	=							False



	def 		UpperCamelCase				(    self				:     Optional[Any]					,						snake_case_				:     Optional[int]					,						snake_case_				:     List[str]					,						snake_case_				:     Union[str, Any]					,						snake_case_				:     int					,						snake_case_				:     List[str])->				Tuple:
						return True



	def 		UpperCamelCase				(    self				:     int					,						snake_case_				:     int					,						snake_case_				:     str					,						snake_case_				:     Optional[Any]=False)->				dict:
						__lowerCAmelCase						 =copy.deepcopy(snake_case_)

						if model_class in get_values(snake_case_):
											__lowerCAmelCase						 ={
											    k: tf.tile(tf.expand_dims(snake_case_					,						1)					,						(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1))
											    if isinstance(snake_case_					,						tf.Tensor) and v.ndim > 0
											    else v
											    for k, v in inputs_dict.items()
											}

						if return_labels:
											if model_class in get_values(snake_case_):
																__lowerCAmelCase						 =tf.ones(self.model_tester.batch_size					,						dtype=tf.intaa)
											elif model_class in get_values(snake_case_):
																__lowerCAmelCase						 =tf.zeros(self.model_tester.batch_size					,						dtype=tf.intaa)
																__lowerCAmelCase						 =tf.zeros(self.model_tester.batch_size					,						dtype=tf.intaa)
											elif model_class in get_values(snake_case_):
																__lowerCAmelCase						 =tf.zeros(self.model_tester.batch_size					,						dtype=tf.intaa)
											elif model_class in get_values(snake_case_):
																__lowerCAmelCase						 =tf.zeros(
																    (self.model_tester.batch_size, self.model_tester.text_seq_length)					,						dtype=tf.intaa)

						return inputs_dict



	def 		UpperCamelCase				(    self				:     List[Any])->				List[str]:
						__lowerCAmelCase						 =TFLayoutLMvaModelTester(self)
						__lowerCAmelCase						 =ConfigTester(self					,						config_class=snake_case_					,						hidden_size=37)



	def 		UpperCamelCase				(    self				:     Dict)->				Dict:
						self.config_tester.run_common_tests()



	def 		UpperCamelCase				(    self				:     str)->				Tuple:
						__lowerCAmelCase ,						__lowerCAmelCase						 =self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes:
											__lowerCAmelCase						 =model_class(snake_case_)
											if getattr(snake_case_					,						"""hf_compute_loss"""					,						snake_case_):
																# The number of elements in the loss should be the same as the number of elements in the label
																__lowerCAmelCase						 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_)
																__lowerCAmelCase						 =prepared_for_class[
																    sorted(prepared_for_class.keys() - inputs_dict.keys()					,						reverse=snake_case_)[0]
																]
																__lowerCAmelCase						 =added_label.shape.as_list()[:1]

																# Test that model correctly compute the loss with kwargs
																__lowerCAmelCase						 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_)
																__lowerCAmelCase						 =prepared_for_class.pop("""input_ids""")

																__lowerCAmelCase						 =model(snake_case_					,						**snake_case_)[0]
																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

																# Test that model correctly compute the loss when we mask some positions
																__lowerCAmelCase						 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_)
																__lowerCAmelCase						 =prepared_for_class.pop("""input_ids""")
																if "labels" in prepared_for_class:
																					__lowerCAmelCase						 =prepared_for_class["""labels"""].numpy()
																					if len(labels.shape) > 1 and labels.shape[1] != 1:
																										__lowerCAmelCase						 =-1_00
																										__lowerCAmelCase						 =tf.convert_to_tensor(snake_case_)
																										__lowerCAmelCase						 =model(snake_case_					,						**snake_case_)[0]
																										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])
																										self.assertTrue(not np.any(np.isnan(loss.numpy())))

                # Test that model correctly compute the loss with a dict
																__lowerCAmelCase						 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_)
																__lowerCAmelCase						 =model(snake_case_)[0]
																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

																# Test that model correctly compute the loss with a tuple
																__lowerCAmelCase						 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_)

																# Get keys that were added with the _prepare_for_class function
																__lowerCAmelCase						 =prepared_for_class.keys() - inputs_dict.keys()
																__lowerCAmelCase						 =inspect.signature(model.call).parameters
																__lowerCAmelCase						 =list(signature.keys())

																# Create a dictionary holding the location of the tensors in the tuple
																__lowerCAmelCase						 ={0: """input_ids"""}
																for label_key in label_keys:
																					__lowerCAmelCase						 =signature_names.index(snake_case_)
																					__lowerCAmelCase						 =label_key
																__lowerCAmelCase						 =sorted(tuple_index_mapping.items())
																# Initialize a list with their default values, update the values and convert to a tuple
																__lowerCAmelCase						 =[]

																for name in signature_names:
																					if name != "kwargs":
																										list_input.append(signature[name].default)

																for index, value in sorted_tuple_index_mapping:
																					__lowerCAmelCase						 =prepared_for_class[value]

																__lowerCAmelCase						 =tuple(snake_case_)

																# Send to model
																__lowerCAmelCase						 =model(tuple_input[:-1])[0]

																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])



	def 		UpperCamelCase				(    self				:     Tuple)->				Any:
						(
						    (
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						
						)						 =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_)



	def 		UpperCamelCase				(    self				:     str)->				List[str]:
						(
						    (
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						
						)						 =self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
											__lowerCAmelCase						 =type
											self.model_tester.create_and_check_model(snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_)



	def 		UpperCamelCase				(    self				:     Union[str, Any])->				Dict:
						(
						    (
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						
						)						 =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(
						    snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_)



	def 		UpperCamelCase				(    self				:     int)->				Union[str, Any]:
						(
						    (
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						
						)						 =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(
						    snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_)



	def 		UpperCamelCase				(    self				:     Tuple)->				List[str]:
						(
						    (
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						(
						    __lowerCAmelCase
						) ,						
						)						 =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(
						    snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_					,						snake_case_)



	@slow
	def 		UpperCamelCase				(    self				:     Optional[int])->				List[Any]:
						for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCAmelCase						 =TFLayoutLMvaModel.from_pretrained(snake_case_)
											self.assertIsNotNone(snake_case_)






def        __lowerCAmelCase		(	)	->    Any:
					__lowerCAmelCase						 =Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
					return image






@require_tf
class     __a			(  unittest.TestCase					):



	@cached_property
	def 		UpperCamelCase				(    self				:     Optional[int])->				Optional[int]:
						return LayoutLMvaImageProcessor(apply_ocr=snake_case_) if is_vision_available() else None



	@slow
	def 		UpperCamelCase				(    self				:     Any)->				str:
						__lowerCAmelCase						 =TFLayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base""")

						__lowerCAmelCase						 =self.default_image_processor
						__lowerCAmelCase						 =prepare_img()
						__lowerCAmelCase						 =image_processor(images=snake_case_					,						return_tensors="""tf""").pixel_values

						__lowerCAmelCase						 =tf.constant([[1, 2]])
						__lowerCAmelCase						 =tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]])					,						axis=0)

						# forward pass
						__lowerCAmelCase						 =model(input_ids=snake_case_					,						bbox=snake_case_					,						pixel_values=snake_case_					,						training=snake_case_)

						# verify the logits
						__lowerCAmelCase						 =(1, 1_99, 7_68)
						self.assertEqual(outputs.last_hidden_state.shape					,						snake_case_)

						__lowerCAmelCase						 =tf.constant(
						    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]])

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









from __future__ import annotations






class     __a			:



	def __init__(    self				:     Optional[int]					,						snake_case_				:     int = 0)->				List[str]:
						__lowerCAmelCase						 =key



	def 		UpperCamelCase				(    self				:     Any					,						snake_case_				:     str					,						snake_case_				:     int)->				list[str]:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key is an appropriate size
						key %= 2_55

						return [chr(ord(snake_case_) ^ key) for ch in content]



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int)->				list[str]:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key is an appropriate size
						key %= 2_55

						return [chr(ord(snake_case_) ^ key) for ch in content]



	def 		UpperCamelCase				(    self				:     str					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				str:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key can be any size
						while key > 2_55:
											key -= 2_55

						# This will be returned
						__lowerCAmelCase						 =""""""

						for ch in content:
											ans += chr(ord(snake_case_) ^ key)

						return ans



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				str:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						__lowerCAmelCase						 =key or self.__key or 1

						# make sure key can be any size
						while key > 2_55:
											key -= 2_55

						# This will be returned
						__lowerCAmelCase						 =""""""

						for ch in content:
											ans += chr(ord(snake_case_) ^ key)

						return ans



	def 		UpperCamelCase				(    self				:     int					,						snake_case_				:     str					,						snake_case_				:     int = 0)->				bool:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						try:
											with open(snake_case_) as fin, open("""encrypt.out"""					,						"""w+""") as fout:
																# actual encrypt-process
																for line in fin:
																					fout.write(self.encrypt_string(snake_case_					,						snake_case_))

						except OSError:
											return False

						return True



	def 		UpperCamelCase				(    self				:     Tuple					,						snake_case_				:     str					,						snake_case_				:     int)->				bool:
						assert isinstance(snake_case_					,						snake_case_) and isinstance(snake_case_					,						snake_case_)

						try:
											with open(snake_case_) as fin, open("""decrypt.out"""					,						"""w+""") as fout:
																# actual encrypt-process
																for line in fin:
																					fout.write(self.decrypt_string(snake_case_					,						snake_case_))

						except OSError:
											return False

						return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")




