



"""simple docstring"""
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        snake_case   (     A__			,A__		):
			UpperCAmelCase_  :				int      =      XCLIPTextConfig()

			# derive patch size from model name
			UpperCAmelCase_  :				Optional[Any]      =      model_name.find("patch"		)
			UpperCAmelCase_  :				Union[str, Any]      =      int(model_name[start_idx + len("patch"		) : start_idx + len("patch"		) + 2]		)
			UpperCAmelCase_  :				Any      =      XCLIPVisionConfig(patch_size=A__			,num_frames=A__		)

			if "large" in model_name:
						UpperCAmelCase_  :				List[str]      =      7_68
						UpperCAmelCase_  :				Dict      =      30_72
						UpperCAmelCase_  :				List[Any]      =      12

						UpperCAmelCase_  :				str      =      10_24
						UpperCAmelCase_  :				Dict      =      40_96
						UpperCAmelCase_  :				List[str]      =      16
						UpperCAmelCase_  :				List[Any]      =      24
						UpperCAmelCase_  :				str      =      7_68
						UpperCAmelCase_  :				Union[str, Any]      =      30_72

			if model_name == "xclip-large-patch14-16-frames":
						UpperCAmelCase_  :				Dict      =      3_36

			UpperCAmelCase_  :				Union[str, Any]      =      XCLIPConfig.from_text_vision_configs(A__			,A__		)

			if "large" in model_name:
						UpperCAmelCase_  :				List[Any]      =      7_68

			return config

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

			return name

def        snake_case   (     A__			,A__		):
			for key in orig_state_dict.copy().keys():
						UpperCAmelCase_  :				str      =      orig_state_dict.pop(A__		)

						if "attn.in_proj" in key:
									UpperCAmelCase_  :				str      =      key.split("."		)
									if key.startswith("visual"		):
												UpperCAmelCase_  :				List[str]      =      key_split[3]
												UpperCAmelCase_  :				Any      =      config.vision_config.hidden_size
												if "message_attn" in key:
															if "weight" in key:
																		UpperCAmelCase_  :				Optional[int]      =      val[
																		    :dim, :
																		]
																		UpperCAmelCase_  :				Union[str, Any]      =      val[
																		    dim : dim * 2, :
																		]
																		UpperCAmelCase_  :				Dict      =      val[
																		    -dim:, :
																		]
															else:
																		UpperCAmelCase_  :				Optional[Any]      =      val[
																		    :dim
																		]
																		UpperCAmelCase_  :				str      =      val[
																		    dim : dim * 2
																		]
																		UpperCAmelCase_  :				str      =      val[
																		    -dim:
																		]
												else:
															if "weight" in key:
																		UpperCAmelCase_  :				str      =      val[
																		    :dim, :
																		]
																		UpperCAmelCase_  :				Any      =      val[
																		    dim : dim * 2, :
																		]
																		UpperCAmelCase_  :				str      =      val[
																		    -dim:, :
																		]
															else:
																		UpperCAmelCase_  :				Any      =      val[:dim]
																		UpperCAmelCase_  :				Tuple      =      val[
																		    dim : dim * 2
																		]
																		UpperCAmelCase_  :				int      =      val[-dim:]
									elif key.startswith("mit"		):
												UpperCAmelCase_  :				Union[str, Any]      =      key_split[2]
												UpperCAmelCase_  :				Optional[int]      =      config.vision_config.mit_hidden_size
												if "weight" in key:
															UpperCAmelCase_  :				Optional[Any]      =      val[:dim, :]
															UpperCAmelCase_  :				List[str]      =      val[dim : dim * 2, :]
															UpperCAmelCase_  :				List[Any]      =      val[-dim:, :]
												else:
															UpperCAmelCase_  :				List[Any]      =      val[:dim]
															UpperCAmelCase_  :				Optional[int]      =      val[dim : dim * 2]
															UpperCAmelCase_  :				Tuple      =      val[-dim:]
									else:
												UpperCAmelCase_  :				Tuple      =      key_split[2]
												UpperCAmelCase_  :				Optional[int]      =      config.text_config.hidden_size
												if "weight" in key:
															UpperCAmelCase_  :				str      =      val[:dim, :]
															UpperCAmelCase_  :				Any      =      val[
															    dim : dim * 2, :
															]
															UpperCAmelCase_  :				int      =      val[-dim:, :]
												else:
															UpperCAmelCase_  :				Dict      =      val[:dim]
															UpperCAmelCase_  :				List[Any]      =      val[
															    dim : dim * 2
															]
															UpperCAmelCase_  :				Any      =      val[-dim:]
						else:
									UpperCAmelCase_  :				Optional[int]      =      rename_key(A__		)
									if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
												UpperCAmelCase_  :				int      =      val.T
									UpperCAmelCase_  :				int      =      val

			return orig_state_dict

def        snake_case   (     A__		):
			if num_frames == 8:
						UpperCAmelCase_  :				Union[str, Any]      =      "eating_spaghetti_8_frames.npy"
			elif num_frames == 16:
						UpperCAmelCase_  :				Optional[int]      =      "eating_spaghetti.npy"
			elif num_frames == 32:
						UpperCAmelCase_  :				Optional[int]      =      "eating_spaghetti_32_frames.npy"
			UpperCAmelCase_  :				str      =      hf_hub_download(
			    repo_id="hf-internal-testing/spaghetti-video"			,filename=A__			,repo_type="dataset"			,)
			UpperCAmelCase_  :				Union[str, Any]      =      np.load(A__		)
			return list(A__		)

def        snake_case   (     A__			,A__=None			,A__=False		):
			UpperCAmelCase_  :				Optional[int]      =      {
			    # 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_  :				str      =      model_to_url[model_name]
			UpperCAmelCase_  :				int      =      8
			if "16-frames" in model_name:
						UpperCAmelCase_  :				Optional[int]      =      16
			elif "shot" in model_name:
						UpperCAmelCase_  :				Any      =      32

			UpperCAmelCase_  :				Any      =      get_xclip_config(A__			,A__		)
			UpperCAmelCase_  :				Optional[int]      =      XCLIPModel(A__		)
			model.eval()

			if "drive" in checkpoint_url:
						UpperCAmelCase_  :				Dict      =      "pytorch_model.bin"
						gdown.cached_download(A__			,A__			,quiet=A__		)
						UpperCAmelCase_  :				List[str]      =      torch.load(A__			,map_location="cpu"		)["model"]
			else:
						UpperCAmelCase_  :				int      =      torch.hub.load_state_dict_from_url(A__		)["model"]

			UpperCAmelCase_  :				Optional[int]      =      convert_state_dict(A__			,A__		)

			UpperCAmelCase_  :				int      =      XCLIPModel(A__		)
			UpperCAmelCase_  :				List[Any]      =      model.load_state_dict(A__			,strict=A__		)
			assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
			model.eval()

			UpperCAmelCase_  :				List[str]      =      3_36 if model_name == "xclip-large-patch14-16-frames" else 2_24
			UpperCAmelCase_  :				int      =      VideoMAEImageProcessor(size=A__		)
			UpperCAmelCase_  :				List[str]      =      CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"		)
			UpperCAmelCase_  :				Dict      =      CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32"		)
			UpperCAmelCase_  :				Optional[Any]      =      XCLIPProcessor(image_processor=A__			,tokenizer=A__		)

			UpperCAmelCase_  :				Tuple      =      prepare_video(A__		)
			UpperCAmelCase_  :				Optional[int]      =      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_  :				Any      =      model(**A__		)

			# Verify outputs
			UpperCAmelCase_  :				Optional[Any]      =      outputs.logits_per_video
			UpperCAmelCase_  :				int      =      logits_per_video.softmax(dim=1		)
			print("Probs:"			,A__		)
			# kinetics-400
			if model_name == "xclip-base-patch32":
						UpperCAmelCase_  :				Any      =      torch.tensor([[0.0019, 0.9951, 0.0030]]		)
			elif model_name == "xclip-base-patch32-16-frames":
						UpperCAmelCase_  :				Optional[int]      =      torch.tensor([[7.0999e-04, 9.9883e-01, 4.5580e-04]]		)
			elif model_name == "xclip-base-patch16":
						UpperCAmelCase_  :				Optional[Any]      =      torch.tensor([[0.0083, 0.9681, 0.0236]]		)
			elif model_name == "xclip-base-patch16-16-frames":
						UpperCAmelCase_  :				int      =      torch.tensor([[7.6937e-04, 9.9728e-01, 1.9473e-03]]		)
			elif model_name == "xclip-large-patch14":
						UpperCAmelCase_  :				Any      =      torch.tensor([[0.0062, 0.9864, 0.0075]]		)
			elif model_name == "xclip-large-patch14-16-frames":
						UpperCAmelCase_  :				Union[str, Any]      =      torch.tensor([[3.3877e-04, 9.9937e-01, 2.8888e-04]]		)
			# kinetics-600
			elif model_name == "xclip-base-patch16-kinetics-600":
						UpperCAmelCase_  :				List[str]      =      torch.tensor([[0.0555, 0.8914, 0.0531]]		)
			elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
						UpperCAmelCase_  :				Dict      =      torch.tensor([[3.8554e-04, 9.9929e-01, 3.2754e-04]]		)
			elif model_name == "xclip-large-patch14-kinetics-600":
						UpperCAmelCase_  :				Union[str, Any]      =      torch.tensor([[0.0036, 0.9920, 0.0045]]		)
			# few shot
			elif model_name == "xclip-base-patch16-hmdb-2-shot":
						UpperCAmelCase_  :				Optional[Any]      =      torch.tensor([[7.1890e-06, 9.9994e-01, 5.6559e-05]]		)
			elif model_name == "xclip-base-patch16-hmdb-4-shot":
						UpperCAmelCase_  :				List[Any]      =      torch.tensor([[1.0320e-05, 9.9993e-01, 6.2435e-05]]		)
			elif model_name == "xclip-base-patch16-hmdb-8-shot":
						UpperCAmelCase_  :				Optional[int]      =      torch.tensor([[4.1377e-06, 9.9990e-01, 9.8386e-05]]		)
			elif model_name == "xclip-base-patch16-hmdb-16-shot":
						UpperCAmelCase_  :				Union[str, Any]      =      torch.tensor([[4.1347e-05, 9.9962e-01, 3.3411e-04]]		)
			elif model_name == "xclip-base-patch16-ucf-2-shot":
						UpperCAmelCase_  :				Optional[int]      =      torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]		)
			elif model_name == "xclip-base-patch16-ucf-4-shot":
						UpperCAmelCase_  :				Any      =      torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]		)
			elif model_name == "xclip-base-patch16-ucf-8-shot":
						UpperCAmelCase_  :				Dict      =      torch.tensor([[0.0027, 0.9904, 0.0070]]		)
			elif model_name == "xclip-base-patch16-ucf-16-shot":
						UpperCAmelCase_  :				Tuple      =      torch.tensor([[9.8219e-04, 9.9593e-01, 3.0863e-03]]		)
			# zero shot
			elif model_name == "xclip-base-patch16-zero-shot":
						UpperCAmelCase_  :				List[str]      =      torch.tensor([[3.5082e-04, 9.9785e-01, 1.7966e-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__":
			lowerCamelCase_       			=   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.'''
			)

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











"""simple docstring"""
import os

import pytest

from datasets import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
)


lowerCamelCase_       			=   pytest.mark.integration

@pytest.mark.parametrize("path"			,["paws", "csv"]		)
def        snake_case   (     A__			,A__		):
			inspect_dataset(A__			,A__		)
			UpperCAmelCase_  :				Tuple      =      path + ".py"
			assert script_name in os.listdir(A__		)
			assert "__pycache__" not in os.listdir(A__		)

@pytest.mark.filterwarnings("ignore:inspect_metric is deprecated:FutureWarning"		)
@pytest.mark.filterwarnings("ignore:metric_module_factory is deprecated:FutureWarning"		)
@pytest.mark.parametrize("path"			,["accuracy"]		)
def        snake_case   (     A__			,A__		):
			inspect_metric(A__			,A__		)
			UpperCAmelCase_  :				List[str]      =      path + ".py"
			assert script_name in os.listdir(A__		)
			assert "__pycache__" not in os.listdir(A__		)

@pytest.mark.parametrize(
    "path, config_name, expected_splits"			,[
        ("squad", "plain_text", ["train", "validation"]),
        ("dalle-mini/wit", "dalle-mini--wit", ["train"]),
        ("paws", "labeled_final", ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				Dict      =      get_dataset_config_info(A__			,config_name=A__		)
			assert info.config_name == config_name
			assert list(info.splits.keys()		) == expected_splits

@pytest.mark.parametrize(
    "path, config_name, expected_exception"			,[
        ("paws", None, ValueError),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			with pytest.raises(A__		):
						get_dataset_config_info(A__			,config_name=A__		)

@pytest.mark.parametrize(
    "path, expected"			,[
        ("squad", "plain_text"),
        ("acronym_identification", "default"),
        ("lhoestq/squad", "plain_text"),
        ("lhoestq/test", "default"),
        ("lhoestq/demo1", "lhoestq--demo1"),
        ("dalle-mini/wit", "dalle-mini--wit"),
    ]			,)
def        snake_case   (     A__			,A__		):
			UpperCAmelCase_  :				str      =      get_dataset_config_names(A__		)
			assert expected in config_names

@pytest.mark.parametrize(
    "path, expected_configs, expected_splits_in_first_config"			,[
        ("squad", ["plain_text"], ["train", "validation"]),
        ("dalle-mini/wit", ["dalle-mini--wit"], ["train"]),
        ("paws", ["labeled_final", "labeled_swap", "unlabeled_final"], ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				List[str]      =      get_dataset_infos(A__		)
			assert list(infos.keys()		) == expected_configs
			UpperCAmelCase_  :				List[str]      =      expected_configs[0]
			assert expected_config in infos
			UpperCAmelCase_  :				int      =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()		) == expected_splits_in_first_config

@pytest.mark.parametrize(
    "path, expected_config, expected_splits"			,[
        ("squad", "plain_text", ["train", "validation"]),
        ("dalle-mini/wit", "dalle-mini--wit", ["train"]),
        ("paws", "labeled_final", ["train", "test", "validation"]),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			UpperCAmelCase_  :				Optional[Any]      =      get_dataset_infos(A__		)
			assert expected_config in infos
			UpperCAmelCase_  :				Union[str, Any]      =      infos[expected_config]
			assert info.config_name == expected_config
			assert list(info.splits.keys()		) == expected_splits




@pytest.mark.parametrize(
    "path, config_name, expected_exception"			,[
        ("paws", None, ValueError),
    ]			,)
def        snake_case   (     A__			,A__			,A__		):
			with pytest.raises(A__		):
						get_dataset_split_names(A__			,config_name=A__		)



