code: 
  
  
  
  
  
  # This model implementation is heavily based on:
  
  import gc
  import random
  import tempfile
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      ControlNetModel,
      DDIMScheduler,
      StableDiffusionControlNetInpaintPipeline,
      UNetaDConditionModel,
  )
  from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
  from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
  from diffusers.utils.import_utils import is_xformers_available
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import (
      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
      TEXT_TO_IMAGE_IMAGE_PARAMS,
  )
  from ..test_pipelines_common import (
      PipelineKarrasSchedulerTesterMixin,
      PipelineLatentTesterMixin,
      PipelineTesterMixin,
  )
  
  
  enable_full_determinism()
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__		,       UpperCamelCase__		,       UpperCamelCase__		,       unittest.TestCase):
        _lowercase       :      Tuple        =    StableDiffusionControlNetInpaintPipeline
        _lowercase       :      int        =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
        _lowercase       :      str        =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
        _lowercase       :      List[Any]        =    frozenset({"""control_image"""})  # skip `image` and `mask` for now, only test for control_image
        _lowercase       :      str        =    TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		List[str]:
  
  
  
          '''simple docstring'''
  
  
  
  
          torch.manual_seed(0							)
          a__			:      Tuple            =UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   sample_size=3_2	,   in_channels=9	,   out_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")	,   cross_attention_dim=3_2	,   )
          torch.manual_seed(0							)
          a__			:      Any            =ControlNetModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   in_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   cross_attention_dim=3_2	,   conditioning_embedding_out_channels=(1_6, 3_2)	,   )
          torch.manual_seed(0							)
          a__			:      Dict            =DDIMScheduler(
              beta_start=0.0_00_85	,   beta_end=0.0_12	,   beta_schedule="scaled_linear"	,   clip_sample=lowerCAmelCase__	,   set_alpha_to_one=lowerCAmelCase__	,   )
          torch.manual_seed(0							)
          a__			:      List[Any]            =AutoencoderKL(
              block_out_channels=[3_2, 6_4]	,   in_channels=3	,   out_channels=3	,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]	,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]	,   latent_channels=4	,   )
          torch.manual_seed(0							)
          a__			:      Union[str, Any]            =CLIPTextConfig(
              bos_token_id=0	,   eos_token_id=2	,   hidden_size=3_2	,   intermediate_size=3_7	,   layer_norm_eps=1E-05	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1_0_0_0	,   )
          a__			:      str            =CLIPTextModel(lowerCAmelCase__							)
          a__			:      List[Any]            =CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)
  
          a__			:      List[str]            ={
              "unet": unet,
              "controlnet": controlnet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          return components
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=0							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          if str(lowerCAmelCase__							).startswith("mps"							):
            a__			:      int            =torch.manual_seed(lowerCAmelCase__							)
          else:
            a__			:      List[str]            =torch.Generator(device=lowerCAmelCase__							).manual_seed(lowerCAmelCase__							)
  
          a__			:      Optional[int]            =2
          a__			:      str            =randn_tensor(
              (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,   generator=lowerCAmelCase__	,   device=torch.device(lowerCAmelCase__							)	,   )
          a__			:      List[Any]            =floats_tensor((1, 3, 3_2, 3_2)	,   rng=random.Random(lowerCAmelCase__							)							).to(lowerCAmelCase__							)
          a__			:      List[Any]            =init_image.cpu().permute(0	,   2	,   3	,   1							)[0]
  
          a__			:      Tuple            =Image.fromarray(np.uinta(lowerCAmelCase__							)							).convert("RGB"							).resize((6_4, 6_4)							)
          a__			:      Union[str, Any]            =Image.fromarray(np.uinta(init_image + 4							)							).convert("RGB"							).resize((6_4, 6_4)							)
  
          a__			:      Optional[Any]            ={
              "prompt": "A painting of a squirrel eating a burger",
              "generator": generator,
              "num_inference_steps": 2,
              "guidance_scale": 6.0,
              "output_type": "numpy",
              "image": image,
              "mask_image": mask_image,
              "control_image": control_image,
          }
  
          return inputs
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		List[str]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
        @unittest.skipIf(
            torch_device != "cuda" or not is_xformers_available()	,   reason="XFormers attention is only available with CUDA and `xformers` installed"	,   )
        def      _lowercase						(					self							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          self._test_inference_batch_single_identical(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__):
        _lowercase       :      Optional[int]        =    StableDiffusionControlNetInpaintPipeline
        _lowercase       :      Optional[Any]        =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
        _lowercase       :      Optional[Any]        =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
        _lowercase       :      Optional[Any]        =    frozenset([])
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Optional[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          torch.manual_seed(0							)
          a__			:      Tuple            =UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   sample_size=3_2	,   in_channels=4	,   out_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")	,   cross_attention_dim=3_2	,   )
          torch.manual_seed(0							)
          a__			:      str            =ControlNetModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   in_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   cross_attention_dim=3_2	,   conditioning_embedding_out_channels=(1_6, 3_2)	,   )
          torch.manual_seed(0							)
          a__			:      Optional[int]            =DDIMScheduler(
              beta_start=0.0_00_85	,   beta_end=0.0_12	,   beta_schedule="scaled_linear"	,   clip_sample=lowerCAmelCase__	,   set_alpha_to_one=lowerCAmelCase__	,   )
          torch.manual_seed(0							)
          a__			:      Dict            =AutoencoderKL(
              block_out_channels=[3_2, 6_4]	,   in_channels=3	,   out_channels=3	,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]	,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]	,   latent_channels=4	,   )
          torch.manual_seed(0							)
          a__			:      Union[str, Any]            =CLIPTextConfig(
              bos_token_id=0	,   eos_token_id=2	,   hidden_size=3_2	,   intermediate_size=3_7	,   layer_norm_eps=1E-05	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1_0_0_0	,   )
          a__			:      Optional[int]            =CLIPTextModel(lowerCAmelCase__							)
          a__			:      Optional[int]            =CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)
  
          a__			:      str            ={
              "unet": unet,
              "controlnet": controlnet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          return components
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__		,       UpperCamelCase__		,       unittest.TestCase):
        _lowercase       :      Tuple        =    StableDiffusionControlNetInpaintPipeline
        _lowercase       :      Dict        =    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
        _lowercase       :      int        =    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Union[str, Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          torch.manual_seed(0							)
          a__			:      str            =UNetaDConditionModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   sample_size=3_2	,   in_channels=9	,   out_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")	,   cross_attention_dim=3_2	,   )
          torch.manual_seed(0							)
  
          def init_weights(lowerCAmelCase__							):
            if isinstance(lowerCAmelCase__	,   torch.nn.Convad							):
              torch.nn.init.normal(m.weight							)
              m.bias.data.fill_(1.0							)
  
          a__			:      List[str]            =ControlNetModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   in_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   cross_attention_dim=3_2	,   conditioning_embedding_out_channels=(1_6, 3_2)	,   )
          controlneta.controlnet_down_blocks.apply(lowerCAmelCase__							)
  
          torch.manual_seed(0							)
          a__			:      Union[str, Any]            =ControlNetModel(
              block_out_channels=(3_2, 6_4)	,   layers_per_block=2	,   in_channels=4	,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")	,   cross_attention_dim=3_2	,   conditioning_embedding_out_channels=(1_6, 3_2)	,   )
          controlneta.controlnet_down_blocks.apply(lowerCAmelCase__							)
  
          torch.manual_seed(0							)
          a__			:      Union[str, Any]            =DDIMScheduler(
              beta_start=0.0_00_85	,   beta_end=0.0_12	,   beta_schedule="scaled_linear"	,   clip_sample=lowerCAmelCase__	,   set_alpha_to_one=lowerCAmelCase__	,   )
          torch.manual_seed(0							)
          a__			:      Optional[Any]            =AutoencoderKL(
              block_out_channels=[3_2, 6_4]	,   in_channels=3	,   out_channels=3	,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]	,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]	,   latent_channels=4	,   )
          torch.manual_seed(0							)
          a__			:      Optional[Any]            =CLIPTextConfig(
              bos_token_id=0	,   eos_token_id=2	,   hidden_size=3_2	,   intermediate_size=3_7	,   layer_norm_eps=1E-05	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1_0_0_0	,   )
          a__			:      List[str]            =CLIPTextModel(lowerCAmelCase__							)
          a__			:      List[Any]            =CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"							)
  
          a__			:      Union[str, Any]            =MultiControlNetModel([controlneta, controlneta]							)
  
          a__			:      int            ={
              "unet": unet,
              "controlnet": controlnet,
              "scheduler": scheduler,
              "vae": vae,
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "safety_checker": None,
              "feature_extractor": None,
          }
          return components
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=0							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          if str(lowerCAmelCase__							).startswith("mps"							):
            a__			:      List[str]            =torch.manual_seed(lowerCAmelCase__							)
          else:
            a__			:      Optional[Any]            =torch.Generator(device=lowerCAmelCase__							).manual_seed(lowerCAmelCase__							)
  
          a__			:      List[str]            =2
  
          a__			:      Optional[int]            =[
              randn_tensor(
                  (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,   generator=lowerCAmelCase__	,   device=torch.device(lowerCAmelCase__							)	,   ),
              randn_tensor(
                  (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,   generator=lowerCAmelCase__	,   device=torch.device(lowerCAmelCase__							)	,   ),
          ]
          a__			:      List[str]            =floats_tensor((1, 3, 3_2, 3_2)	,   rng=random.Random(lowerCAmelCase__							)							).to(lowerCAmelCase__							)
          a__			:      Dict            =init_image.cpu().permute(0	,   2	,   3	,   1							)[0]
  
          a__			:      int            =Image.fromarray(np.uinta(lowerCAmelCase__							)							).convert("RGB"							).resize((6_4, 6_4)							)
          a__			:      str            =Image.fromarray(np.uinta(init_image + 4							)							).convert("RGB"							).resize((6_4, 6_4)							)
  
          a__			:      Optional[Any]            ={
              "prompt": "A painting of a squirrel eating a burger",
              "generator": generator,
              "num_inference_steps": 2,
              "guidance_scale": 6.0,
              "output_type": "numpy",
              "image": image,
              "mask_image": mask_image,
              "control_image": control_image,
          }
  
          return inputs
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Tuple            =self.get_dummy_components()
          a__			:      Union[str, Any]            =self.pipeline_class(**lowerCAmelCase__							)
          pipe.to(lowerCAmelCase__							)
  
          a__			:      int            =10.0
          a__			:      int            =4
  
          a__			:      Dict            =self.get_dummy_inputs(lowerCAmelCase__							)
          a__			:      int            =steps
          a__			:      List[Any]            =scale
          a__			:      Tuple            =pipe(**lowerCAmelCase__							)[0]
  
          a__			:      Dict            =self.get_dummy_inputs(lowerCAmelCase__							)
          a__			:      Dict            =steps
          a__			:      int            =scale
          a__			:      int            =pipe(**lowerCAmelCase__	,   control_guidance_start=0.1	,   control_guidance_end=0.2							)[0]
  
          a__			:      Tuple            =self.get_dummy_inputs(lowerCAmelCase__							)
          a__			:      Optional[Any]            =steps
          a__			:      List[Any]            =scale
          a__			:      int            =pipe(**lowerCAmelCase__	,   control_guidance_start=[0.1, 0.3]	,   control_guidance_end=[0.2, 0.7]							)[0]
  
          a__			:      Any            =self.get_dummy_inputs(lowerCAmelCase__							)
          a__			:      int            =steps
          a__			:      Dict            =scale
          a__			:      Union[str, Any]            =pipe(**lowerCAmelCase__	,   control_guidance_start=0.4	,   control_guidance_end=[0.5, 0.8]							)[0]
  
          # make sure that all outputs are different
          assert np.sum(np.abs(output_a - output_a							)							) > 1E-3
          assert np.sum(np.abs(output_a - output_a							)							) > 1E-3
          assert np.sum(np.abs(output_a - output_a							)							) > 1E-3
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
        @unittest.skipIf(
            torch_device != "cuda" or not is_xformers_available()	,   reason="XFormers attention is only available with CUDA and `xformers` installed"	,   )
        def      _lowercase						(					self							)     ->		Dict:
  
  
  
          '''simple docstring'''
  
  
  
  
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          self._test_inference_batch_single_identical(expected_max_diff=2E-3							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Union[str, Any]            =self.get_dummy_components()
          a__			:      Optional[Any]            =self.pipeline_class(**lowerCAmelCase__							)
          pipe.to(lowerCAmelCase__							)
          pipe.set_progress_bar_config(disable=lowerCAmelCase__							)
          with tempfile.TemporaryDirectory() as tmpdir:
            try:
              # save_pretrained is not implemented for Multi-ControlNet
              pipe.save_pretrained(lowerCAmelCase__							)
            except NotImplementedError:
              pass
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class        __lowerCAmelCase (					unittest.TestCase):
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Dict:
  
  
  
          '''simple docstring'''
  
  
  
  
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Optional[int]            =ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny"							)
  
          a__			:      Dict            =StableDiffusionControlNetInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-inpainting"	,   safety_checker=lowerCAmelCase__	,   controlnet=lowerCAmelCase__							)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=lowerCAmelCase__							)
  
          a__			:      int            =torch.Generator(device="cpu"							).manual_seed(0							)
          a__			:      List[Any]            =load_image(
              "https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"							).resize((5_1_2, 5_1_2)							)
  
          a__			:      Union[str, Any]            =load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
              "/stable_diffusion_inpaint/input_bench_mask.png"							).resize((5_1_2, 5_1_2)							)
  
          a__			:      Optional[Any]            ="pitch black hole"
  
          a__			:      Tuple            =load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"							).resize((5_1_2, 5_1_2)							)
  
          a__			:      List[str]            =pipe(
              lowerCAmelCase__	,   image=lowerCAmelCase__	,   mask_image=lowerCAmelCase__	,   control_image=lowerCAmelCase__	,   generator=lowerCAmelCase__	,   output_type="np"	,   num_inference_steps=3	,   )
  
          a__			:      Tuple            =output.images[0]
  
          assert image.shape == (5_1_2, 5_1_2, 3)
  
          a__			:      List[Any]            =load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"							)
  
          assert np.abs(expected_image - image							).max() < 9E-2
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Any            =ControlNetModel.from_pretrained("lllyasviel/control_v11p_sd15_inpaint"							)
  
          a__			:      Tuple            =StableDiffusionControlNetInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-v1-5"	,   safety_checker=lowerCAmelCase__	,   controlnet=lowerCAmelCase__							)
          a__			:      Optional[int]            =DDIMScheduler.from_config(pipe.scheduler.config							)
          pipe.enable_model_cpu_offload()
          pipe.set_progress_bar_config(disable=lowerCAmelCase__							)
  
          a__			:      int            =torch.Generator(device="cpu"							).manual_seed(3_3							)
  
          a__			:      Any            =load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"							)
          a__			:      Union[str, Any]            =init_image.resize((5_1_2, 5_1_2)							)
  
          a__			:      List[str]            =load_image(
              "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"							)
          a__			:      Optional[Any]            =mask_image.resize((5_1_2, 5_1_2)							)
  
          a__			:      str            ="a handsome man with ray-ban sunglasses"
  
          def make_inpaint_condition(lowerCAmelCase__	,   lowerCAmelCase__							):
            a__			:      List[Any]            =np.array(image.convert("RGB"							)							).astype(np.floataa							) / 2_55.0
            a__			:      str            =np.array(image_mask.convert("L"							)							).astype(np.floataa							) / 2_55.0
  
            assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
            a__			:      Any            =-1.0  # set as masked pixel
            a__			:      int            =np.expand_dims(lowerCAmelCase__	,   0							).transpose(0	,   3	,   1	,   2							)
            a__			:      Tuple            =torch.from_numpy(lowerCAmelCase__							)
            return image
  
          a__			:      List[str]            =make_inpaint_condition(lowerCAmelCase__	,   lowerCAmelCase__							)
  
          a__			:      int            =pipe(
              lowerCAmelCase__	,   image=lowerCAmelCase__	,   mask_image=lowerCAmelCase__	,   control_image=lowerCAmelCase__	,   guidance_scale=9.0	,   eta=1.0	,   generator=lowerCAmelCase__	,   num_inference_steps=2_0	,   output_type="np"	,   )
          a__			:      Dict            =output.images[0]
  
          assert image.shape == (5_1_2, 5_1_2, 3)
  
          a__			:      Tuple            =load_numpy(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"							)
  
          assert np.abs(expected_image - image							).max() < 9E-2
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  def   _A (	SCREAMING_SNAKE_CASE  :     int		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    barcode //= 10  # exclude the last digit
    a__			:      int            =False
    a__			:      List[str]            =0
  
    # extract and check each digit
    while barcode != 0:
      a__			:      Optional[Any]            =1 if checker else 3
      s += mult * (barcode % 10)
      barcode //= 10
      a__			:      Union[str, Any]            =not checker
  
    return (10 - (s % 10)) % 10
  def   _A (	SCREAMING_SNAKE_CASE  :     int		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    return len(str(SCREAMING_SNAKE_CASE		)		) == 13 and get_check_digit(SCREAMING_SNAKE_CASE		) == barcode % 10
  def   _A (	SCREAMING_SNAKE_CASE  :     str		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    if str(SCREAMING_SNAKE_CASE		).isalpha():
      a__			:      Tuple            =f'''Barcode \'{barcode}\' has alphabetic characters.'''
      raise ValueError(SCREAMING_SNAKE_CASE		)
    elif int(SCREAMING_SNAKE_CASE		) < 0:
      raise ValueError("The entered barcode has a negative value. Try again."		)
    else:
      return int(SCREAMING_SNAKE_CASE		)
  
  
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod()
       UpperCAmelCase			:			List[str]	  = get_barcode(input("""Barcode: """).strip())
  
       if is_valid(barcode):
            print(F"""'{barcode}' is a valid barcode.""")
       else:
            print(F"""'{barcode}' is NOT a valid barcode.""")
  
  
  
  
  
  
  