




import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


a_ 		=  {
    "vit_b32": {
        "embed_dim": 512,
        "image_resolution": 768,
        "context_length": 16,
        "vocab_size": 4_9408,
        "vision_layers": 12,
        "vision_width": 768,
        "vision_patch_size": 32,
        "transformer_width": 512,
        "transformer_heads": 8,
        "transformer_layers": 12,
    },
    "vit_b16": {
        "embed_dim": 512,
        "image_resolution": 768,
        "context_length": 16,
        "vocab_size": 4_9408,
        "vision_layers": 12,
        "vision_width": 768,
        "vision_patch_size": 16,
        "transformer_width": 512,
        "transformer_heads": 8,
        "transformer_layers": 12,
    },
    "vit_l14": {
        "embed_dim": 768,
        "image_resolution": 840,
        "context_length": 16,
        "vocab_size": 4_9408,
        "vision_layers": 24,
        "vision_width": 1024,
        "vision_patch_size": 14,
        "transformer_width": 768,
        "transformer_heads": 12,
        "transformer_layers": 12,
    },
}




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_=""       ,  lowercase_="/"   )							->						Optional[int]:

    """simple docstring"""


    __UpperCamelCase			=    []

    for k, v in params.items():
        __UpperCamelCase			=    parent_key + sep + k if parent_key else k

        if isinstance(lowercase_       ,  collections.MutableMapping   ):
            items.extend(flatten_nested_dict(lowercase_       ,  lowercase_       ,  sep=lowercase_   ).items()   )
        else:
            items.append((new_key, v)   )
    return dict(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						str:

    """simple docstring"""


    return jax.tree_util.tree_map(lambda lowercase_   : x.astype(jnp.floataa   ) if x.dtype == jnp.bfloataa else x       ,  lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Optional[int]:

    """simple docstring"""


    __UpperCamelCase		,   __UpperCamelCase		,   __UpperCamelCase			=    pt_attn_layer.in_proj_weight.chunk(3       ,  dim=0   )
    __UpperCamelCase		,   __UpperCamelCase		,   __UpperCamelCase			=    pt_attn_layer.in_proj_bias.chunk(3       ,  dim=0   )

    __UpperCamelCase			=    pt_attn_layer.out_proj.weight
    __UpperCamelCase			=    pt_attn_layer.out_proj.bias

    __UpperCamelCase			=    q_proj
    __UpperCamelCase			=    q_proj_bias

    __UpperCamelCase			=    k_proj
    __UpperCamelCase			=    k_proj_bias

    __UpperCamelCase			=    v_proj
    __UpperCamelCase			=    v_proj_bias

    __UpperCamelCase			=    out_proj_weights
    __UpperCamelCase			=    out_proj_bias




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Dict:

    """simple docstring"""


    copy_linear(hf_mlp.fca       ,  pt_mlp.c_fc   )
    copy_linear(hf_mlp.fca       ,  pt_mlp.c_proj   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						int:

    """simple docstring"""


    __UpperCamelCase			=    pt_linear.weight
    __UpperCamelCase			=    pt_linear.bias




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Optional[Any]:

    """simple docstring"""


    copy_linear(hf_layer.layer_norma       ,  pt_layer.ln_a   )
    copy_linear(hf_layer.layer_norma       ,  pt_layer.ln_a   )

    # copy MLP
    copy_mlp(hf_layer.mlp       ,  pt_layer.mlp   )

    # copy attn
    copy_attn_layer(hf_layer.self_attn       ,  pt_layer.attn   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Any:

    """simple docstring"""


    for hf_layer, pt_layer in zip(lowercase_       ,  lowercase_   ):
        copy_layer(lowercase_       ,  lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						List[str]:

    """simple docstring"""


    __UpperCamelCase			=    pt_model.token_embedding.weight
    __UpperCamelCase			=    pt_model.positional_embedding

    # copy layer norm
    copy_linear(hf_encoder.final_layer_norm       ,  pt_model.ln_final   )

    # copy hidden layers
    copy_layers(hf_encoder.encoder.layers       ,  pt_model.transformer.resblocks   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Optional[int]:

    """simple docstring"""


    __UpperCamelCase			=    pt_model.text_projection.data.T

    # copy text encoder
    copy_encoder(hf_model.text_model       ,  lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Union[str, Any]:

    """simple docstring"""


    __UpperCamelCase			=    pt_model.visual.proj.data.T

    # copy layer norms
    copy_linear(hf_model.vision_model.pre_layernorm       ,  pt_model.visual.ln_pre   )
    copy_linear(hf_model.vision_model.post_layernorm       ,  pt_model.visual.ln_post   )

    # copy embeds
    __UpperCamelCase			=    pt_model.visual.conva.weight.data
    __UpperCamelCase			=    pt_model.visual.class_embedding
    __UpperCamelCase			=    pt_model.visual.positional_embedding.data

    # copy encoder
    copy_layers(hf_model.vision_model.encoder.layers       ,  pt_model.visual.transformer.resblocks   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						List[str]:

    """simple docstring"""


    __UpperCamelCase			=    flatten_nested_dict(flax_params['''backbone''']['''merged_class_token''']   )

    __UpperCamelCase			=    torch.from_numpy(flax_class_token_params['''scale''']   )
    __UpperCamelCase			=    torch.from_numpy(flax_class_token_params['''bias''']   )
    __UpperCamelCase			=    nn.Parameter(lowercase_   )
    __UpperCamelCase			=    nn.Parameter(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Any:

    """simple docstring"""


    __UpperCamelCase			=    hf_model.state_dict()
    __UpperCamelCase			=    {}

    # Rename class prediction head flax params to pytorch HF
    __UpperCamelCase			=    flatten_nested_dict(flax_params['''class_head''']   )

    for flax_key, v in flax_class_params.items():
        __UpperCamelCase			=    flax_key.replace('''/'''       ,  '''.'''   )
        __UpperCamelCase			=    torch_key.replace('''.kernel'''       ,  '''.weight'''   )
        __UpperCamelCase			=    torch_key.replace('''Dense_0'''       ,  '''dense0'''   )
        __UpperCamelCase			=    '''class_head.''' + torch_key

        if "weight" in torch_key and v.ndim == 2:
            __UpperCamelCase			=    v.T

        __UpperCamelCase			=    nn.Parameter(torch.from_numpy(lowercase_   )   )

    # Rename box prediction box flax params to pytorch HF
    __UpperCamelCase			=    flatten_nested_dict(flax_params['''obj_box_head''']   )

    for flax_key, v in flax_box_params.items():
        __UpperCamelCase			=    flax_key.replace('''/'''       ,  '''.'''   )
        __UpperCamelCase			=    torch_key.replace('''.kernel'''       ,  '''.weight'''   )
        __UpperCamelCase			=    torch_key.replace('''_'''       ,  ''''''   ).lower()
        __UpperCamelCase			=    '''box_head.''' + torch_key

        if "weight" in torch_key and v.ndim == 2:
            __UpperCamelCase			=    v.T

        __UpperCamelCase			=    nn.Parameter(torch.from_numpy(lowercase_   )   )

    # Copy flax params to PyTorch params
    for name, param in new_params.items():
        if name in pt_params.keys():
            pt_params[name].copy_(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						int:

    """simple docstring"""


    for k, v in flax_attn_params.items():
        if k.startswith('''transformer'''   ):
            __UpperCamelCase			=    k.replace('''transformer.resblocks'''       ,  '''text_model.encoder.layers'''   )
        else:
            __UpperCamelCase			=    k.replace('''visual.transformer.resblocks'''       ,  '''vision_model.encoder.layers'''   )

        __UpperCamelCase			=    torch_key.replace('''attn'''       ,  '''self_attn'''   )
        __UpperCamelCase			=    torch_key.replace('''key'''       ,  '''k_proj'''   )
        __UpperCamelCase			=    torch_key.replace('''value'''       ,  '''v_proj'''   )
        __UpperCamelCase			=    torch_key.replace('''query'''       ,  '''q_proj'''   )
        __UpperCamelCase			=    torch_key.replace('''out'''       ,  '''out_proj'''   )

        if "bias" in torch_key and v.ndim == 2:
            __UpperCamelCase			=    v.shape[0] * v.shape[1]
            __UpperCamelCase			=    v.reshape(lowercase_   )

        if "weight" in torch_key and "out" in torch_key:
            __UpperCamelCase			=    (v.shape[0] * v.shape[1], v.shape[2])
            __UpperCamelCase			=    v.reshape(lowercase_   ).T

        if "weight" in torch_key and "out" not in torch_key:
            __UpperCamelCase			=    (v.shape[0], v.shape[1] * v.shape[2])
            __UpperCamelCase			=    v.reshape(lowercase_   ).T

        # Copy flax CLIP attn params to HF PyTorch params
        __UpperCamelCase			=    torch.from_numpy(lowercase_   )
        hf_backbone.state_dict()[torch_key].copy_(lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						Union[str, Any]:

    """simple docstring"""


    __UpperCamelCase			=    {}
    __UpperCamelCase			=    []

    for k, v in params.items():
        if "attn." in k:
            __UpperCamelCase			=    k[: k.rindex('''attn.'''   ) + 5]
            if base in processed_attn_layers:
                continue

            processed_attn_layers.append(lowercase_   )
            __UpperCamelCase			=    params[base + '''out.weight'''].shape[-1]
            __UpperCamelCase			=    params[base + '''out.weight'''].reshape(lowercase_       ,  lowercase_   ).T
            __UpperCamelCase			=    params[base + '''out.bias''']
        else:
            __UpperCamelCase			=    v
    return new_params




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						List[str]:

    """simple docstring"""


    __UpperCamelCase			=    CLIP(**lowercase_   )
    torch_model.eval()
    __UpperCamelCase			=    torch_model.state_dict()

    __UpperCamelCase			=    flatten_nested_dict(flax_params['''backbone''']['''clip''']   )
    __UpperCamelCase			=    {}

    for flax_key, v in flax_clip_params.items():
        __UpperCamelCase			=    flax_key.replace('''/'''       ,  '''.'''   )
        __UpperCamelCase			=    torch_key.replace('''text.token_embedding.embedding'''       ,  '''token_embedding.kernel'''   )

        if (
            torch_key.startswith('''text.transformer'''   )
            or torch_key.startswith('''text.text_projection'''   )
            or torch_key.startswith('''text.ln_final'''   )
            or torch_key.startswith('''text.positional_embedding'''   )
        ):
            __UpperCamelCase			=    torch_key[5:]

        __UpperCamelCase			=    torch_key.replace('''text_projection.kernel'''       ,  '''text_projection'''   )
        __UpperCamelCase			=    torch_key.replace('''visual.proj.kernel'''       ,  '''visual.proj'''   )
        __UpperCamelCase			=    torch_key.replace('''.scale'''       ,  '''.weight'''   )
        __UpperCamelCase			=    torch_key.replace('''.kernel'''       ,  '''.weight'''   )

        if "conv" in torch_key or "downsample.0.weight" in torch_key:
            __UpperCamelCase			=    v.transpose(3       ,  2       ,  0       ,  1   )

        elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
            # Fully connected layers are transposed, embeddings are not
            __UpperCamelCase			=    v.T

        __UpperCamelCase			=    v

    __UpperCamelCase			=    _convert_attn_layers(lowercase_   )
    new_torch_params.update(lowercase_   )
    __UpperCamelCase			=    {}

    # Copy flax CLIP backbone params to PyTorch params
    for name, param in new_torch_params.items():
        if name in torch_clip_params.keys():
            __UpperCamelCase			=    torch.from_numpy(new_torch_params[name]   )
            torch_clip_params[name].copy_(lowercase_   )
        else:
            __UpperCamelCase			=    param

    return torch_clip_params, torch_model, attn_params




@torch.no_grad()
def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_=None   )							->						List[str]:

    """simple docstring"""


    __UpperCamelCase			=    Repository(lowercase_       ,  clone_from=F"google/{pytorch_dump_folder_path}"   )
    repo.git_pull()

    if config_path is not None:
        __UpperCamelCase			=    OwlViTConfig.from_pretrained(lowercase_   )
    else:
        __UpperCamelCase			=    OwlViTConfig()

    __UpperCamelCase			=    OwlViTModel(lowercase_   ).eval()
    __UpperCamelCase			=    OwlViTForObjectDetection(lowercase_   ).eval()

    copy_text_model_and_projection(lowercase_       ,  lowercase_   )
    copy_vision_model_and_projection(lowercase_       ,  lowercase_   )
    __UpperCamelCase			=    pt_backbone.logit_scale
    copy_flax_attn_params(lowercase_       ,  lowercase_   )

    __UpperCamelCase			=    hf_backbone
    copy_class_merge_token(lowercase_       ,  lowercase_   )
    copy_class_box_heads(lowercase_       ,  lowercase_   )

    # Save HF model
    hf_model.save_pretrained(repo.local_dir   )

    # Initialize image processor
    __UpperCamelCase			=    OwlViTImageProcessor(
        size=config.vision_config.image_size       ,  crop_size=config.vision_config.image_size   )
    # Initialize tokenizer
    __UpperCamelCase			=    CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''       ,  pad_token='''!'''       ,  model_max_length=16   )

    # Initialize processor
    __UpperCamelCase			=    OwlViTProcessor(image_processor=lowercase_       ,  tokenizer=lowercase_   )
    image_processor.save_pretrained(repo.local_dir   )
    processor.save_pretrained(repo.local_dir   )

    repo.git_add()
    repo.git_commit('''Upload model and processor'''   )
    repo.git_push()


if __name__ == "__main__":
 a_ 		=  argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--owlvit_version",
     default=None,
     type=str,
     required=True,
     help="OWL-ViT model name [clip_b16, clip_b32, clip_l14].",
 )
 parser.add_argument(
     "--owlvit_checkpoint", default=None, type=str, required=True, help="Path to flax model checkpoint."
 )
 parser.add_argument("--hf_config", default=None, type=str, required=True, help="Path to HF model config.")
 parser.add_argument(
     "--pytorch_dump_folder_path", default="hf_model", type=str, help="Path to the output PyTorch model."
 )
 a_ 		=  parser.parse_args()

 # Initialize PyToch clip model
 a_ 		=  args.owlvit_version
 if model_name == "clip_b16":
  a_ 		=  CONFIGS["vit_b16"]
 elif model_name == "clip_b32":
  a_ 		=  CONFIGS["vit_b32"]
 elif model_name == "clip_l14":
  a_ 		=  CONFIGS["vit_l14"]

 # Load from checkpoint and convert params to float-32
 a_ 		=  checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["optimizer"]["target"]
 a_ 		=  jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
 del variables

 # Convert CLIP backbone
 a_		,     a_		,     a_ 		=  convert_clip_backbone(flax_params, torch_config)

 convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)








from __future__ import annotations

import os





class 						__lowercase:


       """simple docstring"""







       UpperCamelCase_				 =							(
           '''High card''',
           '''One pair''',
           '''Two pairs''',
           '''Three of a kind''',
           '''Straight''',
           '''Flush''',
           '''Full house''',
           '''Four of a kind''',
           '''Straight flush''',
           '''Royal flush''',
       )

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



       def __init__(     self					:			Dict  ,      _lowerCAmelCase					:			str       )					->   None:
         if not isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           _lowerCAmelCase						=		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						=		F'''Hand should contain only 5 cards: {hand!r}'''
           raise ValueError(_lowerCAmelCase       )
         _lowerCAmelCase						=		hand
         _lowerCAmelCase						=		0
         _lowerCAmelCase						=		0
         _lowerCAmelCase	,       _lowerCAmelCase						=		self._internal_state()
         _lowerCAmelCase						=		self._get_hand_type()
         _lowerCAmelCase						=		self._card_values[0]



       @property
       def SCREAMING_SNAKE_CASE_				(     self					:			Any       )					->   List[Any]:
         return self._hand



       def SCREAMING_SNAKE_CASE_				(     self					:			int  ,      _lowerCAmelCase					:			PokerHand       )					->   str:
         # Breaking the tie works on the following order of precedence:
         # 1. First pair (default 0)
         # 2. Second pair (default 0)
         # 3. Compare all cards in reverse order because they are sorted.

         # First pair and second pair will only be a non-zero value if the card
         # type is either from the following:
         # 21: Four of a kind
         # 20: Full house
         # 17: Three of a kind
         # 16: Two pairs
         # 15: One pair
         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					:			str       )					->   str:
         _lowerCAmelCase						=		PokerHand._HAND_NAME[self._hand_type - 14]
         _lowerCAmelCase						=		PokerHand._CARD_NAME[self._high_card]
         _lowerCAmelCase						=		PokerHand._CARD_NAME[self._first_pair]
         _lowerCAmelCase						=		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						=		'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					:			Any  ,      _lowerCAmelCase					:			PokerHand       )					->   str:
         # Enumerate gives us the index as well as the element of a list
         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[Any]       )					->   int:
         # Number representing the type of hand internally:
         # 23: Royal flush
         # 22: Straight flush
         # 21: Four of a kind
         # 20: Full house
         # 19: Flush
         # 18: Straight
         # 17: Three of a kind
         # 16: Two pairs
         # 15: One pair
         # 14: High card
         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					:			Any       )					->   bool:
         return len(self._card_suit       ) == 1



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   bool:
         # If a card is a five high straight (low ace) change the location of
         # ace from the start of the list to the end. Check whether the first
         # element is ace or not. (Don't want to change again)
         # Five high straight (low ace): AH 2H 3S 4C 5D
         # Why use sorted here? One call to this function will mutate the list to
         # [5, 4, 3, 2, 14] and so for subsequent calls (which will be rare) we
         # need to compare the sorted version.
         # Refer test_multiple_calls_five_high_straight in test_poker_hand.py
         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						=		self._card_values.pop(0       )
             self._card_values.append(_lowerCAmelCase       )
           return True
         return False



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   bool:
         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					:			Dict       )					->   int:
         # Kind Values for internal use:
         # 7: Four of a kind
         # 6: Full house
         # 3: Three of a kind
         # 2: Two pairs
         # 1: One pair
         # 0: False
         _lowerCAmelCase						=		_lowerCAmelCase						=		_lowerCAmelCase						=		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						=		self._card_values[i]
               kind += 1
             elif vala == self._card_values[i]:
               kind += 2
             elif not vala:
               _lowerCAmelCase						=		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						=		kind + 2 if kind in [4, 5] else kind
         # first meaning first pair to compare in 'compare_with'
         _lowerCAmelCase						=		max(_lowerCAmelCase  ,      _lowerCAmelCase       )
         _lowerCAmelCase						=		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						=		second, first
         _lowerCAmelCase						=		first
         _lowerCAmelCase						=		second
         return kind



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]       )					->   tuple[list[int], set[str]]:
         # Internal representation of hand as a list of card values and
         # a set of card suit
         _lowerCAmelCase						=		{"T": "10", "J": "11", "Q": "12", "K": "13", "A": "14"}
         _lowerCAmelCase						=		self._hand.translate(str.maketrans(_lowerCAmelCase       )       ).split()
         _lowerCAmelCase						=		[int(card[:-1]       ) for card in new_hand]
         _lowerCAmelCase						=		{card[-1] for card in new_hand}
         return sorted(_lowerCAmelCase  ,      reverse=_lowerCAmelCase       ), card_suit



       def __repr__(     self					:			Tuple       )					->   Optional[Any]:
         return F'''{self.__class__}("{self._hand}")'''



       def __str__(     self					:			Optional[int]       )					->   Union[str, Any]:
         return self._hand



       def __eq__(     self					:			Optional[int]  ,      _lowerCAmelCase					:			str       )					->   Tuple:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return self.compare_with(_lowerCAmelCase       ) == "Tie"
         return NotImplemented



       def __lt__(     self					:			List[Any]  ,      _lowerCAmelCase					:			int       )					->   List[str]:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return self.compare_with(_lowerCAmelCase       ) == "Loss"
         return NotImplemented



       def __le__(     self					:			str  ,      _lowerCAmelCase					:			Dict       )					->   str:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return self < other or self == other
         return NotImplemented



       def __gt__(     self					:			Union[str, Any]  ,      _lowerCAmelCase					:			List[Any]       )					->   int:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return not self < other and self != other
         return NotImplemented



       def __ge__(     self					:			Dict  ,      _lowerCAmelCase					:			Dict       )					->   Optional[Any]:
         if isinstance(_lowerCAmelCase  ,      _lowerCAmelCase       ):
           return not self < other
         return NotImplemented






       def __hash__(     self					:			Optional[int]       )					->   List[Any]:
         return object.__hash__(self       )



def 	_a  (					):






  """simple docstring"""




  _lowerCAmelCase						=		0
  _lowerCAmelCase						=		os.path.abspath(os.path.dirname(__SCREAMING_SNAKE_CASE    )    )
  _lowerCAmelCase						=		os.path.join(__SCREAMING_SNAKE_CASE		,				'poker_hands.txt'    )
  with open(__SCREAMING_SNAKE_CASE    ) as file_hand:
    for line in file_hand:
      _lowerCAmelCase						=		line[:14].strip()
      _lowerCAmelCase						=		line[15:].strip()
      _lowerCAmelCase	,       _lowerCAmelCase						=		PokerHand(__SCREAMING_SNAKE_CASE    ), PokerHand(__SCREAMING_SNAKE_CASE    )
      _lowerCAmelCase						=		player.compare_with(__SCREAMING_SNAKE_CASE    )
      if output == "Win":
        answer += 1
  return answer


if __name__ == "__main__":
       solution()
