





'''simple docstring'''

import argparse

import torch

from diffusers import UNetaDConditionModel





def lowerCamelCase						(					__lowerCamelCase			:   Any ,	__lowerCamelCase			:   List[str] ,	__lowerCamelCase			:   Any ,	__lowerCamelCase			:   List[Any]=None ,	__lowerCamelCase			:   int=None ,	__lowerCamelCase			:   Any=None   )						->Any:
    assert isinstance(__lowerCamelCase ,	__lowerCamelCase   ), "Paths should be a list of dicts containing 'old' and 'new' keys."

    # Splits the attention layers into three variables.
    if attention_paths_to_split is not None:
        for path, path_map in attention_paths_to_split.items():
            _SCREAMING_SNAKE_CASE     =      old_checkpoint[path]
            _SCREAMING_SNAKE_CASE     =      old_tensor.shape[0] // 3

            _SCREAMING_SNAKE_CASE     =      (-1, channels) if len(old_tensor.shape   ) == 3 else (-1)

            _SCREAMING_SNAKE_CASE     =      old_tensor.shape[0] // config["""num_head_channels"""] // 3

            _SCREAMING_SNAKE_CASE     =      old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]   )
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      old_tensor.split(channels // num_heads ,	dim=1   )

            _SCREAMING_SNAKE_CASE     =      query.reshape(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      key.reshape(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      value.reshape(__lowerCamelCase   )

    for path in paths:
        _SCREAMING_SNAKE_CASE     =      path["""new"""]

        # These have already been assigned
        if attention_paths_to_split is not None and new_path in attention_paths_to_split:
            continue

        if additional_replacements is not None:
            for replacement in additional_replacements:
                _SCREAMING_SNAKE_CASE     =      new_path.replace(replacement["""old"""] ,	replacement["""new"""]   )

        # proj_attn.weight has to be converted from conv 1D to linear
        _SCREAMING_SNAKE_CASE     =      old_checkpoint[path["""old"""]]
        _SCREAMING_SNAKE_CASE     =      ["""proj_attn.weight"""]
        _SCREAMING_SNAKE_CASE     =      ["""proj_out.weight""", """proj_in.weight"""]
        if any(k in new_path for k in names   ):
            _SCREAMING_SNAKE_CASE     =      weight[:, :, 0]
        elif any(k in new_path for k in names_a   ) and len(weight.shape   ) > 2 and ".attentions." not in new_path:
            _SCREAMING_SNAKE_CASE     =      weight[:, :, 0]
        else:
            _SCREAMING_SNAKE_CASE     =      weight





def lowerCamelCase						(					__lowerCamelCase			:   str ,	__lowerCamelCase			:   int=0   )						->List[str]:
    _SCREAMING_SNAKE_CASE     =      []
    for old_item in old_list:
        _SCREAMING_SNAKE_CASE     =      old_item

        #         new_item = new_item.replace('norm.weight', 'group_norm.weight')
        #         new_item = new_item.replace('norm.bias', 'group_norm.bias')

        #         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
        #         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

        #         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

        mapping.append({"""old""": old_item, """new""": new_item}   )

    return mapping





def lowerCamelCase						(					__lowerCamelCase			:   Dict ,	__lowerCamelCase			:   str=1   )						->Tuple:
    if n_shave_prefix_segments >= 0:
        return ".".join(path.split("""."""   )[n_shave_prefix_segments:]   )
    else:
        return ".".join(path.split("""."""   )[:n_shave_prefix_segments]   )





def lowerCamelCase						(					__lowerCamelCase			:   int ,	__lowerCamelCase			:   Optional[Any]=0   )						->Optional[int]:
    _SCREAMING_SNAKE_CASE     =      []
    for old_item in old_list:
        mapping.append({"""old""": old_item, """new""": old_item}   )

    return mapping





def lowerCamelCase						(					__lowerCamelCase			:   str ,	__lowerCamelCase			:   Dict=0   )						->str:
    _SCREAMING_SNAKE_CASE     =      []
    for old_item in old_list:
        _SCREAMING_SNAKE_CASE     =      old_item.replace("""in_layers.0""" ,	"""norm1"""   )
        _SCREAMING_SNAKE_CASE     =      new_item.replace("""in_layers.2""" ,	"""conv1"""   )

        _SCREAMING_SNAKE_CASE     =      new_item.replace("""out_layers.0""" ,	"""norm2"""   )
        _SCREAMING_SNAKE_CASE     =      new_item.replace("""out_layers.3""" ,	"""conv2"""   )

        _SCREAMING_SNAKE_CASE     =      new_item.replace("""emb_layers.1""" ,	"""time_emb_proj"""   )
        _SCREAMING_SNAKE_CASE     =      new_item.replace("""skip_connection""" ,	"""conv_shortcut"""   )

        _SCREAMING_SNAKE_CASE     =      shave_segments(__lowerCamelCase ,	n_shave_prefix_segments=__lowerCamelCase   )

        if "temopral_conv" not in old_item:
            mapping.append({"""old""": old_item, """new""": new_item}   )

    return mapping





def lowerCamelCase						(					__lowerCamelCase			:   List[Any] ,	__lowerCamelCase			:   List[Any] ,	__lowerCamelCase			:   List[Any]=None ,	__lowerCamelCase			:   Optional[Any]=False   )						->List[Any]:
    _SCREAMING_SNAKE_CASE     =      {}
    _SCREAMING_SNAKE_CASE     =      list(checkpoint.keys()   )

    _SCREAMING_SNAKE_CASE     =      """model.diffusion_model."""

    # at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
    if sum(k.startswith("""model_ema"""   ) for k in keys   ) > 100 and extract_ema:
        print(F'Checkpoint {path} has both EMA and non-EMA weights.'   )
        print(
            """In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"""
            """ weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."""   )
        for key in keys:
            if key.startswith("""model.diffusion_model"""   ):
                _SCREAMING_SNAKE_CASE     =      """model_ema.""" + """""".join(key.split("""."""   )[1:]   )
                _SCREAMING_SNAKE_CASE     =      checkpoint.pop(__lowerCamelCase   )
    else:
        if sum(k.startswith("""model_ema"""   ) for k in keys   ) > 100:
            print(
                """In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"""
                """ weights (usually better for inference), please make sure to add the `--extract_ema` flag."""   )

        for key in keys:
            _SCREAMING_SNAKE_CASE     =      checkpoint.pop(__lowerCamelCase   )

    _SCREAMING_SNAKE_CASE     =      {}

    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""time_embed.0.weight"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""time_embed.0.bias"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""time_embed.2.weight"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""time_embed.2.bias"""]

    if config["class_embed_type"] is None:
        # No parameters to port
        ...
    elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
        _SCREAMING_SNAKE_CASE     =      unet_state_dict["""label_emb.0.0.weight"""]
        _SCREAMING_SNAKE_CASE     =      unet_state_dict["""label_emb.0.0.bias"""]
        _SCREAMING_SNAKE_CASE     =      unet_state_dict["""label_emb.0.2.weight"""]
        _SCREAMING_SNAKE_CASE     =      unet_state_dict["""label_emb.0.2.bias"""]
    else:
        raise NotImplementedError(F'Not implemented `class_embed_type`: {config["class_embed_type"]}'   )

    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""input_blocks.0.0.weight"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""input_blocks.0.0.bias"""]

    _SCREAMING_SNAKE_CASE     =      [v for v in unet_state_dict if v.startswith("""input_blocks.0.1"""   )]
    _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """input_blocks.0.1""", """new""": """transformer_in"""}
    assign_to_checkpoint(__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""out.0.weight"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""out.0.bias"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""out.2.weight"""]
    _SCREAMING_SNAKE_CASE     =      unet_state_dict["""out.2.bias"""]

    # Retrieves the keys for the input blocks only
    _SCREAMING_SNAKE_CASE     =      len({""".""".join(layer.split("""."""   )[:2]   ) for layer in unet_state_dict if """input_blocks""" in layer}   )
    _SCREAMING_SNAKE_CASE     =      {
        layer_id: [key for key in unet_state_dict if F'input_blocks.{layer_id}' in key]
        for layer_id in range(__lowerCamelCase   )
    }

    # Retrieves the keys for the middle blocks only
    _SCREAMING_SNAKE_CASE     =      len({""".""".join(layer.split("""."""   )[:2]   ) for layer in unet_state_dict if """middle_block""" in layer}   )
    _SCREAMING_SNAKE_CASE     =      {
        layer_id: [key for key in unet_state_dict if F'middle_block.{layer_id}' in key]
        for layer_id in range(__lowerCamelCase   )
    }

    # Retrieves the keys for the output blocks only
    _SCREAMING_SNAKE_CASE     =      len({""".""".join(layer.split("""."""   )[:2]   ) for layer in unet_state_dict if """output_blocks""" in layer}   )
    _SCREAMING_SNAKE_CASE     =      {
        layer_id: [key for key in unet_state_dict if F'output_blocks.{layer_id}' in key]
        for layer_id in range(__lowerCamelCase   )
    }

    for i in range(1 ,	__lowerCamelCase   ):
        _SCREAMING_SNAKE_CASE     =      (i - 1) // (config["""layers_per_block"""] + 1)
        _SCREAMING_SNAKE_CASE     =      (i - 1) % (config["""layers_per_block"""] + 1)

        _SCREAMING_SNAKE_CASE     =      [
            key for key in input_blocks[i] if F'input_blocks.{i}.0' in key and F'input_blocks.{i}.0.op' not in key
        ]
        _SCREAMING_SNAKE_CASE     =      [key for key in input_blocks[i] if F'input_blocks.{i}.1' in key]
        _SCREAMING_SNAKE_CASE     =      [key for key in input_blocks[i] if F'input_blocks.{i}.2' in key]

        if F'input_blocks.{i}.op.weight' in unet_state_dict:
            _SCREAMING_SNAKE_CASE     =      unet_state_dict.pop(
                F'input_blocks.{i}.op.weight'   )
            _SCREAMING_SNAKE_CASE     =      unet_state_dict.pop(
                F'input_blocks.{i}.op.bias'   )

        _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase   )
        _SCREAMING_SNAKE_CASE     =      {"""old""": F'input_blocks.{i}.0', """new""": F'down_blocks.{block_id}.resnets.{layer_in_block_id}'}
        assign_to_checkpoint(
            __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

        _SCREAMING_SNAKE_CASE     =      [key for key in resnets if """temopral_conv""" in key]
        _SCREAMING_SNAKE_CASE     =      renew_temp_conv_paths(__lowerCamelCase   )
        _SCREAMING_SNAKE_CASE     =      {
            """old""": F'input_blocks.{i}.0.temopral_conv',
            """new""": F'down_blocks.{block_id}.temp_convs.{layer_in_block_id}',
        }
        assign_to_checkpoint(
            __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

        if len(__lowerCamelCase   ):
            _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      {"""old""": F'input_blocks.{i}.1', """new""": F'down_blocks.{block_id}.attentions.{layer_in_block_id}'}
            assign_to_checkpoint(
                __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

        if len(__lowerCamelCase   ):
            _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      {
                """old""": F'input_blocks.{i}.2',
                """new""": F'down_blocks.{block_id}.temp_attentions.{layer_in_block_id}',
            }
            assign_to_checkpoint(
                __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

    _SCREAMING_SNAKE_CASE     =      middle_blocks[0]
    _SCREAMING_SNAKE_CASE     =      [key for key in resnet_a if """temopral_conv""" in key]
    _SCREAMING_SNAKE_CASE     =      middle_blocks[1]
    _SCREAMING_SNAKE_CASE     =      middle_blocks[2]
    _SCREAMING_SNAKE_CASE     =      middle_blocks[3]
    _SCREAMING_SNAKE_CASE     =      [key for key in resnet_a if """temopral_conv""" in key]

    _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.0""", """new""": """mid_block.resnets.0"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	config=__lowerCamelCase ,	additional_replacements=[meta_path]   )

    _SCREAMING_SNAKE_CASE     =      renew_temp_conv_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.0.temopral_conv""", """new""": """mid_block.temp_convs.0"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	config=__lowerCamelCase ,	additional_replacements=[meta_path]   )

    _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.3""", """new""": """mid_block.resnets.1"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	config=__lowerCamelCase ,	additional_replacements=[meta_path]   )

    _SCREAMING_SNAKE_CASE     =      renew_temp_conv_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.3.temopral_conv""", """new""": """mid_block.temp_convs.1"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	config=__lowerCamelCase ,	additional_replacements=[meta_path]   )

    _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.1""", """new""": """mid_block.attentions.0"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

    _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      {"""old""": """middle_block.2""", """new""": """mid_block.temp_attentions.0"""}
    assign_to_checkpoint(
        __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

    for i in range(__lowerCamelCase   ):
        _SCREAMING_SNAKE_CASE     =      i // (config["""layers_per_block"""] + 1)
        _SCREAMING_SNAKE_CASE     =      i % (config["""layers_per_block"""] + 1)
        _SCREAMING_SNAKE_CASE     =      [shave_segments(__lowerCamelCase ,	2   ) for name in output_blocks[i]]
        _SCREAMING_SNAKE_CASE     =      {}

        for layer in output_block_layers:
            _SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE     =      layer.split("""."""   )[0], shave_segments(__lowerCamelCase ,	1   )
            if layer_id in output_block_list:
                output_block_list[layer_id].append(__lowerCamelCase   )
            else:
                _SCREAMING_SNAKE_CASE     =      [layer_name]

        if len(__lowerCamelCase   ) > 1:
            _SCREAMING_SNAKE_CASE     =      [key for key in output_blocks[i] if F'output_blocks.{i}.0' in key]
            _SCREAMING_SNAKE_CASE     =      [key for key in output_blocks[i] if F'output_blocks.{i}.1' in key]
            _SCREAMING_SNAKE_CASE     =      [key for key in output_blocks[i] if F'output_blocks.{i}.2' in key]

            _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE     =      {"""old""": F'output_blocks.{i}.0', """new""": F'up_blocks.{block_id}.resnets.{layer_in_block_id}'}
            assign_to_checkpoint(
                __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE     =      [key for key in resnets if """temopral_conv""" in key]
            _SCREAMING_SNAKE_CASE     =      renew_temp_conv_paths(__lowerCamelCase   )
            _SCREAMING_SNAKE_CASE     =      {
                """old""": F'output_blocks.{i}.0.temopral_conv',
                """new""": F'up_blocks.{block_id}.temp_convs.{layer_in_block_id}',
            }
            assign_to_checkpoint(
                __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

            _SCREAMING_SNAKE_CASE     =      {k: sorted(__lowerCamelCase   ) for k, v in output_block_list.items()}
            if ["conv.bias", "conv.weight"] in output_block_list.values():
                _SCREAMING_SNAKE_CASE     =      list(output_block_list.values()   ).index(["""conv.bias""", """conv.weight"""]   )
                _SCREAMING_SNAKE_CASE     =      unet_state_dict[
                    F'output_blocks.{i}.{index}.conv.weight'
                ]
                _SCREAMING_SNAKE_CASE     =      unet_state_dict[
                    F'output_blocks.{i}.{index}.conv.bias'
                ]

                # Clear attentions as they have been attributed above.
                if len(__lowerCamelCase   ) == 2:
                    _SCREAMING_SNAKE_CASE     =      []

            if len(__lowerCamelCase   ):
                _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
                _SCREAMING_SNAKE_CASE     =      {
                    """old""": F'output_blocks.{i}.1',
                    """new""": F'up_blocks.{block_id}.attentions.{layer_in_block_id}',
                }
                assign_to_checkpoint(
                    __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )

            if len(__lowerCamelCase   ):
                _SCREAMING_SNAKE_CASE     =      renew_attention_paths(__lowerCamelCase   )
                _SCREAMING_SNAKE_CASE     =      {
                    """old""": F'output_blocks.{i}.2',
                    """new""": F'up_blocks.{block_id}.temp_attentions.{layer_in_block_id}',
                }
                assign_to_checkpoint(
                    __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	additional_replacements=[meta_path] ,	config=__lowerCamelCase   )
        else:
            _SCREAMING_SNAKE_CASE     =      renew_resnet_paths(__lowerCamelCase ,	n_shave_prefix_segments=1   )
            for path in resnet_0_paths:
                _SCREAMING_SNAKE_CASE     =      """.""".join(["""output_blocks""", str(__lowerCamelCase   ), path["""old"""]]   )
                _SCREAMING_SNAKE_CASE     =      """.""".join(["""up_blocks""", str(__lowerCamelCase   ), """resnets""", str(__lowerCamelCase   ), path["""new"""]]   )
                _SCREAMING_SNAKE_CASE     =      unet_state_dict[old_path]

            _SCREAMING_SNAKE_CASE     =      [l for l in output_block_layers if """temopral_conv""" in l]
            for path in temopral_conv_paths:
                _SCREAMING_SNAKE_CASE     =      path.split("""temopral_conv."""   )[-1]
                _SCREAMING_SNAKE_CASE     =      """.""".join(["""output_blocks""", str(__lowerCamelCase   ), str(__lowerCamelCase   ), """temopral_conv""", pruned_path]   )
                _SCREAMING_SNAKE_CASE     =      """.""".join(["""up_blocks""", str(__lowerCamelCase   ), """temp_convs""", str(__lowerCamelCase   ), pruned_path]   )
                _SCREAMING_SNAKE_CASE     =      unet_state_dict[old_path]

    return new_checkpoint


if __name__ == "__main__":
      lowercase_         =			argparse.ArgumentParser()

      parser.add_argument(
          """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
      )
      parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
      lowercase_         =			parser.parse_args()

      lowercase_         =			torch.load(args.checkpoint_path, map_location="""cpu""")
      lowercase_         =			UNetaDConditionModel()

      lowercase_         =			convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

      lowercase_         =			set(unet.state_dict().keys()) - set(converted_ckpt.keys())
      lowercase_         =			set(converted_ckpt.keys()) - set(unet.state_dict().keys())

      assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

      # load state_dict
      unet.load_state_dict(converted_ckpt)

      unet.save_pretrained(args.dump_path)

      # -- finish converting the unet --










'''simple docstring'''

def lowerCamelCase						(					__lowerCamelCase			:   int   )						->int:
    barcode //= 10  # exclude the last digit
    _SCREAMING_SNAKE_CASE     =      False
    _SCREAMING_SNAKE_CASE     =      0

    # extract and check each digit
    while barcode != 0:
        _SCREAMING_SNAKE_CASE     =      1 if checker else 3
        s += mult * (barcode % 10)
        barcode //= 10
        _SCREAMING_SNAKE_CASE     =      not checker

    return (10 - (s % 10)) % 10





def lowerCamelCase						(					__lowerCamelCase			:   int   )						->bool:
    return len(str(__lowerCamelCase   )   ) == 13 and get_check_digit(__lowerCamelCase   ) == barcode % 10





def lowerCamelCase						(					__lowerCamelCase			:   str   )						->int:
    if str(__lowerCamelCase   ).isalpha():
        _SCREAMING_SNAKE_CASE     =      F'Barcode \'{barcode}\' has alphabetic characters.'
        raise ValueError(__lowerCamelCase   )
    elif int(__lowerCamelCase   ) < 0:
        raise ValueError("""The entered barcode has a negative value. Try again."""   )
    else:
        return int(__lowerCamelCase   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      lowercase_         =			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.""")



