






"""simple docstring"""







import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
			import tensorflow as tf

			from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
			from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

a			:    str				 =		logging.get_logger(__name__)


class    __UpperCAmelCase(       enum.Enum							):




						"""simple docstring"""




						__lowerCamelCase    	= 0
						__lowerCamelCase    	= 1


@add_end_docstrings(SCREAMING_SNAKE_CASE__							)
class    __UpperCAmelCase(       SCREAMING_SNAKE_CASE__							):




						"""simple docstring"""




						__lowerCamelCase    	= "generated"




						def __init__(       self	,  *snake_case__	,  **snake_case__      ):
												'''simple docstring'''
												super().__init__(*snake_case__	,  **snake_case__      )

												self.check_model_type(
												    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
												    if self.framework == "tf"
												    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING      )




						def 		UpperCAmelCase_	(       self	,  snake_case__=None	,  snake_case__=None	,  snake_case__=None	,  snake_case__=None	,  snake_case__=None	,  snake_case__=None	,  **snake_case__	,  ):
												'''simple docstring'''
												lowercase__    :				List[Any]=	{}
												if truncation is not None:
																		lowercase__    :				List[Any]=	truncation

												lowercase__    :				Optional[int]=	generate_kwargs

												lowercase__    :				Optional[Any]=	{}
												if return_tensors is not None and return_type is None:
																		lowercase__    :				Optional[int]=	ReturnType.TENSORS if return_tensors else ReturnType.TEXT
												if return_type is not None:
																		lowercase__    :				List[Any]=	return_type

												if clean_up_tokenization_spaces is not None:
																		lowercase__    :				Dict=	clean_up_tokenization_spaces

												if stop_sequence is not None:
																		lowercase__    :				Any=	self.tokenizer.encode(snake_case__	,  add_special_tokens=snake_case__      )
																		if len(snake_case__      ) > 1:
																								warnings.warn(
																								    "Stopping on a multiple token sequence is not yet supported on transformers. The first token of"
																								    " the stop sequence will be used as the stop sequence string in the interim."      )
																		lowercase__    :				List[Any]=	stop_sequence_ids[0]

												return preprocess_params, forward_params, postprocess_params




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__	,  snake_case__      ):
												'''simple docstring'''
												return True




						def 		UpperCAmelCase_	(       self	,  *snake_case__	,  snake_case__      ):
												'''simple docstring'''
												lowercase__    :				Optional[Any]=	self.model.config.prefix if self.model.config.prefix is not None else ""
												if isinstance(args[0]	,  snake_case__      ):
																		if self.tokenizer.pad_token_id is None:
																								raise ValueError("Please make sure that the tokenizer has a pad_token_id when using a batch input"      )
																		lowercase__    :				str=	([prefix + arg for arg in args[0]],)
																		lowercase__    :				Any=	True

												elif isinstance(args[0]	,  snake_case__      ):
																		lowercase__    :				str=	(prefix + args[0],)
																		lowercase__    :				Union[str, Any]=	False
												else:
																		raise ValueError(
																		    F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''      )
												lowercase__    :				Optional[int]=	self.tokenizer(*snake_case__	,  padding=snake_case__	,  truncation=snake_case__	,  return_tensors=self.framework      )
												# This is produced by tokenizers but is an invalid generate kwargs
												if "token_type_ids" in inputs:
																		del inputs["token_type_ids"]
												return inputs




						def __call__(       self	,  *snake_case__	,  **snake_case__      ):
												'''simple docstring'''
												lowercase__    :				Tuple=	super().__call__(*snake_case__	,  **snake_case__      )
												if (
												    isinstance(args[0]	,  snake_case__      )
												    and all(isinstance(snake_case__	,  snake_case__      ) for el in args[0]      )
												    and all(len(snake_case__      ) == 1 for res in result      )
												):
																		return [res[0] for res in result]
												return result




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__=TruncationStrategy.DO_NOT_TRUNCATE	,  **snake_case__      ):
												'''simple docstring'''
												lowercase__    :				Tuple=	self._parse_and_tokenize(snake_case__	,  truncation=snake_case__	,  **snake_case__      )
												return inputs




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  **snake_case__      ):
												'''simple docstring'''
												if self.framework == "pt":
																		lowercase__,     lowercase__    :				List[str]=	model_inputs["input_ids"].shape
												elif self.framework == "tf":
																		lowercase__,     lowercase__    :				Tuple=	tf.shape(model_inputs["input_ids"]      ).numpy()

												lowercase__    :				Optional[Any]=	generate_kwargs.get("min_length"	,  self.model.config.min_length      )
												lowercase__    :				List[Any]=	generate_kwargs.get("max_length"	,  self.model.config.max_length      )
												self.check_inputs(snake_case__	,  generate_kwargs["min_length"]	,  generate_kwargs["max_length"]      )
												lowercase__    :				str=	self.model.generate(**snake_case__	,  **snake_case__      )
												lowercase__    :				Optional[int]=	output_ids.shape[0]
												if self.framework == "pt":
																		lowercase__    :				int=	output_ids.reshape(snake_case__	,  out_b // in_b	,  *output_ids.shape[1:]      )
												elif self.framework == "tf":
																		lowercase__    :				int=	tf.reshape(snake_case__	,  (in_b, out_b // in_b, *output_ids.shape[1:])      )
												return {"output_ids": output_ids}




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__=ReturnType.TEXT	,  snake_case__=False      ):
												'''simple docstring'''
												lowercase__    :				Optional[int]=	[]
												for output_ids in model_outputs["output_ids"][0]:
																		if return_type == ReturnType.TENSORS:
																								lowercase__    :				Tuple=	{F'''{self.return_name}_token_ids''': output_ids}
																		elif return_type == ReturnType.TEXT:
																								lowercase__    :				int=	{
																								    F'''{self.return_name}_text''': self.tokenizer.decode(
																								        snake_case__	,  skip_special_tokens=snake_case__	,  clean_up_tokenization_spaces=snake_case__	,  )
																								}
																		records.append(snake_case__      )
												return records


@add_end_docstrings(SCREAMING_SNAKE_CASE__							)
class    __UpperCAmelCase(       SCREAMING_SNAKE_CASE__							):




						"""simple docstring"""




						__lowerCamelCase    	= "summary"




						def __call__(       self	,  *snake_case__	,  **snake_case__      ):
												'''simple docstring'''
												return super().__call__(*snake_case__	,  **snake_case__      )




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__	,  snake_case__      ):
												'''simple docstring'''
												if max_length < min_length:
																		logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''      )

												if input_length < max_length:
																		logger.warning(
																		    F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
																		    "a summarization task, where outputs shorter than the input are typically wanted, you might "
																		    F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''      )


@add_end_docstrings(SCREAMING_SNAKE_CASE__							)
class    __UpperCAmelCase(       SCREAMING_SNAKE_CASE__							):




						"""simple docstring"""




						__lowerCamelCase    	= "translation"




						def 		UpperCAmelCase_	(       self	,  snake_case__	,  snake_case__	,  snake_case__      ):
												'''simple docstring'''
												if input_length > 0.9 * max_length:
																		logger.warning(
																		    F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
																		    "increasing your max_length manually, e.g. translator('...', max_length=400)"      )
												return True




						def 		UpperCAmelCase_	(       self	,  *snake_case__	,  snake_case__=TruncationStrategy.DO_NOT_TRUNCATE	,  snake_case__=None	,  snake_case__=None      ):
												'''simple docstring'''
												if getattr(self.tokenizer	,  "_build_translation_inputs"	,  snake_case__      ):
																		return self.tokenizer._build_translation_inputs(
																		    *snake_case__	,  return_tensors=self.framework	,  truncation=snake_case__	,  src_lang=snake_case__	,  tgt_lang=snake_case__      )
												else:
																		return super()._parse_and_tokenize(*snake_case__	,  truncation=snake_case__      )




						def 		UpperCAmelCase_	(       self	,  snake_case__=None	,  snake_case__=None	,  **snake_case__      ):
												'''simple docstring'''
												lowercase__,     lowercase__,     lowercase__    :				Tuple=	super()._sanitize_parameters(**snake_case__      )
												if src_lang is not None:
																		lowercase__    :				Any=	src_lang
												if tgt_lang is not None:
																		lowercase__    :				Any=	tgt_lang
												if src_lang is None and tgt_lang is None:
																		# Backward compatibility, direct arguments use is preferred.
																		lowercase__    :				int=	kwargs.get("task"	,  self.task      )
																		lowercase__    :				Dict=	task.split("_"      )
																		if task and len(snake_case__      ) == 4:
																								# translation, XX, to YY
																								lowercase__    :				int=	items[1]
																								lowercase__    :				str=	items[3]
												return preprocess_params, forward_params, postprocess_params




						def __call__(       self	,  *snake_case__	,  **snake_case__      ):
												'''simple docstring'''
												return super().__call__(*snake_case__	,  **snake_case__      )














"""simple docstring"""







from __future__ import annotations





def 						lowercase__(A ,		A						)    ->list[str]:




						"""simple docstring"""



						if partitions <= 0:
												raise ValueError("partitions must be a positive number!"						)
						if partitions > number_of_bytes:
												raise ValueError("partitions can not > number_of_bytes!"						)
						lowercase__    :				List[str]=	number_of_bytes // partitions
						lowercase__    :				Dict=	[]
						for i in range(A						):
												lowercase__    :				Union[str, Any]=	i * bytes_per_partition + 1
												lowercase__    :				Any=	(
												    number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition
												)
												allocation_list.append(f'''{start_bytes}-{end_bytes}'''						)
						return allocation_list


if __name__ == "__main__":
			import doctest

			doctest.testmod()






