

'''simple docstring'''







import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
						from test_module.custom_tokenization_fast import CustomTokenizerFast


class 					A__      (      unittest.TestCase			):



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





											'''simple docstring'''
											A_						=      0



				@slow
				def 					snake_case_			(					self       )						->      Optional[int]:





											'''simple docstring'''
											for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
																		self.assertIsNotNone(UpperCamelCase__       )
																		self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
																		self.assertGreater(len(UpperCamelCase__       )		,				0       )

											for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
																		self.assertIsNotNone(UpperCamelCase__       )
																		self.assertIsInstance(UpperCamelCase__		,				(GPTaTokenizer, GPTaTokenizerFast)       )
																		self.assertGreater(len(UpperCamelCase__       )		,				0       )



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





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
											self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
											self.assertEqual(tokenizer.vocab_size		,				12       )



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





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
											self.assertIsInstance(UpperCamelCase__		,				(RobertaTokenizer, RobertaTokenizerFast)       )
											self.assertEqual(tokenizer.vocab_size		,				20       )



				def 					snake_case_			(					self       )						->      Optional[Any]:





											'''simple docstring'''
											A_						=      AutoConfig.from_pretrained(UpperCamelCase__       )
											self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )
											# Check that tokenizer_type ≠ model_type
											A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				config=UpperCamelCase__       )
											self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
											self.assertEqual(tokenizer.vocab_size		,				12       )



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





											'''simple docstring'''
											with tempfile.TemporaryDirectory() as tmp_dir:
																		shutil.copy("""./tests/fixtures/vocab.txt"""		,				os.path.join(UpperCamelCase__		,				"""vocab.txt"""       )       )

																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""bert"""		,				use_fast=UpperCamelCase__       )
																		self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

											with tempfile.TemporaryDirectory() as tmp_dir:
																		shutil.copy("""./tests/fixtures/vocab.json"""		,				os.path.join(UpperCamelCase__		,				"""vocab.json"""       )       )
																		shutil.copy("""./tests/fixtures/merges.txt"""		,				os.path.join(UpperCamelCase__		,				"""merges.txt"""       )       )

																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""gpt2"""		,				use_fast=UpperCamelCase__       )
																		self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      Any:





											'''simple docstring'''
											with tempfile.TemporaryDirectory() as tmp_dir:
																		shutil.copy("""./tests/fixtures/vocab.txt"""		,				os.path.join(UpperCamelCase__		,				"""vocab.txt"""       )       )

																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""bert"""       )
																		self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

											with tempfile.TemporaryDirectory() as tmp_dir:
																		shutil.copy("""./tests/fixtures/vocab.json"""		,				os.path.join(UpperCamelCase__		,				"""vocab.json"""       )       )
																		shutil.copy("""./tests/fixtures/merges.txt"""		,				os.path.join(UpperCamelCase__		,				"""merges.txt"""       )       )

																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				tokenizer_type="""gpt2"""       )
																		self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



				def 					snake_case_			(					self       )						->      Dict:





											'''simple docstring'''
											with pytest.raises(UpperCamelCase__       ):
																		AutoTokenizer.from_pretrained("""./"""		,				tokenizer_type="""xxx"""       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
																		A_						=      tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""       )
																		self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )

																		if isinstance(UpperCamelCase__		,				UpperCamelCase__       ):
																									self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,				UpperCamelCase__       )
																		else:
																									self.assertEqual(tokenizer.do_lower_case		,				UpperCamelCase__       )

																		self.assertEqual(tokenizer.model_max_length		,				512       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
																		with self.assertRaisesRegex(
																		    UpperCamelCase__		,				"""julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""		,				):
																									A_						=      tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""       )



				def 					snake_case_			(					self       )						->      Optional[Any]:





											'''simple docstring'''
											A_						=      TOKENIZER_MAPPING.values()
											A_						=      []

											for slow_tok, fast_tok in tokenizers:
																		if slow_tok is not None:
																									tokenizer_names.append(slow_tok.__name__       )

																		if fast_tok is not None:
																									tokenizer_names.append(fast_tok.__name__       )

											for tokenizer_name in tokenizer_names:
																		# must find the right class
																		tokenizer_class_from_name(UpperCamelCase__       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""		,				use_fast=UpperCamelCase__       )		,				UpperCamelCase__       )
											self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""       )		,				UpperCamelCase__       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      Union[str, Any]:





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained("""distilbert-base-uncased"""		,				do_lower_case=UpperCamelCase__       )
											A_						=      """Hello, world. How are you?"""
											A_						=      tokenizer.tokenize(UpperCamelCase__       )
											self.assertEqual("""[UNK]"""		,				tokens[0]       )

											A_						=      AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""		,				do_lower_case=UpperCamelCase__       )
											A_						=      tokenizer.tokenize(UpperCamelCase__       )
											self.assertEqual("""[UNK]"""		,				tokens[0]       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""       )
											self.assertEqual(type(UpperCamelCase__       )		,				UpperCamelCase__       )
											self.assertEqual(tokenizer.model_max_length		,				512       )
											self.assertEqual(tokenizer.vocab_size		,				30000       )
											self.assertEqual(tokenizer.unk_token		,				"""[UNK]"""       )
											self.assertEqual(tokenizer.padding_side		,				"""right"""       )
											self.assertEqual(tokenizer.truncation_side		,				"""right"""       )



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





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
											self.assertIsInstance(UpperCamelCase__		,				(BertTokenizer, BertTokenizerFast)       )
											with tempfile.TemporaryDirectory() as tmp_dir:
																		tokenizer.save_pretrained(UpperCamelCase__       )
																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )

											self.assertIsInstance(UpperCamelCase__		,				tokenizer.__class__       )
											self.assertEqual(tokenizera.vocab_size		,				12       )



				def 					snake_case_			(					self       )						->      Dict:





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained("""ctrl"""       )
											# There is no fast CTRL so this always gives us a slow tokenizer.
											self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )



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





											'''simple docstring'''
											A_						=      get_tokenizer_config("""bert-base-cased"""       )
											A_						=      config.pop("""_commit_hash"""		,				UpperCamelCase__       )
											# If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
											self.assertEqual(UpperCamelCase__		,				{"""do_lower_case""": False}       )

											# This model does not have a tokenizer_config so we get back an empty dict.
											A_						=      get_tokenizer_config(UpperCamelCase__       )
											self.assertDictEqual(UpperCamelCase__		,				{}       )

											# A tokenizer saved with `save_pretrained` always creates a tokenizer config.
											A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
											with tempfile.TemporaryDirectory() as tmp_dir:
																		tokenizer.save_pretrained(UpperCamelCase__       )
																		A_						=      get_tokenizer_config(UpperCamelCase__       )

											# Check the class of the tokenizer was properly saved (note that it always saves the slow class).
											self.assertEqual(config["""tokenizer_class"""]		,				"""BertTokenizer"""       )



				def 					snake_case_			(					self       )						->      str:





											'''simple docstring'''
											try:
																		AutoConfig.register("""custom"""		,				UpperCamelCase__       )

																		AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
																		# Trying to register something existing in the Transformers library will raise an error
																		with self.assertRaises(UpperCamelCase__       ):
																									AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )

																		A_						=      CustomTokenizer.from_pretrained(UpperCamelCase__       )
																		with tempfile.TemporaryDirectory() as tmp_dir:
																									tokenizer.save_pretrained(UpperCamelCase__       )

																									A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
																									self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

											finally:
																		if "custom" in CONFIG_MAPPING._extra_content:
																									del CONFIG_MAPPING._extra_content["custom"]
																		if CustomConfig in TOKENIZER_MAPPING._extra_content:
																									del TOKENIZER_MAPPING._extra_content[CustomConfig]



				@require_tokenizers
				def 					snake_case_			(					self       )						->      Union[str, Any]:





											'''simple docstring'''
											try:
																		AutoConfig.register("""custom"""		,				UpperCamelCase__       )

																		# Can register in two steps
																		AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
																		self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, None)       )
																		AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
																		self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)       )

																		del TOKENIZER_MAPPING._extra_content[CustomConfig]
																		# Can register in one step
																		AutoTokenizer.register(
																		    UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
																		self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast)       )

																		# Trying to register something existing in the Transformers library will raise an error
																		with self.assertRaises(UpperCamelCase__       ):
																									AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )

																		# We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
																		# and that model does not have a tokenizer.json
																		with tempfile.TemporaryDirectory() as tmp_dir:
																									A_						=      BertTokenizerFast.from_pretrained(UpperCamelCase__       )
																									bert_tokenizer.save_pretrained(UpperCamelCase__       )
																									A_						=      CustomTokenizerFast.from_pretrained(UpperCamelCase__       )

																		with tempfile.TemporaryDirectory() as tmp_dir:
																									tokenizer.save_pretrained(UpperCamelCase__       )

																									A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__       )
																									self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

																									A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																									self.assertIsInstance(UpperCamelCase__		,				UpperCamelCase__       )

											finally:
																		if "custom" in CONFIG_MAPPING._extra_content:
																									del CONFIG_MAPPING._extra_content["custom"]
																		if CustomConfig in TOKENIZER_MAPPING._extra_content:
																									del TOKENIZER_MAPPING._extra_content[CustomConfig]



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





											'''simple docstring'''
											# If remote code is not set, we will time out when asking whether to load the model.
											with self.assertRaises(UpperCamelCase__       ):
																		A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""       )
											# If remote code is disabled, we can't load this config.
											with self.assertRaises(UpperCamelCase__       ):
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )

											A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
											self.assertTrue(tokenizer.special_attribute_present       )
											# Test tokenizer can be reloaded.
											with tempfile.TemporaryDirectory() as tmp_dir:
																		tokenizer.save_pretrained(UpperCamelCase__       )
																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				trust_remote_code=UpperCamelCase__       )
											self.assertTrue(reloaded_tokenizer.special_attribute_present       )

											if is_tokenizers_available():
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
																		self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )

																		# Test we can also load the slow version
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																		self.assertTrue(tokenizer.special_attribute_present       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		# Test tokenizer can be reloaded.
																		with tempfile.TemporaryDirectory() as tmp_dir:
																									tokenizer.save_pretrained(UpperCamelCase__       )
																									A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																		self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		self.assertTrue(reloaded_tokenizer.special_attribute_present       )
											else:
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		self.assertEqual(reloaded_tokenizer.__class__.__name__		,				"""NewTokenizer"""       )



				@require_tokenizers
				def 					snake_case_			(					self       )						->      Any:





											'''simple docstring'''


											class 					A__      (      _snake_case			):
															lowercase						=		False


											class 					A__      (      _snake_case			):
															lowercase						=		NewTokenizer
															lowercase						=		False

											try:
																		AutoConfig.register("""custom"""		,				UpperCamelCase__       )
																		AutoTokenizer.register(UpperCamelCase__		,				slow_tokenizer_class=UpperCamelCase__       )
																		AutoTokenizer.register(UpperCamelCase__		,				fast_tokenizer_class=UpperCamelCase__       )
																		# If remote code is not set, the default is to use local
																		A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
																		self.assertFalse(tokenizer.special_attribute_present       )
																		A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,				use_fast=UpperCamelCase__       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		self.assertFalse(tokenizer.special_attribute_present       )

																		# If remote code is disabled, we load the local one.
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
																		self.assertFalse(tokenizer.special_attribute_present       )
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		self.assertFalse(tokenizer.special_attribute_present       )

																		# If remote is enabled, we load from the Hub
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )
																		self.assertTrue(tokenizer.special_attribute_present       )
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
																		self.assertTrue(tokenizer.special_attribute_present       )

											finally:
																		if "custom" in CONFIG_MAPPING._extra_content:
																									del CONFIG_MAPPING._extra_content["custom"]
																		if CustomConfig in TOKENIZER_MAPPING._extra_content:
																									del TOKENIZER_MAPPING._extra_content[CustomConfig]



				def 					snake_case_			(					self       )						->      Any:





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained(
											    """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,				trust_remote_code=UpperCamelCase__       )
											self.assertTrue(tokenizer.special_attribute_present       )
											if is_tokenizers_available():
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizerFast"""       )

																		# Test we can also load the slow version
																		A_						=      AutoTokenizer.from_pretrained(
																		    """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,				trust_remote_code=UpperCamelCase__		,				use_fast=UpperCamelCase__       )
																		self.assertTrue(tokenizer.special_attribute_present       )
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )
											else:
																		self.assertEqual(tokenizer.__class__.__name__		,				"""NewTokenizer"""       )



				def 					snake_case_			(					self       )						->      List[str]:





											'''simple docstring'''
											with self.assertRaisesRegex(
											    UpperCamelCase__		,				"""bert-base is not a local folder and is not a valid model identifier"""       ):
																		A_						=      AutoTokenizer.from_pretrained("""bert-base"""       )



				def 					snake_case_			(					self       )						->      Optional[Any]:





											'''simple docstring'''
											with self.assertRaisesRegex(
											    UpperCamelCase__		,				R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""       ):
																		A_						=      AutoTokenizer.from_pretrained(UpperCamelCase__		,				revision="""aaaaaa"""       )







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





											'''simple docstring'''
											A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
											with RequestCounter() as counter:
																		A_						=      AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""       )
																		self.assertEqual(counter.get_request_count		,				0       )
																		self.assertEqual(counter.head_request_count		,				1       )
																		self.assertEqual(counter.other_request_count		,				0       )



'''simple docstring'''







import numpy as np
from cva import COLOR_BGR2GRAY, cvtColor, imread
from numpy import array, uinta
from PIL import Image

from digital_image_processing import change_contrast as cc
from digital_image_processing import convert_to_negative as cn
from digital_image_processing import sepia as sp
from digital_image_processing.dithering import burkes as bs
from digital_image_processing.edge_detection import canny
from digital_image_processing.filters import convolve as conv
from digital_image_processing.filters import gaussian_filter as gg
from digital_image_processing.filters import local_binary_pattern as lbp
from digital_image_processing.filters import median_filter as med
from digital_image_processing.filters import sobel_filter as sob
from digital_image_processing.resize import resize as rs

__lowerCamelCase		       =    imread(r'''digital_image_processing/image_data/lena_small.jpg''')
__lowerCamelCase		       =    cvtColor(img, COLOR_BGR2GRAY)
def       UpperCAmelCase__    (      )			->			Dict:
       A_						=      cn.convert_to_negative(UpperCAmelCase__				)
       # assert negative_img array for at least one True
       assert negative_img.any()
def       UpperCAmelCase__    (      )			->			List[Any]:
       with Image.open("""digital_image_processing/image_data/lena_small.jpg"""				) as img:
              # Work around assertion for response
              assert str(cc.change_contrast(UpperCAmelCase__,       1_10				)				).startswith(
                  """<PIL.Image.Image image mode=RGB size=100x100 at"""				)
def       UpperCAmelCase__    (      )			->			str:
       A_						=      canny.gen_gaussian_kernel(9,       sigma=1.4				)
       # Assert ambiguous array
       assert resp.all()
def       UpperCAmelCase__    (      )			->			Union[str, Any]:
       A_						=      imread("""digital_image_processing/image_data/lena_small.jpg""",       0				)
       # assert ambiguous array for all == True
       assert canny_img.all()
       A_						=      canny.canny(UpperCAmelCase__				)
       # assert canny array for at least one True
       assert canny_array.any()
def       UpperCAmelCase__    (      )			->			Dict:
       assert gg.gaussian_filter(UpperCAmelCase__,       5,       sigma=0.9				).all()
def       UpperCAmelCase__    (      )			->			int:
       # laplace diagonals
       A_						=      array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]				)
       A_						=      conv.img_convolve(UpperCAmelCase__,       UpperCAmelCase__				).astype(UpperCAmelCase__				)
       assert res.any()
def       UpperCAmelCase__    (      )			->			List[Any]:
       assert med.median_filter(UpperCAmelCase__,       3				).any()
def       UpperCAmelCase__    (      )			->			List[Any]:
       A_					,			A_						=      sob.sobel_filter(UpperCAmelCase__				)
       assert grad.any() and theta.any()
def       UpperCAmelCase__    (      )			->			List[str]:
       A_						=      sp.make_sepia(UpperCAmelCase__,       20				)
       assert sepia.all()
def       UpperCAmelCase__    (      UpperCAmelCase__ = "digital_image_processing/image_data/lena_small.jpg"				)			->			List[Any]:
       A_						=      bs.Burkes(imread(UpperCAmelCase__,       1				),       1_20				)
       burkes.process()
       assert burkes.output_img.any()
def       UpperCAmelCase__    (      UpperCAmelCase__ = "digital_image_processing/image_data/lena_small.jpg",       )			->			Optional[int]:
       A_						=      rs.NearestNeighbour(imread(UpperCAmelCase__,       1				),       4_00,       2_00				)
       nn.process()
       assert nn.output.any()







def       UpperCAmelCase__    (      )			->			Optional[int]:
       A_						=      """digital_image_processing/image_data/lena.jpg"""

       # Reading the image and converting it to grayscale.
       A_						=      imread(UpperCAmelCase__,       0				)

       # Test for get_neighbors_pixel function() return not None
       A_						=      0
       A_						=      0
       A_						=      image[x_coordinate][y_coordinate]

       A_						=      lbp.get_neighbors_pixel(
           UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)

       assert neighbors_pixels is not None

       # Test for local_binary_pattern function()
       # Create a numpy array as the same height and width of read image
       A_						=      np.zeros((image.shape[0], image.shape[1])				)

       # Iterating through the image and calculating the local binary pattern value
       # for each pixel.
       for i in range(0,       image.shape[0]				):
              for j in range(0,       image.shape[1]				):
                     A_						=      lbp.local_binary_value(UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)

       assert lbp_image.any()
