import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)







def  __UpperCamelCase    (						A ,							A							):
     UpperCamelCase__										=      XCLIPTextConfig()

     # derive patch size from model name
     UpperCamelCase__										=      model_name.find('''patch'''							)
     UpperCamelCase__										=      int(model_name[start_idx + len('''patch'''							) : start_idx + len('''patch'''							) + 2]							)
     UpperCamelCase__										=      XCLIPVisionConfig(patch_size=A ,							num_frames=A							)

     if "large" in model_name:
          UpperCamelCase__										=      768
          UpperCamelCase__										=      3072
          UpperCamelCase__										=      12

          UpperCamelCase__										=      1024
          UpperCamelCase__										=      4096
          UpperCamelCase__										=      16
          UpperCamelCase__										=      24
          UpperCamelCase__										=      768
          UpperCamelCase__										=      3072

     if model_name == "xclip-large-patch14-16-frames":
          UpperCamelCase__										=      336

     UpperCamelCase__										=      XCLIPConfig.from_text_vision_configs(A ,							A							)

     if "large" in model_name:
          UpperCamelCase__										=      768

     return config







def  __UpperCamelCase    (						A							):
     # text encoder
     if name == "token_embedding.weight":
          UpperCamelCase__										=      name.replace('''token_embedding.weight''' ,							'''text_model.embeddings.token_embedding.weight'''							)
     if name == "positional_embedding":
          UpperCamelCase__										=      name.replace('''positional_embedding''' ,							'''text_model.embeddings.position_embedding.weight'''							)
     if "ln_1" in name:
          UpperCamelCase__										=      name.replace('''ln_1''' ,							'''layer_norm1'''							)
     if "ln_2" in name:
          UpperCamelCase__										=      name.replace('''ln_2''' ,							'''layer_norm2'''							)
     if "c_fc" in name:
          UpperCamelCase__										=      name.replace('''c_fc''' ,							'''fc1'''							)
     if "c_proj" in name:
          UpperCamelCase__										=      name.replace('''c_proj''' ,							'''fc2'''							)
     if name.startswith('''transformer.resblocks'''							):
          UpperCamelCase__										=      name.replace('''transformer.resblocks''' ,							'''text_model.encoder.layers'''							)
     if "attn.out_proj" in name and "message" not in name:
          UpperCamelCase__										=      name.replace('''attn.out_proj''' ,							'''self_attn.out_proj'''							)
     if "ln_final" in name:
          UpperCamelCase__										=      name.replace('''ln_final''' ,							'''text_model.final_layer_norm'''							)
     # visual encoder
     if name == "visual.class_embedding":
          UpperCamelCase__										=      name.replace('''visual.class_embedding''' ,							'''vision_model.embeddings.class_embedding'''							)
     if name == "visual.positional_embedding":
          UpperCamelCase__										=      name.replace('''visual.positional_embedding''' ,							'''vision_model.embeddings.position_embedding.weight'''							)
     if name.startswith('''visual.transformer.resblocks'''							):
          UpperCamelCase__										=      name.replace('''visual.transformer.resblocks''' ,							'''vision_model.encoder.layers'''							)
     if "visual.conv1" in name:
          UpperCamelCase__										=      name.replace('''visual.conv1''' ,							'''vision_model.embeddings.patch_embedding'''							)
     if "visual.ln_pre" in name:
          UpperCamelCase__										=      name.replace('''visual.ln_pre''' ,							'''vision_model.pre_layernorm'''							)
     if "visual.ln_post" in name:
          UpperCamelCase__										=      name.replace('''visual.ln_post''' ,							'''vision_model.post_layernorm'''							)
     if "visual.proj" in name:
          UpperCamelCase__										=      name.replace('''visual.proj''' ,							'''visual_projection.weight'''							)
     if "text_projection" in name:
          UpperCamelCase__										=      name.replace('''text_projection''' ,							'''text_projection.weight'''							)
     # things on top
     if "prompts_visual_proj" in name:
          UpperCamelCase__										=      name.replace('''prompts_visual_proj''' ,							'''prompts_visual_projection'''							)
     if "prompts_visual_ln" in name:
          UpperCamelCase__										=      name.replace('''prompts_visual_ln''' ,							'''prompts_visual_layernorm'''							)
     # mit
     if name == "mit.positional_embedding":
          UpperCamelCase__										=      name.replace('''positional''' ,							'''position'''							)
     if name.startswith('''mit.resblocks'''							):
          UpperCamelCase__										=      name.replace('''mit.resblocks''' ,							'''mit.encoder.layers'''							)
     # prompts generator
     if name.startswith('''prompts_generator.norm'''							):
          UpperCamelCase__										=      name.replace('''prompts_generator.norm''' ,							'''prompts_generator.layernorm'''							)

     return name







def  __UpperCamelCase    (						A ,							A							):
     for key in orig_state_dict.copy().keys():
          UpperCamelCase__										=      orig_state_dict.pop(A							)

          if "attn.in_proj" in key:
               UpperCamelCase__										=      key.split('''.'''							)
               if key.startswith('''visual'''							):
                    UpperCamelCase__										=      key_split[3]
                    UpperCamelCase__										=      config.vision_config.hidden_size
                    if "message_attn" in key:
                         if "weight" in key:
                              UpperCamelCase__										=      val[
                                  :dim, :
                              ]
                              UpperCamelCase__										=      val[
                                  dim : dim * 2, :
                              ]
                              UpperCamelCase__										=      val[
                                  -dim:, :
                              ]
                         else:
                              UpperCamelCase__										=      val[
                                  :dim
                              ]
                              UpperCamelCase__										=      val[
                                  dim : dim * 2
                              ]
                              UpperCamelCase__										=      val[
                                  -dim:
                              ]
                    else:
                         if "weight" in key:
                              UpperCamelCase__										=      val[
                                  :dim, :
                              ]
                              UpperCamelCase__										=      val[
                                  dim : dim * 2, :
                              ]
                              UpperCamelCase__										=      val[
                                  -dim:, :
                              ]
                         else:
                              UpperCamelCase__										=      val[:dim]
                              UpperCamelCase__										=      val[
                                  dim : dim * 2
                              ]
                              UpperCamelCase__										=      val[-dim:]
               elif key.startswith('''mit'''							):
                    UpperCamelCase__										=      key_split[2]
                    UpperCamelCase__										=      config.vision_config.mit_hidden_size
                    if "weight" in key:
                         UpperCamelCase__										=      val[:dim, :]
                         UpperCamelCase__										=      val[dim : dim * 2, :]
                         UpperCamelCase__										=      val[-dim:, :]
                    else:
                         UpperCamelCase__										=      val[:dim]
                         UpperCamelCase__										=      val[dim : dim * 2]
                         UpperCamelCase__										=      val[-dim:]
               else:
                    UpperCamelCase__										=      key_split[2]
                    UpperCamelCase__										=      config.text_config.hidden_size
                    if "weight" in key:
                         UpperCamelCase__										=      val[:dim, :]
                         UpperCamelCase__										=      val[
                             dim : dim * 2, :
                         ]
                         UpperCamelCase__										=      val[-dim:, :]
                    else:
                         UpperCamelCase__										=      val[:dim]
                         UpperCamelCase__										=      val[
                             dim : dim * 2
                         ]
                         UpperCamelCase__										=      val[-dim:]
          else:
               UpperCamelCase__										=      rename_key(A							)
               if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
                    UpperCamelCase__										=      val.T
               UpperCamelCase__										=      val

     return orig_state_dict







def  __UpperCamelCase    (						A							):
     if num_frames == 8:
          UpperCamelCase__										=      '''eating_spaghetti_8_frames.npy'''
     elif num_frames == 16:
          UpperCamelCase__										=      '''eating_spaghetti.npy'''
     elif num_frames == 32:
          UpperCamelCase__										=      '''eating_spaghetti_32_frames.npy'''
     UpperCamelCase__										=      hf_hub_download(
         repo_id='''hf-internal-testing/spaghetti-video''' ,							filename=A ,							repo_type='''dataset''' ,							)
     UpperCamelCase__										=      np.load(A							)
     return list(A							)







def  __UpperCamelCase    (						A ,							A=None ,							A=False							):
     UpperCamelCase__										=      {
         # fully supervised kinetics-400 checkpoints
         '''xclip-base-patch32''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth''',
         '''xclip-base-patch32-16-frames''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth'''
         ),
         '''xclip-base-patch16''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth''',
         '''xclip-base-patch16-16-frames''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth'''
         ),
         '''xclip-large-patch14''': '''https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb''',
         '''xclip-large-patch14-16-frames''': '''https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f''',
         # fully supervised kinetics-600 checkpoints
         '''xclip-base-patch16-kinetics-600''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth'''
         ),
         '''xclip-base-patch16-kinetics-600-16-frames''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth'''
         ),
         '''xclip-large-patch14-kinetics-600''': '''https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be''',
         # few shot
         '''xclip-base-patch16-hmdb-2-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth'''
         ),
         '''xclip-base-patch16-hmdb-4-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth'''
         ),
         '''xclip-base-patch16-hmdb-8-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth'''
         ),
         '''xclip-base-patch16-hmdb-16-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth'''
         ),
         '''xclip-base-patch16-ucf-2-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth'''
         ),
         '''xclip-base-patch16-ucf-4-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth'''
         ),
         '''xclip-base-patch16-ucf-8-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth'''
         ),
         '''xclip-base-patch16-ucf-16-shot''': (
             '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth'''
         ),
         # zero shot
         '''xclip-base-patch16-zero-shot''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth''',
     }

     UpperCamelCase__										=      model_to_url[model_name]
     UpperCamelCase__										=      8
     if "16-frames" in model_name:
          UpperCamelCase__										=      16
     elif "shot" in model_name:
          UpperCamelCase__										=      32

     UpperCamelCase__										=      get_xclip_config(A ,							A							)
     UpperCamelCase__										=      XCLIPModel(A							)
     model.eval()

     if "drive" in checkpoint_url:
          UpperCamelCase__										=      '''pytorch_model.bin'''
          gdown.cached_download(A ,							A ,							quiet=A							)
          UpperCamelCase__										=      torch.load(A ,							map_location='''cpu'''							)['''model''']
     else:
          UpperCamelCase__										=      torch.hub.load_state_dict_from_url(A							)['''model''']

     UpperCamelCase__										=      convert_state_dict(A ,							A							)

     UpperCamelCase__										=      XCLIPModel(A							)
     UpperCamelCase__						,       UpperCamelCase__										=      model.load_state_dict(A ,							strict=A							)
     assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
     model.eval()

     UpperCamelCase__										=      336 if model_name == '''xclip-large-patch14-16-frames''' else 224
     UpperCamelCase__										=      VideoMAEImageProcessor(size=A							)
     UpperCamelCase__										=      CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''							)
     UpperCamelCase__										=      CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32'''							)
     UpperCamelCase__										=      XCLIPProcessor(image_processor=A ,							tokenizer=A							)

     UpperCamelCase__										=      prepare_video(A							)
     UpperCamelCase__										=      processor(
         text=['''playing sports''', '''eating spaghetti''', '''go shopping'''] ,							videos=A ,							return_tensors='''pt''' ,							padding=A							)

     print('''Shape of pixel values:''' ,							inputs.pixel_values.shape							)

     with torch.no_grad():
          UpperCamelCase__										=      model(**A							)

     # Verify outputs
     UpperCamelCase__										=      outputs.logits_per_video
     UpperCamelCase__										=      logits_per_video.softmax(dim=1							)
     print('''Probs:''' ,							A							)
     # kinetics-400
     if model_name == "xclip-base-patch32":
          UpperCamelCase__										=      torch.tensor([[0.00_19, 0.99_51, 0.00_30]]							)
     elif model_name == "xclip-base-patch32-16-frames":
          UpperCamelCase__										=      torch.tensor([[7.09_99e-04, 9.98_83e-01, 4.55_80e-04]]							)
     elif model_name == "xclip-base-patch16":
          UpperCamelCase__										=      torch.tensor([[0.00_83, 0.96_81, 0.02_36]]							)
     elif model_name == "xclip-base-patch16-16-frames":
          UpperCamelCase__										=      torch.tensor([[7.69_37e-04, 9.97_28e-01, 1.94_73e-03]]							)
     elif model_name == "xclip-large-patch14":
          UpperCamelCase__										=      torch.tensor([[0.00_62, 0.98_64, 0.00_75]]							)
     elif model_name == "xclip-large-patch14-16-frames":
          UpperCamelCase__										=      torch.tensor([[3.38_77e-04, 9.99_37e-01, 2.88_88e-04]]							)
     # kinetics-600
     elif model_name == "xclip-base-patch16-kinetics-600":
          UpperCamelCase__										=      torch.tensor([[0.05_55, 0.89_14, 0.05_31]]							)
     elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
          UpperCamelCase__										=      torch.tensor([[3.85_54e-04, 9.99_29e-01, 3.27_54e-04]]							)
     elif model_name == "xclip-large-patch14-kinetics-600":
          UpperCamelCase__										=      torch.tensor([[0.00_36, 0.99_20, 0.00_45]]							)
     # few shot
     elif model_name == "xclip-base-patch16-hmdb-2-shot":
          UpperCamelCase__										=      torch.tensor([[7.18_90e-06, 9.99_94e-01, 5.65_59e-05]]							)
     elif model_name == "xclip-base-patch16-hmdb-4-shot":
          UpperCamelCase__										=      torch.tensor([[1.03_20e-05, 9.99_93e-01, 6.24_35e-05]]							)
     elif model_name == "xclip-base-patch16-hmdb-8-shot":
          UpperCamelCase__										=      torch.tensor([[4.13_77e-06, 9.99_90e-01, 9.83_86e-05]]							)
     elif model_name == "xclip-base-patch16-hmdb-16-shot":
          UpperCamelCase__										=      torch.tensor([[4.13_47e-05, 9.99_62e-01, 3.34_11e-04]]							)
     elif model_name == "xclip-base-patch16-ucf-2-shot":
          UpperCamelCase__										=      torch.tensor([[8.58_57e-05, 9.99_28e-01, 6.32_91e-04]]							)
     elif model_name == "xclip-base-patch16-ucf-4-shot":
          UpperCamelCase__										=      torch.tensor([[8.58_57e-05, 9.99_28e-01, 6.32_91e-04]]							)
     elif model_name == "xclip-base-patch16-ucf-8-shot":
          UpperCamelCase__										=      torch.tensor([[0.00_27, 0.99_04, 0.00_70]]							)
     elif model_name == "xclip-base-patch16-ucf-16-shot":
          UpperCamelCase__										=      torch.tensor([[9.82_19e-04, 9.95_93e-01, 3.08_63e-03]]							)
     # zero shot
     elif model_name == "xclip-base-patch16-zero-shot":
          UpperCamelCase__										=      torch.tensor([[3.50_82e-04, 9.97_85e-01, 1.79_66e-03]]							)
     else:
          raise ValueError(f"Model name {model_name} not supported"							)
     assert torch.allclose(A ,							A ,							atol=1e-3							)
     print('''Looks ok!'''							)

     if pytorch_dump_folder_path is not None:
          print(f"Saving model {model_name} to {pytorch_dump_folder_path}"							)
          model.save_pretrained(A							)

     if push_to_hub:
          print('''Pushing model, processor and slow tokenizer files to the hub...'''							)
          model.push_to_hub(A ,							organization='''nielsr'''							)
          processor.push_to_hub(A ,							organization='''nielsr'''							)
          slow_tokenizer.push_to_hub(A ,							organization='''nielsr'''							)


if __name__ == "__main__":
     __magic_name__								=argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '''--model_name''',
         default='''xclip-base-patch32''',
         type=str,
         help='''Name of the model.''',
     )
     parser.add_argument(
         '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
     )
     parser.add_argument(
         '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
     )

     __magic_name__								=parser.parse_args()
     convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	List[str]						=""
  SCREAMING_SNAKE_CASE_	:	str						=(
      None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
  )
  SCREAMING_SNAKE_CASE_	:	str						=None  # compression type in fsspec. ex: "gzip"
  SCREAMING_SNAKE_CASE_	:	str						=None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz






  def __init__(self   ,				SCREAMING_SNAKE_CASE_ = ""   ,				SCREAMING_SNAKE_CASE_ = None   ,				SCREAMING_SNAKE_CASE_ = None   ,				**SCREAMING_SNAKE_CASE_	)		->      List[str]:





       '''simple docstring'''





       super().__init__(self   ,				**SCREAMING_SNAKE_CASE_	)
       # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
       UpperCamelCase__										=      fsspec.open(
           SCREAMING_SNAKE_CASE_   ,				mode='''rb'''   ,				protocol=SCREAMING_SNAKE_CASE_   ,				compression=self.compression   ,				client_kwargs={
               '''requote_redirect_url''': False,  # see https://github.com/huggingface/datasets/pull/5459
               '''trust_env''': True,  # Enable reading proxy env variables.
               **(target_options or {}).pop('''client_kwargs'''   ,				{}	),  # To avoid issues if it was already passed.
           }   ,				**(target_options or {})   ,				)
       UpperCamelCase__										=      os.path.basename(self.file.path.split('''::'''	)[0]	)
       UpperCamelCase__										=      (
           self.compressed_name[: self.compressed_name.rindex('''.'''	)]
           if '''.''' in self.compressed_name
           else self.compressed_name
       )
       UpperCamelCase__										=      None






  @classmethod
  def 		_a					(cls   ,				SCREAMING_SNAKE_CASE_	)		->      Optional[Any]:





       '''simple docstring'''





       return super()._strip_protocol(SCREAMING_SNAKE_CASE_	).lstrip('''/'''	)






  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





       if self.dir_cache is None:
            UpperCamelCase__										=      {**self.file.fs.info(self.file.path	), '''name''': self.uncompressed_name}
            UpperCamelCase__										=      {f['''name''']: f}






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_	)		->      List[Any]:





       '''simple docstring'''





       return self.file.open().read()






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_ = "rb"   ,				SCREAMING_SNAKE_CASE_=None   ,				SCREAMING_SNAKE_CASE_=True   ,				SCREAMING_SNAKE_CASE_=None   ,				**SCREAMING_SNAKE_CASE_   ,				)		->      List[Any]:





       '''simple docstring'''





       UpperCamelCase__										=      self._strip_protocol(SCREAMING_SNAKE_CASE_	)
       if mode != "rb":
            raise ValueError(F"Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"	)
       return self.file.open()



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	Tuple						="bz2"
  SCREAMING_SNAKE_CASE_	:	List[str]						="bz2"
  SCREAMING_SNAKE_CASE_	:	List[Any]						=".bz2"



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	Tuple						="gzip"
  SCREAMING_SNAKE_CASE_	:	Dict						="gzip"
  SCREAMING_SNAKE_CASE_	:	List[Any]						=".gz"



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	List[Any]						="lz4"
  SCREAMING_SNAKE_CASE_	:	str						="lz4"
  SCREAMING_SNAKE_CASE_	:	Any						=".lz4"



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	Dict						="xz"
  SCREAMING_SNAKE_CASE_	:	List[str]						="xz"
  SCREAMING_SNAKE_CASE_	:	Optional[int]						=".xz"



class     _A   (    __UpperCamelCase							):
  SCREAMING_SNAKE_CASE_	:	Optional[Any]						="zstd"
  SCREAMING_SNAKE_CASE_	:	Optional[int]						="zstd"
  SCREAMING_SNAKE_CASE_	:	Optional[int]						=".zst"






  def __init__(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_ = "rb"   ,				SCREAMING_SNAKE_CASE_ = None   ,				SCREAMING_SNAKE_CASE_ = None   ,				SCREAMING_SNAKE_CASE_ = DEFAULT_BLOCK_SIZE   ,				**SCREAMING_SNAKE_CASE_   ,				)		->      List[Any]:





       '''simple docstring'''





       super().__init__(
           fo=SCREAMING_SNAKE_CASE_   ,				mode=SCREAMING_SNAKE_CASE_   ,				target_protocol=SCREAMING_SNAKE_CASE_   ,				target_options=SCREAMING_SNAKE_CASE_   ,				block_size=SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_   ,				)
       # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
       #
       # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
       #     out.close = close
       # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
       #
       # see https://github.com/intake/filesystem_spec/issues/725
       UpperCamelCase__										=      self.file.__enter__



       class     _A   :






         def __init__(self   ,				SCREAMING_SNAKE_CASE_	)		->      int:





              '''simple docstring'''





              UpperCamelCase__										=      file_






         def __enter__(self	)		->      Union[str, Any]:





              '''simple docstring'''





              self._file.__enter__()
              return self






         def __exit__(self   ,				*SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_	)		->      List[Any]:





              '''simple docstring'''





              self._file.__exit__(*SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_	)






         def __iter__(self	)		->      Dict:





              '''simple docstring'''





              return iter(self._file	)






         def 		_a					(self	)		->      Dict:





              '''simple docstring'''





              return next(self._file	)






         def __getattr__(self   ,				SCREAMING_SNAKE_CASE_	)		->      str:





              '''simple docstring'''





              return getattr(self._file   ,				SCREAMING_SNAKE_CASE_	)

       def fixed_enter(*SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_	):
            return WrappedFile(_enter(*SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_	)	)

       UpperCamelCase__										=      fixed_enter



