






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       __UpperCAmelCase		:







			def __init__(	self:  List[Any]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  List[str]=2      ,	UpperCAmelCase_:  int=3      ,	UpperCAmelCase_:  List[Any]=4      ,	UpperCAmelCase_:  Any=2      ,	UpperCAmelCase_:  str=7      ,	UpperCAmelCase_:  Optional[int]=True      ,	UpperCAmelCase_:  Optional[int]=True      ,	UpperCAmelCase_:  str=True      ,	UpperCAmelCase_:  Union[str, Any]=True      ,	UpperCAmelCase_:  Optional[int]=99      ,	UpperCAmelCase_:  List[Any]=36      ,	UpperCAmelCase_:  Optional[Any]=3      ,	UpperCAmelCase_:  Union[str, Any]=4      ,	UpperCAmelCase_:  Any=37      ,	UpperCAmelCase_:  Dict="gelu"      ,	UpperCAmelCase_:  Optional[int]=0.1      ,	UpperCAmelCase_:  Optional[Any]=0.1      ,	UpperCAmelCase_:  Any=512      ,	UpperCAmelCase_:  int=16      ,	UpperCAmelCase_:  List[Any]=2      ,	UpperCAmelCase_:  List[Any]=0.02      ,	UpperCAmelCase_:  List[Any]=6      ,	UpperCAmelCase_:  Optional[Any]=6      ,	UpperCAmelCase_:  Union[str, Any]=3      ,	UpperCAmelCase_:  List[str]=4      ,	UpperCAmelCase_:  Dict=None      ,	UpperCAmelCase_:  Optional[int]=1_000      ,	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  parent
									_SCREAMING_SNAKE_CASE	      =  batch_size
									_SCREAMING_SNAKE_CASE	      =  num_channels
									_SCREAMING_SNAKE_CASE	      =  image_size
									_SCREAMING_SNAKE_CASE	      =  patch_size
									_SCREAMING_SNAKE_CASE	      =  text_seq_length
									_SCREAMING_SNAKE_CASE	      =  is_training
									_SCREAMING_SNAKE_CASE	      =  use_input_mask
									_SCREAMING_SNAKE_CASE	      =  use_token_type_ids
									_SCREAMING_SNAKE_CASE	      =  use_labels
									_SCREAMING_SNAKE_CASE	      =  vocab_size
									_SCREAMING_SNAKE_CASE	      =  hidden_size
									_SCREAMING_SNAKE_CASE	      =  num_hidden_layers
									_SCREAMING_SNAKE_CASE	      =  num_attention_heads
									_SCREAMING_SNAKE_CASE	      =  intermediate_size
									_SCREAMING_SNAKE_CASE	      =  hidden_act
									_SCREAMING_SNAKE_CASE	      =  hidden_dropout_prob
									_SCREAMING_SNAKE_CASE	      =  attention_probs_dropout_prob
									_SCREAMING_SNAKE_CASE	      =  max_position_embeddings
									_SCREAMING_SNAKE_CASE	      =  type_vocab_size
									_SCREAMING_SNAKE_CASE	      =  type_sequence_label_size
									_SCREAMING_SNAKE_CASE	      =  initializer_range
									_SCREAMING_SNAKE_CASE	      =  coordinate_size
									_SCREAMING_SNAKE_CASE	      =  shape_size
									_SCREAMING_SNAKE_CASE	      =  num_labels
									_SCREAMING_SNAKE_CASE	      =  num_choices
									_SCREAMING_SNAKE_CASE	      =  scope
									_SCREAMING_SNAKE_CASE	      =  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	      =  text_seq_length
									_SCREAMING_SNAKE_CASE	      =  (image_size // patch_size) ** 2 + 1
									_SCREAMING_SNAKE_CASE	      =  self.text_seq_length + self.image_seq_length







			def 							UpperCamelCase      (	self:  Optional[int]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size, self.text_seq_length]      ,	self.vocab_size     )

									_SCREAMING_SNAKE_CASE	      =  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	      =  bbox[i, j, 3]
																											_SCREAMING_SNAKE_CASE	      =  bbox[i, j, 1]
																											_SCREAMING_SNAKE_CASE	      =  t
																					if bbox[i, j, 2] < bbox[i, j, 0]:
																											_SCREAMING_SNAKE_CASE	      =  bbox[i, j, 2]
																											_SCREAMING_SNAKE_CASE	      =  bbox[i, j, 0]
																											_SCREAMING_SNAKE_CASE	      =  t

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

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

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

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

									_SCREAMING_SNAKE_CASE	      =  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:  str      ,	UpperCAmelCase_:  Union[str, Any]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Union[str, Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaModel(config=lowerCAmelCase_     )
									model.to(lowerCAmelCase_     )
									model.eval()

									# text + image
									_SCREAMING_SNAKE_CASE	      =  model(lowerCAmelCase_      ,	pixel_values=lowerCAmelCase_     )
									_SCREAMING_SNAKE_CASE	      =  model(
									    lowerCAmelCase_      ,	bbox=lowerCAmelCase_      ,	pixel_values=lowerCAmelCase_      ,	attention_mask=lowerCAmelCase_      ,	token_type_ids=lowerCAmelCase_     )
									_SCREAMING_SNAKE_CASE	      =  model(lowerCAmelCase_      ,	bbox=lowerCAmelCase_      ,	pixel_values=lowerCAmelCase_      ,	token_type_ids=lowerCAmelCase_     )
									_SCREAMING_SNAKE_CASE	      =  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	      =  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	      =  model(pixel_values=lowerCAmelCase_     )
									self.parent.assertEqual(
									    result.last_hidden_state.shape      ,	(self.batch_size, self.image_seq_length, self.hidden_size)     )







			def 							UpperCamelCase      (	self:  int      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  Dict     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.num_labels
									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaForSequenceClassification(lowerCAmelCase_     )
									model.to(lowerCAmelCase_     )
									model.eval()
									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  List[Any]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Optional[int]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.num_labels
									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaForTokenClassification(config=lowerCAmelCase_     )
									model.to(lowerCAmelCase_     )
									model.eval()
									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  Optional[Any]      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Union[str, Any]      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  Any     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaForQuestionAnswering(config=lowerCAmelCase_     )
									model.to(lowerCAmelCase_     )
									model.eval()
									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  Optional[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.prepare_config_and_inputs()
									(
									    _SCREAMING_SNAKE_CASE	
									)	      =  config_and_inputs
									_SCREAMING_SNAKE_CASE	      =  {
									    "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       __UpperCAmelCase		(__A       ,__A       ,unittest.TestCase    ):
			__snake_case				:      Tuple 						=							False
			__snake_case				:      int 						=							False
			__snake_case				:      Optional[Any] 						=							False

			__snake_case				:      Dict 						=							(
			    (
			        LayoutLMvaModel,
			        LayoutLMvaForSequenceClassification,
			        LayoutLMvaForTokenClassification,
			        LayoutLMvaForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			__snake_case				:      Union[str, Any] 						=							(
			    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
			    if is_torch_available()
			    else {}
			)







			def 							UpperCamelCase      (	self:  Union[str, Any]      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  Dict     ):







									'''simple docstring'''




									return True







			def 							UpperCamelCase      (	self:  str     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaModelTester(self     )
									_SCREAMING_SNAKE_CASE	      =  ConfigTester(self      ,	config_class=lowerCAmelCase_      ,	hidden_size=37     )







			def 							UpperCamelCase      (	self:  Tuple      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  int=False     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  copy.deepcopy(lowerCAmelCase_     )
									if model_class in get_values(lowerCAmelCase_     ):
															_SCREAMING_SNAKE_CASE	      =  {
															    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	      =  torch.ones(self.model_tester.batch_size      ,	dtype=torch.long      ,	device=lowerCAmelCase_     )
															elif model_class in get_values(lowerCAmelCase_     ):
																					_SCREAMING_SNAKE_CASE	      =  torch.zeros(
																					    self.model_tester.batch_size      ,	dtype=torch.long      ,	device=lowerCAmelCase_     )
																					_SCREAMING_SNAKE_CASE	      =  torch.zeros(
																					    self.model_tester.batch_size      ,	dtype=torch.long      ,	device=lowerCAmelCase_     )
															elif model_class in [
															    *get_values(lowerCAmelCase_     ),
															]:
																					_SCREAMING_SNAKE_CASE	      =  torch.zeros(
																					    self.model_tester.batch_size      ,	dtype=torch.long      ,	device=lowerCAmelCase_     )
															elif model_class in [
															    *get_values(lowerCAmelCase_     ),
															]:
																					_SCREAMING_SNAKE_CASE	      =  torch.zeros(
																					    (self.model_tester.batch_size, self.model_tester.text_seq_length)      ,	dtype=torch.long      ,	device=lowerCAmelCase_      ,	)

									return inputs_dict







			def 							UpperCamelCase      (	self:  List[str]     ):







									'''simple docstring'''




									self.config_tester.run_common_tests()







			def 							UpperCamelCase      (	self:  List[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowerCAmelCase_     )







			def 							UpperCamelCase      (	self:  Union[str, Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
															_SCREAMING_SNAKE_CASE	      =  type
															self.model_tester.create_and_check_model(*lowerCAmelCase_     )







			def 							UpperCamelCase      (	self:  List[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_     )







			def 							UpperCamelCase      (	self:  Optional[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_     )







			def 							UpperCamelCase      (	self:  int     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_     )







			@slow
			def 							UpperCamelCase      (	self:  Dict     ):







									'''simple docstring'''




									for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE	      =  LayoutLMvaModel.from_pretrained(lowerCAmelCase_     )
															self.assertIsNotNone(lowerCAmelCase_     )

def        __lowerCamelCase			(		)							->  Dict:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE	      =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
						return image




@require_torch
class       __UpperCAmelCase		(unittest.TestCase    ):







			@cached_property
			def 							UpperCamelCase      (	self:  List[str]     ):







									'''simple docstring'''




									return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase_     ) if is_vision_available() else None







			@slow
			def 							UpperCamelCase      (	self:  int     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""     ).to(lowerCAmelCase_     )

									_SCREAMING_SNAKE_CASE	      =  self.default_image_processor
									_SCREAMING_SNAKE_CASE	      =  prepare_img()
									_SCREAMING_SNAKE_CASE	      =  image_processor(images=lowerCAmelCase_      ,	return_tensors="""pt"""     ).pixel_values.to(lowerCAmelCase_     )

									_SCREAMING_SNAKE_CASE	      =  torch.tensor([[1, 2]]     )
									_SCREAMING_SNAKE_CASE	      =  torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]     ).unsqueeze(0     )

									# forward pass
									_SCREAMING_SNAKE_CASE	      =  model(
									    input_ids=input_ids.to(lowerCAmelCase_     )      ,	bbox=bbox.to(lowerCAmelCase_     )      ,	pixel_values=pixel_values.to(lowerCAmelCase_     )      ,	)

									# verify the logits
									_SCREAMING_SNAKE_CASE	      =  torch.Size((1, 199, 768)     )
									self.assertEqual(outputs.last_hidden_state.shape      ,	lowerCAmelCase_     )

									_SCREAMING_SNAKE_CASE	      =  torch.tensor(
									    [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]]     ).to(lowerCAmelCase_     )

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









"""simple docstring"""
import copy
import os

import cva
import numpy as np
from matplotlib import pyplot as plt







class 			UpperCamelCase_       :





	def __init__(      self					: str						)						->			Dict:
				UpperCAmelCase_     : List[Any]			     =					""
				UpperCAmelCase_     : int			     =					""
				UpperCAmelCase_     : Dict			     =					[]
				UpperCAmelCase_     : int			     =					0
				UpperCAmelCase_     : List[Any]			     =					256
				UpperCAmelCase_     : Dict			     =					0
				UpperCAmelCase_     : List[Any]			     =					0
				UpperCAmelCase_     : str			     =					0
				UpperCAmelCase_     : List[str]			     =					0





	def      _SCREAMING_SNAKE_CASE      (      self					: List[str]	,	lowerCAmelCase_					: Dict						)						->			Optional[Any]:
				UpperCAmelCase_     : Dict			     =					cva.imread(lowerCAmelCase_	,	0						)
				UpperCAmelCase_     : Union[str, Any]			     =					copy.deepcopy(self.img						)
				UpperCAmelCase_     ,	UpperCAmelCase_     ,	UpperCAmelCase_     : List[Any]			     =					plt.hist(self.img.ravel()	,	256	,	[0, 256]	,	label="x"						)
				UpperCAmelCase_     : List[Any]			     =					np.sum(lowerCAmelCase_						)
				for i in range(len(lowerCAmelCase_						)						):
							UpperCAmelCase_     : List[Any]			     =					x[i] / self.k
							self.sk += prk
							UpperCAmelCase_     : Optional[Any]			     =					(self.L - 1) * self.sk
							if self.rem != 0:
										UpperCAmelCase_     : Any			     =					int(last % last						)
							UpperCAmelCase_     : List[str]			     =					int(last + 1 if self.rem >= 0.5 else last						)
							self.last_list.append(lowerCAmelCase_						)
							UpperCAmelCase_     : Optional[Any]			     =					int(np.ma.count(self.img						) / self.img[1].size						)
							UpperCAmelCase_     : Dict			     =					self.img[1].size
				for i in range(self.number_of_cols						):
							for j in range(self.number_of_rows						):
										UpperCAmelCase_     : Any			     =					self.img[j][i]
										if num != self.last_list[num]:
													UpperCAmelCase_     : Tuple			     =					self.last_list[num]
				cva.imwrite("output_data/output.jpg"	,	self.img						)





	def      _SCREAMING_SNAKE_CASE      (      self					: List[Any]						)						->			Union[str, Any]:
				plt.hist(self.img.ravel()	,	256	,	[0, 256]						)





	def      _SCREAMING_SNAKE_CASE      (      self					: Union[str, Any]						)						->			str:
				cva.imshow("Output-Image"	,	self.img						)
				cva.imshow("Input-Image"	,	self.original_image						)
				cva.waitKey(5_000						)
				cva.destroyAllWindows()


if __name__ == "__main__":
			lowerCamelCase_					=      os.path.join(os.path.basename(__file__), '''image_data/input.jpg''')
			lowerCamelCase_					=      ConstantStretch()
			stretcher.stretch(file_path)
			stretcher.plot_histogram()
			stretcher.show_image()



