




import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, slow, torch_device

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin






class 	A	(						a_	,  a_	,  unittest.TestCase						):
     """simple docstring"""

     _snake_case:		Any   =UNetaDModel
     _snake_case:		Dict   ="sample"




     @property
     def        __snake_case      (			self     :      Dict	) ->				int:
           lowerCamelCase__					     = 4
           lowerCamelCase__					     = 1_4
           lowerCamelCase__					     = 1_6

           lowerCamelCase__					     = floats_tensor((batch_size, num_features, seq_len)	).to(A__	)
           lowerCamelCase__					     = torch.tensor([1_0] * batch_size	).to(A__	)

           return {"sample": noise, "timestep": time_step}




     @property
     def        __snake_case      (			self     :      List[str]	) ->				List[str]:
           return (4, 1_4, 1_6)




     @property
     def        __snake_case      (			self     :      Optional[int]	) ->				Any:
           return (4, 1_4, 1_6)




     def        __snake_case      (			self     :      List[str]	) ->				int:
           pass




     def        __snake_case      (			self     :      Dict	) ->				Optional[Any]:
           pass




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Tuple	) ->				List[Any]:
           super().test_determinism()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      List[Any]	) ->				int:
           super().test_outputs_equivalence()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      List[Any]	) ->				str:
           super().test_from_save_pretrained()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      int	) ->				str:
           super().test_from_save_pretrained_variant()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Union[str, Any]	) ->				Tuple:
           super().test_model_from_pretrained()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Any	) ->				List[Any]:
           super().test_output()




     def        __snake_case      (			self     :      str	) ->				str:
           lowerCamelCase__					     = {
               """block_out_channels""": (3_2, 6_4, 1_2_8, 2_5_6),
               """in_channels""": 1_4,
               """out_channels""": 1_4,
               """time_embedding_type""": """positional""",
               """use_timestep_embedding""": True,
               """flip_sin_to_cos""": False,
               """freq_shift""": 1.0,
               """out_block_type""": """OutConv1DBlock""",
               """mid_block_type""": """MidResTemporalBlock1D""",
               """down_block_types""": ("""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""),
               """up_block_types""": ("""UpResnetBlock1D""", """UpResnetBlock1D""", """UpResnetBlock1D"""),
               """act_fn""": """mish""",
           }
           lowerCamelCase__					     = self.dummy_input
           return init_dict, inputs_dict




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      int	) ->				List[Any]:
           lowerCamelCase__					     = UNetaDModel.from_pretrained(
               'bglick13/hopper-medium-v2-value-function-hor32'		,     output_loading_info=A__		,     subfolder='unet'	)
           self.assertIsNotNone(A__	)
           self.assertEqual(len(loading_info['missing_keys']	)		,     0	)

           model.to(A__	)
           lowerCamelCase__					     = model(**self.dummy_input	)

           assert image is not None, "Make sure output is not None"




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      str	) ->				Optional[Any]:
           lowerCamelCase__					     = UNetaDModel.from_pretrained('bglick13/hopper-medium-v2-value-function-hor32'		,     subfolder='unet'	)
           torch.manual_seed(0	)
           if torch.cuda.is_available():
                 torch.cuda.manual_seed_all(0	)

           lowerCamelCase__					     = model.config.in_channels
           lowerCamelCase__					     = 1_6
           lowerCamelCase__					     = torch.randn((1, seq_len, num_features)	).permute(
               0		,     2		,     1	)  # match original, we can update values and remove
           lowerCamelCase__					     = torch.full((num_features,)		,     0	)

           with torch.no_grad():
                 lowerCamelCase__					     = model(A__		,     A__	).sample.permute(0		,     2		,     1	)

           lowerCamelCase__					     = output[0, -3:, -3:].flatten()
           # fmt: off
           lowerCamelCase__					     = torch.tensor([-2.137172, 1.1426016, 0.3688687, -0.766922, 0.7303146, 0.11038864, -0.4760633, 0.13270172, 0.02591348]	)
           # fmt: on
           self.assertTrue(torch.allclose(A__		,     A__		,     rtol=1E-3	)	)




     def        __snake_case      (			self     :      Optional[Any]	) ->				Optional[Any]:
           pass




     @slow
     def        __snake_case      (			self     :      int	) ->				str:
           lowerCamelCase__					     = """harmonai/maestro-150k"""
           lowerCamelCase__					     = UNetaDModel.from_pretrained(A__		,     subfolder='unet'	)
           model.to(A__	)

           lowerCamelCase__					     = 6_5_5_3_6
           lowerCamelCase__					     = torch.sin(torch.arange(A__	)[None, None, :].repeat(1		,     2		,     1	)	).to(A__	)
           lowerCamelCase__					     = torch.tensor([1]	).to(A__	)

           with torch.no_grad():
                 lowerCamelCase__					     = model(A__		,     A__	).sample

           lowerCamelCase__					     = output.abs().sum()
           lowerCamelCase__					     = output.abs().max()

           assert (output_sum - 224.0896).abs() < 0.5
           assert (output_max - 0.0607).abs() < 4E-4






class 	A	(						a_	,  a_	,  unittest.TestCase						):
     """simple docstring"""

     _snake_case:		Optional[Any]   =UNetaDModel
     _snake_case:		Tuple   ="sample"




     @property
     def        __snake_case      (			self     :      List[Any]	) ->				int:
           lowerCamelCase__					     = 4
           lowerCamelCase__					     = 1_4
           lowerCamelCase__					     = 1_6

           lowerCamelCase__					     = floats_tensor((batch_size, num_features, seq_len)	).to(A__	)
           lowerCamelCase__					     = torch.tensor([1_0] * batch_size	).to(A__	)

           return {"sample": noise, "timestep": time_step}




     @property
     def        __snake_case      (			self     :      Optional[Any]	) ->				Optional[Any]:
           return (4, 1_4, 1_6)




     @property
     def        __snake_case      (			self     :      Optional[int]	) ->				Any:
           return (4, 1_4, 1)




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Tuple	) ->				List[Any]:
           super().test_determinism()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      List[str]	) ->				Dict:
           super().test_outputs_equivalence()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Union[str, Any]	) ->				Dict:
           super().test_from_save_pretrained()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Optional[int]	) ->				Tuple:
           super().test_from_save_pretrained_variant()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Optional[int]	) ->				str:
           super().test_model_from_pretrained()




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      List[str]	) ->				Tuple:
           lowerCamelCase__					     = self.prepare_init_args_and_inputs_for_common()
           lowerCamelCase__					     = self.model_class(**A__	)
           model.to(A__	)
           model.eval()

           with torch.no_grad():
                 lowerCamelCase__					     = model(**A__	)

                 if isinstance(A__		,     A__	):
                       lowerCamelCase__					     = output.sample

           self.assertIsNotNone(A__	)
           lowerCamelCase__					     = torch.Size((inputs_dict['sample'].shape[0], 1)	)
           self.assertEqual(output.shape		,     A__		,     'Input and output shapes do not match'	)




     def        __snake_case      (			self     :      List[Any]	) ->				Dict:
           pass




     def        __snake_case      (			self     :      Optional[int]	) ->				List[Any]:
           pass




     def        __snake_case      (			self     :      str	) ->				Optional[int]:
           lowerCamelCase__					     = {
               """in_channels""": 1_4,
               """out_channels""": 1_4,
               """down_block_types""": ["""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""],
               """up_block_types""": [],
               """out_block_type""": """ValueFunction""",
               """mid_block_type""": """ValueFunctionMidBlock1D""",
               """block_out_channels""": [3_2, 6_4, 1_2_8, 2_5_6],
               """layers_per_block""": 1,
               """downsample_each_block""": True,
               """use_timestep_embedding""": True,
               """freq_shift""": 1.0,
               """flip_sin_to_cos""": False,
               """time_embedding_type""": """positional""",
               """act_fn""": """mish""",
           }
           lowerCamelCase__					     = self.dummy_input
           return init_dict, inputs_dict




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      Tuple	) ->				str:
           lowerCamelCase__					     = UNetaDModel.from_pretrained(
               'bglick13/hopper-medium-v2-value-function-hor32'		,     output_loading_info=A__		,     subfolder='value_function'	)
           self.assertIsNotNone(A__	)
           self.assertEqual(len(vf_loading_info['missing_keys']	)		,     0	)

           value_function.to(A__	)
           lowerCamelCase__					     = value_function(**self.dummy_input	)

           assert image is not None, "Make sure output is not None"




     @unittest.skipIf(torch_device == 'mps'		,     'mish op not supported in MPS'	)
     def        __snake_case      (			self     :      int	) ->				List[str]:
           lowerCamelCase__					     = UNetaDModel.from_pretrained(
               'bglick13/hopper-medium-v2-value-function-hor32'		,     output_loading_info=A__		,     subfolder='value_function'	)
           torch.manual_seed(0	)
           if torch.cuda.is_available():
                 torch.cuda.manual_seed_all(0	)

           lowerCamelCase__					     = value_function.config.in_channels
           lowerCamelCase__					     = 1_4
           lowerCamelCase__					     = torch.randn((1, seq_len, num_features)	).permute(
               0		,     2		,     1	)  # match original, we can update values and remove
           lowerCamelCase__					     = torch.full((num_features,)		,     0	)

           with torch.no_grad():
                 lowerCamelCase__					     = value_function(A__		,     A__	).sample

           # fmt: off
           lowerCamelCase__					     = torch.tensor([165.25] * seq_len	)
           # fmt: on
           self.assertTrue(torch.allclose(A__		,     A__		,     rtol=1E-3	)	)




     def        __snake_case      (			self     :      List[str]	) ->				List[str]:
           pass


from __future__ import annotations

import os



class SCREAMING_SNAKE_CASE	:
  """simple docstring"""






  lowerCamelCase    :			Union[str, Any]						      =(
      "High card",
      "One pair",
      "Two pairs",
      "Three of a kind",
      "Straight",
      "Flush",
      "Full house",
      "Four of a kind",
      "Straight flush",
      "Royal flush",
  )

  lowerCamelCase    :			Dict						      =(
      "",  # placeholder as tuples are zero-indexed
      "One",
      "Two",
      "Three",
      "Four",
      "Five",
      "Six",
      "Seven",
      "Eight",
      "Nine",
      "Ten",
      "Jack",
      "Queen",
      "King",
      "Ace",
  )







  def __init__(			self :    Tuple       ,							lowerCAmelCase :    str    )							->	None:






     """simple docstring"""







     if not isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        __lowerCAmelCase  :			Tuple					    =						f'''Hand should be of type \'str\': {hand!r}'''
        raise TypeError(lowerCAmelCase    )
     # split removes duplicate whitespaces so no need of strip
     if len(hand.split(""" """    )    ) != 5:
        __lowerCAmelCase  :			Any					    =						f'''Hand should contain only 5 cards: {hand!r}'''
        raise ValueError(lowerCAmelCase    )
     __lowerCAmelCase  :			int					    =						hand
     __lowerCAmelCase  :			Any					    =						0
     __lowerCAmelCase  :			str					    =						0
     __lowerCAmelCase    ,__lowerCAmelCase  :			List[str]					    =						self._internal_state()
     __lowerCAmelCase  :			int					    =						self._get_hand_type()
     __lowerCAmelCase  :			Any					    =						self._card_values[0]







  @property
  def        SCREAMING_SNAKE_CASE    (			self :    Union[str, Any]    )							->	Optional[int]:






     """simple docstring"""







     return self._hand







  def        SCREAMING_SNAKE_CASE    (			self :    Dict       ,							lowerCAmelCase :    PokerHand    )							->	str:






     """simple docstring"""







     if self._hand_type > other._hand_type:
        return "Win"
     elif self._hand_type < other._hand_type:
        return "Loss"
     elif self._first_pair == other._first_pair:
        if self._second_pair == other._second_pair:
           return self._compare_cards(lowerCAmelCase    )
        else:
           return "Win" if self._second_pair > other._second_pair else "Loss"
     return "Win" if self._first_pair > other._first_pair else "Loss"







  def        SCREAMING_SNAKE_CASE    (			self :    int    )							->	str:






     """simple docstring"""







     __lowerCAmelCase  :			Optional[int]					    =						PokerHand._HAND_NAME[self._hand_type - 14]
     __lowerCAmelCase  :			str					    =						PokerHand._CARD_NAME[self._high_card]
     __lowerCAmelCase  :			Optional[Any]					    =						PokerHand._CARD_NAME[self._first_pair]
     __lowerCAmelCase  :			Any					    =						PokerHand._CARD_NAME[self._second_pair]
     if self._hand_type in [22, 19, 18]:
        return name + f''', {high}-high'''
     elif self._hand_type in [21, 17, 15]:
        return name + f''', {paira}s'''
     elif self._hand_type in [20, 16]:
        __lowerCAmelCase  :			List[str]					    =						"""over""" if self._hand_type == 20 else """and"""
        return name + f''', {paira}s {join} {paira}s'''
     elif self._hand_type == 23:
        return name
     else:
        return name + f''', {high}'''







  def        SCREAMING_SNAKE_CASE    (			self :    Dict       ,							lowerCAmelCase :    PokerHand    )							->	str:






     """simple docstring"""







     for index, card_value in enumerate(self._card_values    ):
        if card_value != other._card_values[index]:
           return "Win" if card_value > other._card_values[index] else "Loss"
     return "Tie"







  def        SCREAMING_SNAKE_CASE    (			self :    Optional[int]    )							->	int:






     """simple docstring"""







     if self._is_flush():
        if self._is_five_high_straight() or self._is_straight():
           return 23 if sum(self._card_values    ) == 60 else 22
        return 19
     elif self._is_five_high_straight() or self._is_straight():
        return 18
     return 14 + self._is_same_kind()







  def        SCREAMING_SNAKE_CASE    (			self :    List[Any]    )							->	bool:






     """simple docstring"""







     return len(self._card_suit    ) == 1







  def        SCREAMING_SNAKE_CASE    (			self :    List[str]    )							->	bool:






     """simple docstring"""







     if sorted(self._card_values    ) == [2, 3, 4, 5, 14]:
        if self._card_values[0] == 14:
           # Remember, our list is sorted in reverse order
           __lowerCAmelCase  :			Optional[Any]					    =						self._card_values.pop(0    )
           self._card_values.append(lowerCAmelCase    )
        return True
     return False







  def        SCREAMING_SNAKE_CASE    (			self :    List[str]    )							->	bool:






     """simple docstring"""







     for i in range(4    ):
        if self._card_values[i] - self._card_values[i + 1] != 1:
           return False
     return True







  def        SCREAMING_SNAKE_CASE    (			self :    Optional[int]    )							->	int:






     """simple docstring"""







     __lowerCAmelCase  :			str					    =						0
     for i in range(4    ):
        # Compare two cards at a time, if they are same increase 'kind',
        # add the value of the card to val1, if it is repeating again we
        # will add 2 to 'kind' as there are now 3 cards with same value.
        # If we get card of different value than val1, we will do the same
        # thing with val2
        if self._card_values[i] == self._card_values[i + 1]:
           if not vala:
              __lowerCAmelCase  :			List[str]					    =						self._card_values[i]
              kind += 1
           elif vala == self._card_values[i]:
              kind += 2
           elif not vala:
              __lowerCAmelCase  :			Optional[Any]					    =						self._card_values[i]
              kind += 1
           elif vala == self._card_values[i]:
              kind += 2
        # For consistency in hand type (look at note in _get_hand_type function)
     __lowerCAmelCase  :			List[Any]					    =						kind + 2 if kind in [4, 5] else kind
     # first meaning first pair to compare in 'compare_with'
     __lowerCAmelCase  :			Optional[int]					    =						max(lowerCAmelCase       ,							lowerCAmelCase    )
     __lowerCAmelCase  :			Optional[Any]					    =						min(lowerCAmelCase       ,							lowerCAmelCase    )
     # If it's full house (three count pair + two count pair), make sure
     # first pair is three count and if not then switch them both.
     if kind == 6 and self._card_values.count(lowerCAmelCase    ) != 3:
        __lowerCAmelCase    ,__lowerCAmelCase  :			Tuple					    =						second, first
     __lowerCAmelCase  :			Optional[Any]					    =						first
     __lowerCAmelCase  :			Union[str, Any]					    =						second
     return kind







  def        SCREAMING_SNAKE_CASE    (			self :    List[Any]    )							->	tuple[list[int], set[str]]:






     """simple docstring"""







     __lowerCAmelCase  :			dict					    =						{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
     __lowerCAmelCase  :			Optional[Any]					    =						self._hand.translate(str.maketrans(lowerCAmelCase    )    ).split()
     __lowerCAmelCase  :			List[str]					    =						[int(card[:-1]    ) for card in new_hand]
     __lowerCAmelCase  :			str					    =						{card[-1] for card in new_hand}
     return sorted(lowerCAmelCase       ,							reverse=lowerCAmelCase    ), card_suit







  def __repr__(			self :    List[str]    )							->	Any:






     """simple docstring"""







     return f'''{self.__class__}("{self._hand}")'''







  def __str__(			self :    Any    )							->	Any:






     """simple docstring"""







     return self._hand







  def __eq__(			self :    Union[str, Any]       ,							lowerCAmelCase :    List[Any]    )							->	Union[str, Any]:






     """simple docstring"""







     if isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        return self.compare_with(lowerCAmelCase    ) == "Tie"
     return NotImplemented







  def __lt__(			self :    Dict       ,							lowerCAmelCase :    str    )							->	List[str]:






     """simple docstring"""







     if isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        return self.compare_with(lowerCAmelCase    ) == "Loss"
     return NotImplemented







  def __le__(			self :    str       ,							lowerCAmelCase :    int    )							->	Union[str, Any]:






     """simple docstring"""







     if isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        return self < other or self == other
     return NotImplemented







  def __gt__(			self :    Dict       ,							lowerCAmelCase :    str    )							->	Optional[Any]:






     """simple docstring"""







     if isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        return not self < other and self != other
     return NotImplemented







  def __ge__(			self :    Tuple       ,							lowerCAmelCase :    Tuple    )							->	Dict:






     """simple docstring"""







     if isinstance(lowerCAmelCase       ,							lowerCAmelCase    ):
        return not self < other
     return NotImplemented







  def __hash__(			self :    List[str]    )							->	str:






     """simple docstring"""







     return object.__hash__(self    )






def 	snake_case_      ()			->	int:
   # Solution for problem number 54 from Project Euler
   # Input from poker_hands.txt file
   __lowerCAmelCase  :			str					    =						0
   __lowerCAmelCase  :			List[str]					    =						os.path.abspath(os.path.dirname(__A     )     )
   __lowerCAmelCase  :			Optional[Any]					    =						os.path.join(__A					,   """poker_hands.txt"""     )
   with open(__A     ) as file_hand:
      for line in file_hand:
         __lowerCAmelCase  :			Union[str, Any]					    =						line[:1_4].strip()
         __lowerCAmelCase  :			Optional[int]					    =						line[1_5:].strip()
         __lowerCAmelCase    ,__lowerCAmelCase  :			List[str]					    =						PokerHand(__A     ), PokerHand(__A     )
         __lowerCAmelCase  :			List[str]					    =						player.compare_with(__A     )
         if output == "Win":
            answer += 1
   return answer


if __name__ == "__main__":
   solution()


