



'''simple docstring'''



from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_vision_available():
		from PIL import Image

		from ..image_utils import load_image

if is_torch_available():
		import torch

		from transformers.modeling_outputs import BaseModelOutput

		from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

lowerCamelCase	 =       logging.get_logger(__name__)





@add_end_docstrings(A		)
class _UpperCamelCase		(     A		):





				'''simple docstring'''





				def __init__(							self  :  Any  ,       **_lowerCAmelCase  :  List[str]):







											'''simple docstring'''

											super().__init__(**_lowerCAmelCase)

											if self.framework == "tf":
																		raise ValueError(f"""The {self.__class__} is only available in PyTorch.""")

											requires_backends(self  ,       'vision')
											self.check_model_type(_lowerCAmelCase)

				def __call__(							self  :  Optional[int]  ,       _lowerCAmelCase  :  Union[str, "Image.Image", List[Dict[str, Any]]]  ,       _lowerCAmelCase  :  Union[str, List[str]] = None  ,       **_lowerCAmelCase  :  Any  ,       ):







											'''simple docstring'''

											if "text_queries" in kwargs:
																		__lowercase       	=kwargs.pop('text_queries')

											if isinstance(_lowerCAmelCase  ,       (str, Image.Image)):
																		__lowercase       	={'image': image, 'candidate_labels': candidate_labels}
											else:
																		__lowercase       	=image
											__lowercase       	=super().__call__(_lowerCAmelCase  ,       **_lowerCAmelCase)
											return results

				def 				__lowerCamelCase     (							self  :  Tuple  ,       **_lowerCAmelCase  :  Optional[Any]):







											'''simple docstring'''

											__lowercase       	={}
											if "threshold" in kwargs:
																		__lowercase       	=kwargs['threshold']
											if "top_k" in kwargs:
																		__lowercase       	=kwargs['top_k']
											return {}, {}, postprocess_params

				def 				__lowerCamelCase     (							self  :  int  ,       _lowerCAmelCase  :  int):







											'''simple docstring'''

											__lowercase       	=load_image(inputs['image'])
											__lowercase       	=inputs['candidate_labels']
											if isinstance(_lowerCAmelCase  ,       _lowerCAmelCase):
																		__lowercase       	=candidate_labels.split(',')

											__lowercase       	=torch.tensor([[image.height, image.width]]  ,       dtype=torch.intaa)
											for i, candidate_label in enumerate(_lowerCAmelCase):
																		__lowercase       	=self.tokenizer(_lowerCAmelCase  ,       return_tensors=self.framework)
																		__lowercase       	=self.image_processor(_lowerCAmelCase  ,       return_tensors=self.framework)
																		yield {
																		    "is_last": i == len(_lowerCAmelCase) - 1,
																		    "target_size": target_size,
																		    "candidate_label": candidate_label,
																		    **text_inputs,
																		    **image_features,
																		}

				def 				__lowerCamelCase     (							self  :  Any  ,       _lowerCAmelCase  :  str):







											'''simple docstring'''

											__lowercase       	=model_inputs.pop('target_size')
											__lowercase       	=model_inputs.pop('candidate_label')
											__lowercase       	=model_inputs.pop('is_last')

											__lowercase       	=self.model(**_lowerCAmelCase)

											__lowercase       	={'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs}
											return model_outputs

				def 				__lowerCamelCase     (							self  :  Optional[Any]  ,       _lowerCAmelCase  :  Any  ,       _lowerCAmelCase  :  List[Any]=0.1  ,       _lowerCAmelCase  :  str=None):







											'''simple docstring'''

											__lowercase       	=[]
											for model_output in model_outputs:
																		__lowercase       	=model_output['candidate_label']
																		__lowercase       	=BaseModelOutput(_lowerCAmelCase)
																		__lowercase       	=self.image_processor.post_process_object_detection(
																		    outputs=_lowerCAmelCase  ,       threshold=_lowerCAmelCase  ,       target_sizes=model_output['target_size'])[0]

																		for index in outputs["scores"].nonzero():
																									__lowercase       	=outputs['scores'][index].item()
																									__lowercase       	=self._get_bounding_box(outputs['boxes'][index][0])

																									__lowercase       	={'score': score, 'label': label, 'box': box}
																									results.append(_lowerCAmelCase)

											__lowercase       	=sorted(_lowerCAmelCase  ,       key=lambda _lowerCAmelCase: x["score"]  ,       reverse=_lowerCAmelCase)
											if top_k:
																		__lowercase       	=results[:top_k]

											return results

				def 				__lowerCamelCase     (							self  :  int  ,       _lowerCAmelCase  :  "torch.Tensor"):







											'''simple docstring'''

											if self.framework != "pt":
																		raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.')
											__lowercase	,				__lowercase	,				__lowercase	,				__lowercase       	=box.int().tolist()
											__lowercase       	={
											    'xmin': xmin,
											    'ymin': ymin,
											    'xmax': xmax,
											    'ymax': ymax,
											}
											return bbox








'''simple docstring'''



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


lowerCamelCase	 =       logging.get_logger(__name__)

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

lowerCamelCase	 =       {
    """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"""
        ),
    },
}

lowerCamelCase	 =       {
    """Salesforce/codegen-350M-mono""": 2048,
}





class _UpperCamelCase		(     A		):





				'''simple docstring'''





				lowerCAmelCase__					    =    VOCAB_FILES_NAMES
				lowerCAmelCase__					    =    PRETRAINED_VOCAB_FILES_MAP
				lowerCAmelCase__					    =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowerCAmelCase__					    =    ["""input_ids""", """attention_mask"""]
				lowerCAmelCase__					    =    CodeGenTokenizer

				def __init__(							self  :  int  ,       _lowerCAmelCase  :  str=None  ,       _lowerCAmelCase  :  List[Any]=None  ,       _lowerCAmelCase  :  Optional[Any]=None  ,       _lowerCAmelCase  :  List[str]="<|endoftext|>"  ,       _lowerCAmelCase  :  Optional[int]="<|endoftext|>"  ,       _lowerCAmelCase  :  Optional[Any]="<|endoftext|>"  ,       _lowerCAmelCase  :  Optional[int]=False  ,       **_lowerCAmelCase  :  Union[str, Any]  ,       ):







											'''simple docstring'''

											super().__init__(
											    _lowerCAmelCase  ,       _lowerCAmelCase  ,       tokenizer_file=_lowerCAmelCase  ,       unk_token=_lowerCAmelCase  ,       bos_token=_lowerCAmelCase  ,       eos_token=_lowerCAmelCase  ,       add_prefix_space=_lowerCAmelCase  ,       **_lowerCAmelCase  ,       )

											if kwargs.pop('add_bos_token'  ,       _lowerCAmelCase):
																		__lowercase       	=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.')

											__lowercase       	=json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__())
											if pre_tok_state.get('add_prefix_space'  ,       _lowerCAmelCase) != add_prefix_space:
																		__lowercase       	=getattr(_lowerCAmelCase  ,       pre_tok_state.pop('type'))
																		__lowercase       	=add_prefix_space
																		__lowercase       	=pre_tok_class(**_lowerCAmelCase)

											__lowercase       	=add_prefix_space

				def 				__lowerCamelCase     (							self  :  Any  ,       *_lowerCAmelCase  :  Tuple  ,       **_lowerCAmelCase  :  Union[str, Any]):







											'''simple docstring'''

											__lowercase       	=kwargs.get('is_split_into_words'  ,       _lowerCAmelCase)
											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(*_lowerCAmelCase  ,       **_lowerCAmelCase)

				def 				__lowerCamelCase     (							self  :  List[str]  ,       *_lowerCAmelCase  :  List[Any]  ,       **_lowerCAmelCase  :  List[str]):







											'''simple docstring'''

											__lowercase       	=kwargs.get('is_split_into_words'  ,       _lowerCAmelCase)

											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(*_lowerCAmelCase  ,       **_lowerCAmelCase)

				def 				__lowerCamelCase     (							self  :  str  ,       _lowerCAmelCase  :  str  ,       _lowerCAmelCase  :  Optional[str] = None):







											'''simple docstring'''

											__lowercase       	=self._tokenizer.model.save(_lowerCAmelCase  ,       name=_lowerCAmelCase)
											return tuple(_lowerCAmelCase)

				def 				__lowerCamelCase     (							self  :  str  ,       _lowerCAmelCase  :  Union[int, List[int], "np.ndarray", "torch.Tensor", "tf.Tensor"]  ,       _lowerCAmelCase  :  bool = False  ,       _lowerCAmelCase  :  bool = None  ,       _lowerCAmelCase  :  Optional[List[str]] = None  ,       **_lowerCAmelCase  :  Any  ,       ):







											'''simple docstring'''

											__lowercase       	=super().decode(
											    token_ids=_lowerCAmelCase  ,       skip_special_tokens=_lowerCAmelCase  ,       clean_up_tokenization_spaces=_lowerCAmelCase  ,       **_lowerCAmelCase  ,       )

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

											return decoded_text

				def 				__lowerCamelCase     (							self  :  Any  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  Optional[int]):







											'''simple docstring'''

											def find_re(_lowerCAmelCase  :  List[Any]  ,       _lowerCAmelCase  :  Union[str, Any]  ,       _lowerCAmelCase  :  str):
																		__lowercase       	=pattern.search(_lowerCAmelCase  ,       _lowerCAmelCase)
																		return m.start() if m else -1

											__lowercase       	=[re.compile(_lowerCAmelCase  ,       re.MULTILINE) for pattern in truncate_before_pattern]

											__lowercase       	=list(re.finditer('^print'  ,       _lowerCAmelCase  ,       re.MULTILINE))

											if len(_lowerCAmelCase) > 1:
																		__lowercase       	=completion[: prints[1].start()]

											__lowercase       	=list(re.finditer('^def'  ,       _lowerCAmelCase  ,       re.MULTILINE))

											if len(_lowerCAmelCase) > 1:
																		__lowercase       	=completion[: defs[1].start()]

											__lowercase       	=0

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

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



