
import argparse
import json
import pickle
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowercase__		:Optional[int]   =    logging.get_logger(__name__)



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase							=						SwinConfig.from_pretrained(
					    '''microsoft/swin-tiny-patch4-window7-224''' ,			out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']		)
					lowercase							=						MaskFormerConfig(backbone_config=lowerCAmelCase__		)

					lowercase							=						'''huggingface/label-files'''
					if "ade20k-full" in model_name:
										# this should be ok
										lowercase							=						847
										lowercase							=						'''maskformer-ade20k-full-id2label.json'''
					elif "ade" in model_name:
										# this should be ok
										lowercase							=						150
										lowercase							=						'''ade20k-id2label.json'''
					elif "coco-stuff" in model_name:
										# this should be ok
										lowercase							=						171
										lowercase							=						'''maskformer-coco-stuff-id2label.json'''
					elif "coco" in model_name:
										# TODO
										lowercase							=						133
										lowercase							=						'''coco-panoptic-id2label.json'''
					elif "cityscapes" in model_name:
										# this should be ok
										lowercase							=						19
										lowercase							=						'''cityscapes-id2label.json'''
					elif "vistas" in model_name:
										# this should be ok
										lowercase							=						65
										lowercase							=						'''mapillary-vistas-id2label.json'''

					lowercase							=						json.load(open(hf_hub_download(lowerCAmelCase__ ,			lowerCAmelCase__ ,			repo_type='''dataset'''		) ,			'''r'''		)		)
					lowercase							=						{int(lowerCAmelCase__		): v for k, v in idalabel.items()}

					return config



def        UpperCamelCase    (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase							=						[]
					# stem
					# fmt: off
					rename_keys.append(('''backbone.patch_embed.proj.weight''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight''')		)
					rename_keys.append(('''backbone.patch_embed.proj.bias''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias''')		)
					rename_keys.append(('''backbone.patch_embed.norm.weight''', '''model.pixel_level_module.encoder.model.embeddings.norm.weight''')		)
					rename_keys.append(('''backbone.patch_embed.norm.bias''', '''model.pixel_level_module.encoder.model.embeddings.norm.bias''')		)
					# stages
					for i in range(len(config.backbone_config.depths		)		):
										for j in range(config.backbone_config.depths[i]		):
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm1.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm1.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.relative_position_index', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.proj.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.proj.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm2.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm2.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc1.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc1.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc2.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight')		)
															rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc2.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias')		)

										if i < 3:
															rename_keys.append((f'backbone.layers.{i}.downsample.reduction.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight')		)
															rename_keys.append((f'backbone.layers.{i}.downsample.norm.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight')		)
															rename_keys.append((f'backbone.layers.{i}.downsample.norm.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias')		)
										rename_keys.append((f'backbone.norm{i}.weight', f'model.pixel_level_module.encoder.hidden_states_norms.{i}.weight')		)
										rename_keys.append((f'backbone.norm{i}.bias', f'model.pixel_level_module.encoder.hidden_states_norms.{i}.bias')		)

					# FPN
					rename_keys.append(('''sem_seg_head.layer_4.weight''', '''model.pixel_level_module.decoder.fpn.stem.0.weight''')		)
					rename_keys.append(('''sem_seg_head.layer_4.norm.weight''', '''model.pixel_level_module.decoder.fpn.stem.1.weight''')		)
					rename_keys.append(('''sem_seg_head.layer_4.norm.bias''', '''model.pixel_level_module.decoder.fpn.stem.1.bias''')		)
					for source_index, target_index in zip(range(3 ,			0 ,			-1		) ,			range(0 ,			3		)		):
										rename_keys.append((f'sem_seg_head.adapter_{source_index}.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight')		)
										rename_keys.append((f'sem_seg_head.adapter_{source_index}.norm.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight')		)
										rename_keys.append((f'sem_seg_head.adapter_{source_index}.norm.bias', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias')		)
										rename_keys.append((f'sem_seg_head.layer_{source_index}.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight')		)
										rename_keys.append((f'sem_seg_head.layer_{source_index}.norm.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight')		)
										rename_keys.append((f'sem_seg_head.layer_{source_index}.norm.bias', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias')		)
					rename_keys.append(('''sem_seg_head.mask_features.weight''', '''model.pixel_level_module.decoder.mask_projection.weight''')		)
					rename_keys.append(('''sem_seg_head.mask_features.bias''', '''model.pixel_level_module.decoder.mask_projection.bias''')		)

					# Transformer decoder
					for idx in range(config.decoder_config.decoder_layers		):
										# self-attention out projection
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight', f'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias', f'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias')		)
										# cross-attention out projection
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight', f'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias', f'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias')		)
										# MLP 1
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight', f'model.transformer_module.decoder.layers.{idx}.fc1.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias', f'model.transformer_module.decoder.layers.{idx}.fc1.bias')		)
										# MLP 2
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight', f'model.transformer_module.decoder.layers.{idx}.fc2.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias', f'model.transformer_module.decoder.layers.{idx}.fc2.bias')		)
										# layernorm 1 (self-attention layernorm)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight', f'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias', f'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias')		)
										# layernorm 2 (cross-attention layernorm)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight', f'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias', f'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias')		)
										# layernorm 3 (final layernorm)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight', f'model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias', f'model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias')		)

					rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.weight''', '''model.transformer_module.decoder.layernorm.weight''')		)
					rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.bias''', '''model.transformer_module.decoder.layernorm.bias''')		)

					# heads on top
					rename_keys.append(('''sem_seg_head.predictor.query_embed.weight''', '''model.transformer_module.queries_embedder.weight''')		)

					rename_keys.append(('''sem_seg_head.predictor.input_proj.weight''', '''model.transformer_module.input_projection.weight''')		)
					rename_keys.append(('''sem_seg_head.predictor.input_proj.bias''', '''model.transformer_module.input_projection.bias''')		)

					rename_keys.append(('''sem_seg_head.predictor.class_embed.weight''', '''class_predictor.weight''')		)
					rename_keys.append(('''sem_seg_head.predictor.class_embed.bias''', '''class_predictor.bias''')		)

					for i in range(3		):
										rename_keys.append((f'sem_seg_head.predictor.mask_embed.layers.{i}.weight', f'mask_embedder.{i}.0.weight')		)
										rename_keys.append((f'sem_seg_head.predictor.mask_embed.layers.{i}.bias', f'mask_embedder.{i}.0.bias')		)
					# fmt: on

					return rename_keys



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__		):
					'''simple docstring'''
					lowercase							=						dct.pop(lowerCAmelCase__		)
					lowercase							=						val



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__		):
					'''simple docstring'''
					lowercase							=						[int(backbone_config.embed_dim * 2**i		) for i in range(len(backbone_config.depths		)		)]
					for i in range(len(backbone_config.depths		)		):
										lowercase							=						num_features[i]
										for j in range(backbone_config.depths[i]		):
															# fmt: off
															# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
															lowercase							=						state_dict.pop(f'backbone.layers.{i}.blocks.{j}.attn.qkv.weight'		)
															lowercase							=						state_dict.pop(f'backbone.layers.{i}.blocks.{j}.attn.qkv.bias'		)
															# next, add query, keys and values (in that order) to the state dict
															lowercase							=						in_proj_weight[:dim, :]
															lowercase							=						in_proj_bias[: dim]
															lowercase							=						in_proj_weight[
															    dim : dim * 2, :
															]
															lowercase							=						in_proj_bias[
															    dim : dim * 2
															]
															lowercase							=						in_proj_weight[
															    -dim :, :
															]
															lowercase							=						in_proj_bias[-dim :]
															# fmt: on



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__		):
					'''simple docstring'''
					# fmt: off
					lowercase							=						config.decoder_config.hidden_size
					for idx in range(config.decoder_config.decoder_layers		):
										# read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
										lowercase							=						state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight'		)
										lowercase							=						state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias'		)
										# next, add query, keys and values (in that order) to the state dict
										lowercase							=						in_proj_weight[: hidden_size, :]
										lowercase							=						in_proj_bias[:config.hidden_size]
										lowercase							=						in_proj_weight[hidden_size : hidden_size * 2, :]
										lowercase							=						in_proj_bias[hidden_size : hidden_size * 2]
										lowercase							=						in_proj_weight[-hidden_size :, :]
										lowercase							=						in_proj_bias[-hidden_size :]
										# read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
										lowercase							=						state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight'		)
										lowercase							=						state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias'		)
										# next, add query, keys and values (in that order) to the state dict
										lowercase							=						in_proj_weight[: hidden_size, :]
										lowercase							=						in_proj_bias[:config.hidden_size]
										lowercase							=						in_proj_weight[hidden_size : hidden_size * 2, :]
										lowercase							=						in_proj_bias[hidden_size : hidden_size * 2]
										lowercase							=						in_proj_weight[-hidden_size :, :]
										lowercase							=						in_proj_bias[-hidden_size :]
					# fmt: on



def        UpperCamelCase    (							):
					'''simple docstring'''
					lowercase							=						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
					lowercase							=						Image.open(requests.get(lowerCAmelCase__ ,			stream=lowerCAmelCase__		).raw		)
					return im



@torch.no_grad()
def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__ = False		):
					'''simple docstring'''
					lowercase							=						get_maskformer_config(lowerCAmelCase__		)

					# load original state_dict
					with open(lowerCAmelCase__ ,			'''rb'''		) as f:
										lowercase							=						pickle.load(lowerCAmelCase__		)
					lowercase							=						data['''model''']

					# for name, param in state_dict.items():
					#     print(name, param.shape)

					# rename keys
					lowercase							=						create_rename_keys(lowerCAmelCase__		)
					for src, dest in rename_keys:
										rename_key(lowerCAmelCase__ ,			lowerCAmelCase__ ,			lowerCAmelCase__		)
					read_in_swin_q_k_v(lowerCAmelCase__ ,			config.backbone_config		)
					read_in_decoder_q_k_v(lowerCAmelCase__ ,			lowerCAmelCase__		)

					# update to torch tensors
					for key, value in state_dict.items():
										lowercase							=						torch.from_numpy(lowerCAmelCase__		)

					# load 🤗 model
					lowercase							=						MaskFormerForInstanceSegmentation(lowerCAmelCase__		)
					model.eval()

					for name, param in model.named_parameters():
										print(lowerCAmelCase__ ,			param.shape		)

					lowercase	,						lowercase							=						model.load_state_dict(lowerCAmelCase__ ,			strict=lowerCAmelCase__		)
					assert missing_keys == [
					    "model.pixel_level_module.encoder.model.layernorm.weight",
					    "model.pixel_level_module.encoder.model.layernorm.bias",
					]
					assert len(lowerCAmelCase__		) == 0, f'Unexpected keys: {unexpected_keys}'

					# verify results
					lowercase							=						prepare_img()
					if "vistas" in model_name:
										lowercase							=						65
					elif "cityscapes" in model_name:
										lowercase							=						6_5535
					else:
										lowercase							=						255
					lowercase							=						True if '''ade''' in model_name else False
					lowercase							=						MaskFormerImageProcessor(ignore_index=lowerCAmelCase__ ,			reduce_labels=lowerCAmelCase__		)

					lowercase							=						image_processor(lowerCAmelCase__ ,			return_tensors='''pt'''		)

					lowercase							=						model(**lowerCAmelCase__		)

					print('''Logits:''' ,			outputs.class_queries_logits[0, :3, :3]		)

					if model_name == "maskformer-swin-tiny-ade":
										lowercase							=						torch.tensor(
										    [[3.63_53, -4.47_70, -2.60_65], [0.50_81, -4.23_94, -3.53_43], [2.19_09, -5.03_53, -1.93_23]]		)
					assert torch.allclose(outputs.class_queries_logits[0, :3, :3] ,			lowerCAmelCase__ ,			atol=1E-4		)
					print('''Looks ok!'''		)

					if pytorch_dump_folder_path is not None:
										print(f'Saving model and image processor to {pytorch_dump_folder_path}'		)
										Path(lowerCAmelCase__		).mkdir(exist_ok=lowerCAmelCase__		)
										model.save_pretrained(lowerCAmelCase__		)
										image_processor.save_pretrained(lowerCAmelCase__		)

					if push_to_hub:
										print('''Pushing model and image processor to the hub...'''		)
										model.push_to_hub(f'nielsr/{model_name}'		)
										image_processor.push_to_hub(f'nielsr/{model_name}'		)


if __name__ == "__main__":
							lowercase__		:Optional[int]   =    argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--model_name",
							    default="maskformer-swin-tiny-ade",
							    type=str,
							    help=("Name of the MaskFormer model you'd like to convert",),
							)
							parser.add_argument(
							    "--checkpoint_path",
							    default="/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl",
							    type=str,
							    help="Path to the original state dict (.pth file).",
							)
							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."
							)

							lowercase__		:Optional[Any]   =    parser.parse_args()
							convert_maskformer_checkpoint(
							    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
							)









import os
from pathlib import Path
from unittest.mock import patch

import pytest
import zstandard as zstd

from datasets.download.download_config import DownloadConfig
from datasets.utils.file_utils import (
    OfflineModeIsEnabled,
    cached_path,
    fsspec_get,
    fsspec_head,
    ftp_get,
    ftp_head,
    get_from_cache,
    http_get,
    http_head,
)


__snake_case						:List[str]      		=     '''\
    Text data.
    Second line of data.'''

__snake_case						:Optional[Any]      		=     '''file'''





@pytest.fixture(scope='''session'''				)
def      __snake_case	(			_UpperCAmelCase				):
    __a						       =				tmp_path_factory.mktemp('''data'''				) / (FILE_PATH + '''.zstd''')
    __a						       =				bytes(_UpperCAmelCase   , '''utf-8'''				)
    with zstd.open(_UpperCAmelCase   , '''wb'''				) as f:
        f.write(_UpperCAmelCase				)
    return path





@pytest.fixture
def      __snake_case	(			_UpperCAmelCase				):
    with open(os.path.join(tmpfs.local_root_dir   , _UpperCAmelCase				)   , '''w'''				) as f:
        f.write(_UpperCAmelCase				)
    return FILE_PATH





@pytest.mark.parametrize('''compression_format'''   , ['''gzip''', '''xz''', '''zstd''']				)
def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				):
    __a						       =				{'''gzip''': gz_file, '''xz''': xz_file, '''zstd''': zstd_path}
    __a						       =				input_paths[compression_format]
    __a						       =				tmp_path / '''cache'''
    __a						       =				DownloadConfig(cache_dir=_UpperCAmelCase   , extract_compressed_file=_UpperCAmelCase				)
    __a						       =				cached_path(_UpperCAmelCase   , download_config=_UpperCAmelCase				)
    with open(_UpperCAmelCase				) as f:
        __a						       =				f.read()
    with open(_UpperCAmelCase				) as f:
        __a						       =				f.read()
    assert extracted_file_content == expected_file_content





@pytest.mark.parametrize('''default_extracted'''   , [True, False]				)
@pytest.mark.parametrize('''default_cache_dir'''   , [True, False]				)
def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				):
    __a						       =				'''custom_cache'''
    __a						       =				'''custom_extracted_dir'''
    __a						       =				tmp_path / '''custom_extracted_path'''
    if default_extracted:
        __a						       =				('''downloads''' if default_cache_dir else custom_cache_dir, '''extracted''')
    else:
        monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_DIR'''   , _UpperCAmelCase				)
        monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_PATH'''   , str(_UpperCAmelCase				)				)
        __a						       =				custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

    __a						       =				xz_file
    __a						       =				(
        DownloadConfig(extract_compressed_file=_UpperCAmelCase				)
        if default_cache_dir
        else DownloadConfig(cache_dir=tmp_path / custom_cache_dir   , extract_compressed_file=_UpperCAmelCase				)
    )
    __a						       =				cached_path(_UpperCAmelCase   , download_config=_UpperCAmelCase				)
    assert Path(_UpperCAmelCase				).parent.parts[-2:] == expected





def      __snake_case	(			_UpperCAmelCase				):
    # absolute path
    __a						       =				str(Path(_UpperCAmelCase				).resolve()				)
    assert cached_path(_UpperCAmelCase				) == text_file
    # relative path
    __a						       =				str(Path(_UpperCAmelCase				).resolve().relative_to(Path(os.getcwd()				)				)				)
    assert cached_path(_UpperCAmelCase				) == text_file





def      __snake_case	(			_UpperCAmelCase				):
    # absolute path
    __a						       =				str(tmp_path.resolve() / '''__missing_file__.txt'''				)
    with pytest.raises(_UpperCAmelCase				):
        cached_path(_UpperCAmelCase				)
    # relative path
    __a						       =				'''./__missing_file__.txt'''
    with pytest.raises(_UpperCAmelCase				):
        cached_path(_UpperCAmelCase				)





def      __snake_case	(			_UpperCAmelCase				):
    __a						       =				get_from_cache(f'tmp://{tmpfs_file}'				)
    with open(_UpperCAmelCase				) as f:
        __a						       =				f.read()
    assert output_file_content == FILE_CONTENT





@patch('''datasets.config.HF_DATASETS_OFFLINE'''   , _UpperCAmelCase				)
def      __snake_case	(			):
    with pytest.raises(_UpperCAmelCase				):
        cached_path('''https://huggingface.co'''				)





@patch('''datasets.config.HF_DATASETS_OFFLINE'''   , _UpperCAmelCase				)
def      __snake_case	(			_UpperCAmelCase				):
    __a						       =				tmp_path_factory.mktemp('''data'''				) / '''file.html'''
    with pytest.raises(_UpperCAmelCase				):
        http_get('''https://huggingface.co'''   , temp_file=_UpperCAmelCase				)
    with pytest.raises(_UpperCAmelCase				):
        http_head('''https://huggingface.co'''				)





@patch('''datasets.config.HF_DATASETS_OFFLINE'''   , _UpperCAmelCase				)
def      __snake_case	(			_UpperCAmelCase				):
    __a						       =				tmp_path_factory.mktemp('''data'''				) / '''file.html'''
    with pytest.raises(_UpperCAmelCase				):
        ftp_get('''ftp://huggingface.co'''   , temp_file=_UpperCAmelCase				)
    with pytest.raises(_UpperCAmelCase				):
        ftp_head('''ftp://huggingface.co'''				)





@patch('''datasets.config.HF_DATASETS_OFFLINE'''   , _UpperCAmelCase				)
def      __snake_case	(			_UpperCAmelCase				):
    __a						       =				tmp_path_factory.mktemp('''data'''				) / '''file.html'''
    with pytest.raises(_UpperCAmelCase				):
        fsspec_get('''s3://huggingface.co'''   , temp_file=_UpperCAmelCase				)
    with pytest.raises(_UpperCAmelCase				):
        fsspec_head('''s3://huggingface.co'''				)





