




from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__A						:							List[str]							=  logging.get_logger(__name__)

__A						:							int							=  {
    """google/mobilenet_v1_1.0_224""": """https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json""",
    """google/mobilenet_v1_0.75_192""": """https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json""",
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}




class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     '''mobilenet_v1'''





							def __init__(					self       :	Tuple       ,     a       :	Tuple=3       ,     a       :	Any=224       ,     a       :	List[Any]=1.0       ,     a       :	str=8       ,     a       :	Tuple="relu6"       ,     a       :	Dict=True       ,     a       :	Optional[Any]=0.999       ,     a       :	Union[str, Any]=0.02       ,     a       :	Union[str, Any]=0.001       ,     **a       :	Any       ,     )			->					Union[str, Any]:
										super().__init__(**a			)

										if depth_multiplier <= 0:
													raise ValueError("""depth_multiplier must be greater than zero."""			)

										SCREAMING_SNAKE_CASE           =					num_channels
										SCREAMING_SNAKE_CASE           =					image_size
										SCREAMING_SNAKE_CASE           =					depth_multiplier
										SCREAMING_SNAKE_CASE           =					min_depth
										SCREAMING_SNAKE_CASE           =					hidden_act
										SCREAMING_SNAKE_CASE           =					tf_padding
										SCREAMING_SNAKE_CASE           =					classifier_dropout_prob
										SCREAMING_SNAKE_CASE           =					initializer_range
										SCREAMING_SNAKE_CASE           =					layer_norm_eps





class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     version.parse('''1.11'''       )





							@property
							def    _UpperCAmelCase     (					self       :	int			)			->					Mapping[str, Mapping[int, str]]:
										return OrderedDict([("""pixel_values""", {0: """batch"""})]			)





							@property
							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Mapping[str, Mapping[int, str]]:
										if self.task == "image-classification":
													return OrderedDict([("""logits""", {0: """batch"""})]			)
										else:
													return OrderedDict([("""last_hidden_state""", {0: """batch"""}), ("""pooler_output""", {0: """batch"""})]			)







							@property
							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					float:
										return 1E-4












import json
import re
from typing import TYPE_CHECKING, List, Optional, Tuple, Union

import numpy as np

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
		if is_torch_available():
				import torch
		if is_tf_available():
				import tensorflow as tf

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_codegen import CodeGenTokenizer


__A						:							Union[str, Any]							=  logging.get_logger(__name__)

__A						:							str							=  {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

__A						:							List[Any]							=  {
    """vocab_file""": {
        """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """Salesforce/codegen-350M-mono""": """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """Salesforce/codegen-350M-mono""": (
            """https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/tokenizer.json"""
        ),
    },
}

__A						:							Tuple							=  {
    """Salesforce/codegen-350M-mono""": 2_0_4_8,
}




class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     VOCAB_FILES_NAMES
							a__						  =     PRETRAINED_VOCAB_FILES_MAP
							a__						  =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							a__						  =     ['''input_ids''', '''attention_mask''']
							a__						  =     CodeGenTokenizer





							def __init__(					self       :	Tuple       ,     a       :	Dict=None       ,     a       :	Tuple=None       ,     a       :	Tuple=None       ,     a       :	Optional[Any]="<|endoftext|>"       ,     a       :	Any="<|endoftext|>"       ,     a       :	Dict="<|endoftext|>"       ,     a       :	Optional[int]=False       ,     **a       :	Tuple       ,     )			->					str:
										super().__init__(
										    a       ,     a       ,     tokenizer_file=a       ,     unk_token=a       ,     bos_token=a       ,     eos_token=a       ,     add_prefix_space=a       ,     **a       ,     )

										if kwargs.pop("""add_bos_token"""       ,     a			):
													SCREAMING_SNAKE_CASE           =					kwargs.pop("""name_or_path"""       ,     """"""			)
													raise ValueError(
													    """Currenty GPT2's fast tokenizer does NOT support adding a BOS token."""
													    """Instead you should use GPT2's slow tokenizer class `CodeGenTokenizer` as follows: \n"""
													    f"""`CodeGenTokenizer.from_pretrained('{model_id}')`\nor\n"""
													    f"""`AutoTokenizer.from_pretrained('{model_id}', use_fast=False)`\n"""
													    """This issue will be fixed soon, see: https://github.com/huggingface/tokenizers/pull/1005."""
													    """ so that the fast tokenizer works correctly."""			)

										SCREAMING_SNAKE_CASE           =					json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()			)
										if pre_tok_state.get("""add_prefix_space"""       ,     a			) != add_prefix_space:
													SCREAMING_SNAKE_CASE           =					getattr(a       ,     pre_tok_state.pop("""type"""			)			)
													SCREAMING_SNAKE_CASE           =					add_prefix_space
													SCREAMING_SNAKE_CASE           =					pre_tok_class(**a			)

										SCREAMING_SNAKE_CASE           =					add_prefix_space





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     *a       :	Optional[Any]       ,     **a       :	List[Any]			)			->					BatchEncoding:
										SCREAMING_SNAKE_CASE           =					kwargs.get("""is_split_into_words"""       ,     a			)
										assert self.add_prefix_space or not is_split_into_words, (
										    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
										    "to use it with pretokenized inputs."
										)

										return super()._batch_encode_plus(*a       ,     **a			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     *a       :	Tuple       ,     **a       :	List[Any]			)			->					BatchEncoding:
										SCREAMING_SNAKE_CASE           =					kwargs.get("""is_split_into_words"""       ,     a			)

										assert self.add_prefix_space or not is_split_into_words, (
										    f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """
										    "to use it with pretokenized inputs."
										)

										return super()._encode_plus(*a       ,     **a			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	Optional[str] = None			)			->					Tuple[str]:
										SCREAMING_SNAKE_CASE           =					self._tokenizer.model.save(a       ,     name=a			)
										return tuple(a			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	Union[int, List[int], "np.ndarray", "torch.Tensor", "tf.Tensor"]       ,     a       :	bool = False       ,     a       :	bool = None       ,     a       :	Optional[List[str]] = None       ,     **a       :	List[Any]       ,     )			->					str:
										SCREAMING_SNAKE_CASE           =					super().decode(
										    token_ids=a       ,     skip_special_tokens=a       ,     clean_up_tokenization_spaces=a       ,     **a       ,     )

										if truncate_before_pattern is not None and len(a			) > 0:
													SCREAMING_SNAKE_CASE           =					self.truncate(a       ,     a			)

										return decoded_text







							def    _UpperCAmelCase     (					self       :	Any       ,     a       :	Optional[Any]       ,     a       :	List[str]			)			->					Any:
										def find_re(a       :	Tuple       ,     a       :	Any       ,     a       :	List[str]			):
													SCREAMING_SNAKE_CASE           =					pattern.search(a       ,     a			)
													return m.start() if m else -1

										SCREAMING_SNAKE_CASE           =					[re.compile(a       ,     re.MULTILINE			) for pattern in truncate_before_pattern]

										SCREAMING_SNAKE_CASE           =					list(re.finditer("""^print"""       ,     a       ,     re.MULTILINE			)			)

										if len(a			) > 1:
													SCREAMING_SNAKE_CASE           =					completion[: prints[1].start()]

										SCREAMING_SNAKE_CASE           =					list(re.finditer("""^def"""       ,     a       ,     re.MULTILINE			)			)

										if len(a			) > 1:
													SCREAMING_SNAKE_CASE           =					completion[: defs[1].start()]

										SCREAMING_SNAKE_CASE           =					0

										SCREAMING_SNAKE_CASE           =					[
										    pos for pos in [find_re(a       ,     a       ,     a			) for terminal in terminals] if pos != -1
										]

										if len(a			) > 0:
													return completion[: min(a			)]
										else:
													return completion






