
"""simple docstring"""



import os
from itertools import chain
from random import randrange, shuffle

import pytest

from .sola import PokerHand

a					:	List[Any]							=		(
    '''4S 3H 2C 7S 5H''',
    '''9D 8H 2C 6S 7H''',
    '''2D 6D 9D TH 7D''',
    '''TC 8C 2S JH 6C''',
    '''JH 8S TH AH QH''',
    '''TS KS 5S 9S AC''',
    '''KD 6S 9D TH AD''',
    '''KS 8D 4D 9S 4S''',  # pair
    '''8C 4S KH JS 4D''',  # pair
    '''QH 8H KD JH 8S''',  # pair
    '''KC 4H KS 2H 8D''',  # pair
    '''KD 4S KC 3H 8S''',  # pair
    '''AH 8S AS KC JH''',  # pair
    '''3H 4C 4H 3S 2H''',  # 2 pairs
    '''5S 5D 2C KH KH''',  # 2 pairs
    '''3C KH 5D 5S KH''',  # 2 pairs
    '''AS 3C KH AD KH''',  # 2 pairs
    '''7C 7S 3S 7H 5S''',  # 3 of a kind
    '''7C 7S KH 2H 7H''',  # 3 of a kind
    '''AC KH QH AH AS''',  # 3 of a kind
    '''2H 4D 3C AS 5S''',  # straight (low ace)
    '''3C 5C 4C 2C 6H''',  # straight
    '''6S 8S 7S 5H 9H''',  # straight
    '''JS QS 9H TS KH''',  # straight
    '''QC KH TS JS AH''',  # straight (high ace)
    '''8C 9C 5C 3C TC''',  # flush
    '''3S 8S 9S 5S KS''',  # flush
    '''4C 5C 9C 8C KC''',  # flush
    '''JH 8H AH KH QH''',  # flush
    '''3D 2H 3H 2C 2D''',  # full house
    '''2H 2C 3S 3H 3D''',  # full house
    '''KH KC 3S 3H 3D''',  # full house
    '''JC 6H JS JD JH''',  # 4 of a kind
    '''JC 7H JS JD JH''',  # 4 of a kind
    '''JC KH JS JD JH''',  # 4 of a kind
    '''2S AS 4S 5S 3S''',  # straight flush (low ace)
    '''2D 6D 3D 4D 5D''',  # straight flush
    '''5C 6C 3C 7C 4C''',  # straight flush
    '''JH 9H TH KH QH''',  # straight flush
    '''JH AH TH KH QH''',  # royal flush (high ace straight flush)
)

a					:	Tuple							=		(
    ('''2H 3H 4H 5H 6H''', '''KS AS TS QS JS''', '''Loss'''),
    ('''2H 3H 4H 5H 6H''', '''AS AD AC AH JD''', '''Win'''),
    ('''AS AH 2H AD AC''', '''JS JD JC JH 3D''', '''Win'''),
    ('''2S AH 2H AS AC''', '''JS JD JC JH AD''', '''Loss'''),
    ('''2S AH 2H AS AC''', '''2H 3H 5H 6H 7H''', '''Win'''),
    ('''AS 3S 4S 8S 2S''', '''2H 3H 5H 6H 7H''', '''Win'''),
    ('''2H 3H 5H 6H 7H''', '''2S 3H 4H 5S 6C''', '''Win'''),
    ('''2S 3H 4H 5S 6C''', '''3D 4C 5H 6H 2S''', '''Tie'''),
    ('''2S 3H 4H 5S 6C''', '''AH AC 5H 6H AS''', '''Win'''),
    ('''2S 2H 4H 5S 4C''', '''AH AC 5H 6H AS''', '''Loss'''),
    ('''2S 2H 4H 5S 4C''', '''AH AC 5H 6H 7S''', '''Win'''),
    ('''6S AD 7H 4S AS''', '''AH AC 5H 6H 7S''', '''Loss'''),
    ('''2S AH 4H 5S KC''', '''AH AC 5H 6H 7S''', '''Loss'''),
    ('''2S 3H 6H 7S 9C''', '''7H 3C TH 6H 9S''', '''Loss'''),
    ('''4S 5H 6H TS AC''', '''3S 5H 6H TS AC''', '''Win'''),
    ('''2S AH 4H 5S 6C''', '''AD 4C 5H 6H 2C''', '''Tie'''),
    ('''AS AH 3H AD AC''', '''AS AH 2H AD AC''', '''Win'''),
    ('''AH AC 5H 5C QS''', '''AH AC 5H 5C KS''', '''Loss'''),
    ('''AH AC 5H 5C QS''', '''KH KC 5H 5C QS''', '''Win'''),
    ('''7C 7S KH 2H 7H''', '''3C 3S AH 2H 3H''', '''Win'''),
    ('''3C 3S AH 2H 3H''', '''7C 7S KH 2H 7H''', '''Loss'''),
    ('''6H 5H 4H 3H 2H''', '''5H 4H 3H 2H AH''', '''Win'''),
    ('''5H 4H 3H 2H AH''', '''5H 4H 3H 2H AH''', '''Tie'''),
    ('''5H 4H 3H 2H AH''', '''6H 5H 4H 3H 2H''', '''Loss'''),
    ('''AH AD KS KC AC''', '''AH KD KH AC KC''', '''Win'''),
    ('''2H 4D 3C AS 5S''', '''2H 4D 3C 6S 5S''', '''Loss'''),
    ('''2H 3S 3C 3H 2S''', '''3S 3C 2S 2H 2D''', '''Win'''),
    ('''4D 6D 5D 2D JH''', '''3S 8S 3H TC KH''', '''Loss'''),
    ('''4S 6C 8S 3S 7S''', '''AD KS 2D 7D 7C''', '''Loss'''),
    ('''6S 4C 7H 8C 3H''', '''5H JC AH 9D 9C''', '''Loss'''),
    ('''9D 9H JH TC QH''', '''3C 2S JS 5C 7H''', '''Win'''),
    ('''2H TC 8S AD 9S''', '''4H TS 7H 2C 5C''', '''Win'''),
    ('''9D 3S 2C 7S 7C''', '''JC TD 3C TC 9H''', '''Loss'''),
)

a					:	Optional[int]							=		(
    ('''2H 3H 4H 5H 6H''', True),
    ('''AS AH 2H AD AC''', False),
    ('''2H 3H 5H 6H 7H''', True),
    ('''KS AS TS QS JS''', True),
    ('''8H 9H QS JS TH''', False),
    ('''AS 3S 4S 8S 2S''', True),
)

a					:	Any							=		(
    ('''2H 3H 4H 5H 6H''', True),
    ('''AS AH 2H AD AC''', False),
    ('''2H 3H 5H 6H 7H''', False),
    ('''KS AS TS QS JS''', True),
    ('''8H 9H QS JS TH''', True),
)

a					:	Any							=		(
    ('''2H 4D 3C AS 5S''', True, [5, 4, 3, 2, 1_4]),
    ('''2H 5D 3C AS 5S''', False, [1_4, 5, 5, 3, 2]),
    ('''JH QD KC AS TS''', False, [1_4, 1_3, 1_2, 1_1, 1_0]),
    ('''9D 3S 2C 7S 7C''', False, [9, 7, 7, 3, 2]),
)

a					:	Any							=		(
    ('''JH AH TH KH QH''', 0),
    ('''JH 9H TH KH QH''', 0),
    ('''JC KH JS JD JH''', 7),
    ('''KH KC 3S 3H 3D''', 6),
    ('''8C 9C 5C 3C TC''', 0),
    ('''JS QS 9H TS KH''', 0),
    ('''7C 7S KH 2H 7H''', 3),
    ('''3C KH 5D 5S KH''', 2),
    ('''QH 8H KD JH 8S''', 1),
    ('''2D 6D 9D TH 7D''', 0),
)

a					:	List[str]							=		(
    ('''JH AH TH KH QH''', 2_3),
    ('''JH 9H TH KH QH''', 2_2),
    ('''JC KH JS JD JH''', 2_1),
    ('''KH KC 3S 3H 3D''', 2_0),
    ('''8C 9C 5C 3C TC''', 1_9),
    ('''JS QS 9H TS KH''', 1_8),
    ('''7C 7S KH 2H 7H''', 1_7),
    ('''3C KH 5D 5S KH''', 1_6),
    ('''QH 8H KD JH 8S''', 1_5),
    ('''2D 6D 9D TH 7D''', 1_4),
)


def  _UpperCamelCase	(						)    ->  Optional[Any]:





    """simple docstring"""

    _UpperCAmelCase          =   randrange(len(snake_case_      )      ), randrange(len(snake_case_      )      )
    _UpperCAmelCase          =   ["""Loss""", """Tie""", """Win"""][(play >= oppo) + (play > oppo)]
    _UpperCAmelCase          =   SORTED_HANDS[play], SORTED_HANDS[oppo]
    return hand, other, expected


def  _UpperCamelCase	(						_A = 1_0_0      )    ->  List[Any]:





    """simple docstring"""

    return (generate_random_hand() for _ in range(snake_case_      ))


@pytest.mark.parametrize("""hand, expected"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A      )    ->  Optional[Any]:





    """simple docstring"""

    assert PokerHand(snake_case_      )._is_flush() == expected


@pytest.mark.parametrize("""hand, expected"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A      )    ->  int:





    """simple docstring"""

    assert PokerHand(snake_case_      )._is_straight() == expected


@pytest.mark.parametrize("""hand, expected, card_values"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A					,      _A      )    ->  str:





    """simple docstring"""

    _UpperCAmelCase          =   PokerHand(snake_case_      )
    assert player._is_five_high_straight() == expected
    assert player._card_values == card_values


@pytest.mark.parametrize("""hand, expected"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A      )    ->  Optional[Any]:





    """simple docstring"""

    assert PokerHand(snake_case_      )._is_same_kind() == expected


@pytest.mark.parametrize("""hand, expected"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A      )    ->  Any:





    """simple docstring"""

    assert PokerHand(snake_case_      )._hand_type == expected


@pytest.mark.parametrize("""hand, other, expected"""					,      snake_case_      )
def  _UpperCamelCase	(						_A					,      _A					,      _A      )    ->  Dict:





    """simple docstring"""

    assert PokerHand(snake_case_      ).compare_with(PokerHand(snake_case_      )      ) == expected


@pytest.mark.parametrize("""hand, other, expected"""					,      generate_random_hands()      )
def  _UpperCamelCase	(						_A					,      _A					,      _A      )    ->  Dict:





    """simple docstring"""

    assert PokerHand(snake_case_      ).compare_with(PokerHand(snake_case_      )      ) == expected


def  _UpperCamelCase	(						)    ->  Optional[int]:





    """simple docstring"""

    _UpperCAmelCase          =   [PokerHand(snake_case_      ) for hand in SORTED_HANDS]
    _UpperCAmelCase          =   poker_hands.copy()
    shuffle(snake_case_      )
    _UpperCAmelCase          =   chain(sorted(snake_case_      )      )
    for index, hand in enumerate(snake_case_      ):
        assert hand == poker_hands[index]


def  _UpperCamelCase	(						)    ->  int:





    """simple docstring"""

    _UpperCAmelCase          =   [PokerHand("""2D AC 3H 4H 5S"""      ), PokerHand("""2S 3H 4H 5S 6C"""      )]
    pokerhands.sort(reverse=snake_case_      )
    assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C"


def  _UpperCamelCase	(						)    ->  int:





    """simple docstring"""

    _UpperCAmelCase          =   PokerHand("""2C 4S AS 3D 5C"""      )
    _UpperCAmelCase          =   True
    _UpperCAmelCase          =   [5, 4, 3, 2, 1_4]
    for _ in range(1_0      ):
        assert pokerhand._is_five_high_straight() == expected
        assert pokerhand._card_values == expected_card_values







def  _UpperCamelCase	(						)    ->  List[Any]:





    """simple docstring"""

    _UpperCAmelCase          =   0
    _UpperCAmelCase          =   os.path.abspath(os.path.dirname(snake_case_      )      )
    _UpperCAmelCase          =   os.path.join(snake_case_					,      """poker_hands.txt"""      )
    with open(snake_case_      ) as file_hand:
        for line in file_hand:
            _UpperCAmelCase          =   line[:1_4].strip()
            _UpperCAmelCase          =   line[1_5:].strip()
            _UpperCAmelCase          =   PokerHand(snake_case_      ), PokerHand(snake_case_      )
            _UpperCAmelCase          =   player.compare_with(snake_case_      )
            if output == "Win":
                answer += 1
    assert answer == 3_7_6

"""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					:	List[str]							=		logging.get_logger(__name__)




class 		a_						( enum.Enum	):
    a      :				Optional[Any]     =				0
    a      :				Dict     =				1







@add_end_docstrings(_UpperCAmelCase	)
class 		a_						( _UpperCAmelCase	):
    a      :				List[Any]     =				'generated'







    def __init__(			self			:       int     ,					*__UpperCamelCase			:       Optional[int]     ,					**__UpperCamelCase			:       str     )		->Any:






        '''simple docstring'''






        super().__init__(*__UpperCamelCase     ,					**__UpperCamelCase     )

        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      _snake_case					(			self			:       Optional[int]     ,					__UpperCamelCase			:       List[Any]=None     ,					__UpperCamelCase			:       Union[str, Any]=None     ,					__UpperCamelCase			:       Any=None     ,					__UpperCamelCase			:       int=None     ,					__UpperCamelCase			:       Tuple=None     ,					__UpperCamelCase			:       Dict=None     ,					**__UpperCamelCase			:       Any     ,					)		->Tuple:






        '''simple docstring'''






        _UpperCAmelCase          =   {}
        if truncation is not None:
            _UpperCAmelCase          =   truncation

        _UpperCAmelCase          =   generate_kwargs

        _UpperCAmelCase          =   {}
        if return_tensors is not None and return_type is None:
            _UpperCAmelCase          =   ReturnType.TENSORS if return_tensors else ReturnType.TEXT
        if return_type is not None:
            _UpperCAmelCase          =   return_type

        if clean_up_tokenization_spaces is not None:
            _UpperCAmelCase          =   clean_up_tokenization_spaces

        if stop_sequence is not None:
            _UpperCAmelCase          =   self.tokenizer.encode(__UpperCamelCase     ,					add_special_tokens=__UpperCamelCase     )
            if len(__UpperCamelCase     ) > 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."""     )
            _UpperCAmelCase          =   stop_sequence_ids[0]

        return preprocess_params, forward_params, postprocess_params







    def      _snake_case					(			self			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     )		->Any:






        '''simple docstring'''






        return True







    def      _snake_case					(			self			:       Optional[Any]     ,					*__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       Dict     )		->Dict:






        '''simple docstring'''






        _UpperCAmelCase          =   self.model.config.prefix if self.model.config.prefix is not None else """"""
        if isinstance(args[0]     ,					__UpperCamelCase     ):
            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"""     )
            _UpperCAmelCase          =   ([prefix + arg for arg in args[0]],)
            _UpperCAmelCase          =   True

        elif isinstance(args[0]     ,					__UpperCamelCase     ):
            _UpperCAmelCase          =   (prefix + args[0],)
            _UpperCAmelCase          =   False
        else:
            raise ValueError(
                f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`"""     )
        _UpperCAmelCase          =   self.tokenizer(*__UpperCamelCase     ,					padding=__UpperCamelCase     ,					truncation=__UpperCamelCase     ,					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			:       Dict     ,					*__UpperCamelCase			:       str     ,					**__UpperCamelCase			:       Dict     )		->Optional[Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   super().__call__(*__UpperCamelCase     ,					**__UpperCamelCase     )
        if (
            isinstance(args[0]     ,					__UpperCamelCase     )
            and all(isinstance(__UpperCamelCase     ,					__UpperCamelCase     ) for el in args[0]     )
            and all(len(__UpperCamelCase     ) == 1 for res in result     )
        ):
            return [res[0] for res in result]
        return result







    def      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       str=TruncationStrategy.DO_NOT_TRUNCATE     ,					**__UpperCamelCase			:       Optional[int]     )		->Optional[int]:






        '''simple docstring'''






        _UpperCAmelCase          =   self._parse_and_tokenize(__UpperCamelCase     ,					truncation=__UpperCamelCase     ,					**__UpperCamelCase     )
        return inputs







    def      _snake_case					(			self			:       str     ,					__UpperCamelCase			:       Dict     ,					**__UpperCamelCase			:       Dict     )		->Tuple:






        '''simple docstring'''






        if self.framework == "pt":
            _UpperCAmelCase    ,_UpperCAmelCase          =   model_inputs["""input_ids"""].shape
        elif self.framework == "tf":
            _UpperCAmelCase    ,_UpperCAmelCase          =   tf.shape(model_inputs["""input_ids"""]     ).numpy()

        _UpperCAmelCase          =   generate_kwargs.get("""min_length"""     ,					self.model.config.min_length     )
        _UpperCAmelCase          =   generate_kwargs.get("""max_length"""     ,					self.model.config.max_length     )
        self.check_inputs(__UpperCamelCase     ,					generate_kwargs["""min_length"""]     ,					generate_kwargs["""max_length"""]     )
        _UpperCAmelCase          =   self.model.generate(**__UpperCamelCase     ,					**__UpperCamelCase     )
        _UpperCAmelCase          =   output_ids.shape[0]
        if self.framework == "pt":
            _UpperCAmelCase          =   output_ids.reshape(__UpperCamelCase     ,					out_b // in_b     ,					*output_ids.shape[1:]     )
        elif self.framework == "tf":
            _UpperCAmelCase          =   tf.reshape(__UpperCamelCase     ,					(in_b, out_b // in_b, *output_ids.shape[1:])     )
        return {"output_ids": output_ids}







    def      _snake_case					(			self			:       Tuple     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       Union[str, Any]=ReturnType.TEXT     ,					__UpperCamelCase			:       int=False     )		->Any:






        '''simple docstring'''






        _UpperCAmelCase          =   []
        for output_ids in model_outputs["output_ids"][0]:
            if return_type == ReturnType.TENSORS:
                _UpperCAmelCase          =   {f"""{self.return_name}_token_ids""": output_ids}
            elif return_type == ReturnType.TEXT:
                _UpperCAmelCase          =   {
                    f"""{self.return_name}_text""": self.tokenizer.decode(
                        __UpperCamelCase     ,					skip_special_tokens=__UpperCamelCase     ,					clean_up_tokenization_spaces=__UpperCamelCase     ,					)
                }
            records.append(__UpperCamelCase     )
        return records







@add_end_docstrings(_UpperCAmelCase	)
class 		a_						( _UpperCAmelCase	):
    a      :				List[Any]     =				'summary'







    def __call__(			self			:       Optional[Any]     ,					*__UpperCamelCase			:       Optional[Any]     ,					**__UpperCamelCase			:       Optional[int]     )		->Any:






        '''simple docstring'''






        return super().__call__(*__UpperCamelCase     ,					**__UpperCamelCase     )







    def      _snake_case					(			self			:       str     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     )		->bool:






        '''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(_UpperCAmelCase	)
class 		a_						( _UpperCAmelCase	):
    a      :				Optional[int]     =				'translation'







    def      _snake_case					(			self			:       Union[str, Any]     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     ,					__UpperCamelCase			:       int     )		->Any:






        '''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      _snake_case					(			self			:       Tuple     ,					*__UpperCamelCase			:       List[str]     ,					__UpperCamelCase			:       Tuple=TruncationStrategy.DO_NOT_TRUNCATE     ,					__UpperCamelCase			:       Tuple=None     ,					__UpperCamelCase			:       Union[str, Any]=None     )		->Tuple:






        '''simple docstring'''






        if getattr(self.tokenizer     ,					"""_build_translation_inputs"""     ,					__UpperCamelCase     ):
            return self.tokenizer._build_translation_inputs(
                *__UpperCamelCase     ,					return_tensors=self.framework     ,					truncation=__UpperCamelCase     ,					src_lang=__UpperCamelCase     ,					tgt_lang=__UpperCamelCase     )
        else:
            return super()._parse_and_tokenize(*__UpperCamelCase     ,					truncation=__UpperCamelCase     )







    def      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       int=None     ,					__UpperCamelCase			:       int=None     ,					**__UpperCamelCase			:       Any     )		->int:






        '''simple docstring'''






        _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase          =   super()._sanitize_parameters(**__UpperCamelCase     )
        if src_lang is not None:
            _UpperCAmelCase          =   src_lang
        if tgt_lang is not None:
            _UpperCAmelCase          =   tgt_lang
        if src_lang is None and tgt_lang is None:
            # Backward compatibility, direct arguments use is preferred.
            _UpperCAmelCase          =   kwargs.get("""task"""     ,					self.task     )
            _UpperCAmelCase          =   task.split("""_"""     )
            if task and len(__UpperCamelCase     ) == 4:
                # translation, XX, to YY
                _UpperCAmelCase          =   items[1]
                _UpperCAmelCase          =   items[3]
        return preprocess_params, forward_params, postprocess_params







    def __call__(			self			:       List[str]     ,					*__UpperCamelCase			:       str     ,					**__UpperCamelCase			:       Optional[Any]     )		->int:






        '''simple docstring'''






        return super().__call__(*__UpperCamelCase     ,					**__UpperCamelCase     )