



'''simple docstring'''



import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import RegNetForImageClassification, RegNetModel
	from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor






class 					UpperCAmelCase__	:



					def __init__(    self			,				UpperCamelCase			,				UpperCamelCase=3			,				UpperCamelCase=32			,				UpperCamelCase=3			,				UpperCamelCase=10			,				UpperCamelCase=[10, 20, 30, 40]			,				UpperCamelCase=[1, 1, 2, 1]			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase="relu"			,				UpperCamelCase=3			,				UpperCamelCase=None			,				)     ->			Dict:
						__lowerCAmelCase												=  parent
						__lowerCAmelCase												=  batch_size
						__lowerCAmelCase												=  image_size
						__lowerCAmelCase												=  num_channels
						__lowerCAmelCase												=  embeddings_size
						__lowerCAmelCase												=  hidden_sizes
						__lowerCAmelCase												=  depths
						__lowerCAmelCase												=  is_training
						__lowerCAmelCase												=  use_labels
						__lowerCAmelCase												=  hidden_act
						__lowerCAmelCase												=  num_labels
						__lowerCAmelCase												=  scope
						__lowerCAmelCase												=  len(UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
						__lowerCAmelCase												=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

						__lowerCAmelCase												=  None
						if self.use_labels:
							__lowerCAmelCase												=  ids_tensor([self.batch_size]			,				self.num_labels     )

						__lowerCAmelCase												=  self.get_config()

						return config, pixel_values, labels



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						return RegNetConfig(
						    num_channels=self.num_channels			,				embeddings_size=self.embeddings_size			,				hidden_sizes=self.hidden_sizes			,				depths=self.depths			,				hidden_act=self.hidden_act			,				num_labels=self.num_labels			,				)



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			List[Any]:
						__lowerCAmelCase												=  RegNetModel(config=UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase     )
						# expected last hidden states: B, C, H // 32, W // 32
						self.parent.assertEqual(
						    result.last_hidden_state.shape			,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,				)



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Optional[Any]:
						__lowerCAmelCase												=  self.num_labels
						__lowerCAmelCase												=  RegNetForImageClassification(UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				labels=UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)     )



					def        UpperCAmelCase_ (    self     )     ->			Any:
						__lowerCAmelCase												=  self.prepare_config_and_inputs()
						__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase												=  config_and_inputs
						__lowerCAmelCase												=  {"pixel_values": pixel_values}
						return config, inputs_dict






@require_torch
class 					UpperCAmelCase__	(		UpperCamelCase__							,       UpperCamelCase__							,       unittest.TestCase ):
					a      :     Dict        =							(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
					a      :     List[Any]        =							(
					    {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					a      :     str        =							False
					a      :     Optional[Any]        =							False
					a      :     Dict        =							False
					a      :     Union[str, Any]        =							False



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  RegNetModelTester(self     )
						__lowerCAmelCase												=  ConfigTester(self			,				config_class=UpperCamelCase			,				has_text_modality=UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						self.create_and_test_config_common_properties()
						self.config_tester.create_and_test_config_to_json_string()
						self.config_tester.create_and_test_config_to_json_file()
						self.config_tester.create_and_test_config_from_and_save_pretrained()
						self.config_tester.create_and_test_config_with_num_labels()
						self.config_tester.check_config_can_be_init_without_params()
						self.config_tester.check_config_arguments_init()



					def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
						return



					@unittest.skip(reason="RegNet does not use inputs_embeds"     )
					def        UpperCAmelCase_ (    self     )     ->			int:
						pass



					@unittest.skip(reason="RegNet does not support input and output embeddings"     )
					def        UpperCAmelCase_ (    self     )     ->			int:
						pass



					def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							__lowerCAmelCase												=  inspect.signature(model.forward     )
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							__lowerCAmelCase												=  [*signature.parameters.keys()]

							__lowerCAmelCase												=  ["pixel_values"]
							self.assertListEqual(arg_names[:1]			,				UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							__lowerCAmelCase												=  model_class(config=UpperCamelCase     )
							for name, module in model.named_modules():
								if isinstance(UpperCamelCase			,				(nn.BatchNormad, nn.GroupNorm)     ):
									self.assertTrue(
									    torch.all(module.weight == 1     )			,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''			,				)
									self.assertTrue(
									    torch.all(module.bias == 0     )			,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''			,				)



					def        UpperCAmelCase_ (    self     )     ->			Tuple:
						def check_hidden_states_output(UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     ):
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							model.to(UpperCamelCase     )
							model.eval()

							with torch.no_grad():
								__lowerCAmelCase												=  model(**self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )     )

							__lowerCAmelCase												=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

							__lowerCAmelCase												=  self.model_tester.num_stages
							self.assertEqual(len(UpperCamelCase     )			,				expected_num_stages + 1     )

							# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]     )			,				[self.model_tester.image_size // 2, self.model_tester.image_size // 2]			,				)

						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase												=  ["basic", "bottleneck"]
						for model_class in self.all_model_classes:
							for layer_type in layers_type:
								__lowerCAmelCase												=  layer_type
								__lowerCAmelCase												=  True
								check_hidden_states_output(UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								__lowerCAmelCase												=  True

								check_hidden_states_output(UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*UpperCamelCase     )



					@slow
					def        UpperCAmelCase_ (    self     )     ->			Dict:
						for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase												=  RegNetModel.from_pretrained(UpperCamelCase     )
							self.assertIsNotNone(UpperCamelCase     )



def   __lowerCAmelCase					(							):






	'''simple docstring'''




	__lowerCAmelCase												=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
	return image






@require_torch
@require_vision
class 					UpperCAmelCase__	(		unittest.TestCase ):



					@cached_property
					def        UpperCAmelCase_ (    self     )     ->			Dict:
						return (
						    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
						    if is_vision_available()
						    else None
						)



					@slow
					def        UpperCAmelCase_ (    self     )     ->			int:
						__lowerCAmelCase												=  RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(UpperCamelCase     )

						__lowerCAmelCase												=  self.default_image_processor
						__lowerCAmelCase												=  prepare_img()
						__lowerCAmelCase												=  image_processor(images=UpperCamelCase			,				return_tensors="pt"     ).to(UpperCamelCase     )

						# forward pass
						with torch.no_grad():
							__lowerCAmelCase												=  model(**UpperCamelCase     )

						# verify the logits
						__lowerCAmelCase												=  torch.Size((1, 1000)     )
						self.assertEqual(outputs.logits.shape			,				UpperCamelCase     )

						__lowerCAmelCase												=  torch.tensor([-0.41_80, -1.50_51, -3.48_36]     ).to(UpperCamelCase     )

						self.assertTrue(torch.allclose(outputs.logits[0, :3]			,				UpperCamelCase			,				atol=1E-4     )     )




'''simple docstring'''



import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases



def   __lowerCAmelCase					(							lowerCamelCase   :						str				,		lowerCamelCase   :						Union[str, Any]					):






	'''simple docstring'''




	assert isinstance(lowerCamelCase				,		lowerCamelCase					)
	assert dataset.num_rows == 4
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_1", "col_2", "col_3"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"				,		[False, True]					)
def   __lowerCAmelCase					(							lowerCamelCase   :						Tuple				,		lowerCamelCase   :						int				,		lowerCamelCase   :						Optional[int]					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
		__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		cache_dir=lowerCamelCase				,		keep_in_memory=lowerCamelCase					).read()
	_check_json_dataset(lowerCamelCase				,		lowerCamelCase					)



@pytest.mark.parametrize(
    "features"				,		[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]				,		)
def   __lowerCAmelCase					(							lowerCamelCase   :						List[Any]				,		lowerCamelCase   :						int				,		lowerCamelCase   :						Dict					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	__lowerCAmelCase												=  features.copy() if features else default_expected_features
	__lowerCAmelCase												=  (
	    Features({feature: Value(lowerCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
	)
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		features=lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	_check_json_dataset(lowerCamelCase				,		lowerCamelCase					)



@pytest.mark.parametrize(
    "features"				,		[
        None,
        {"col_3": "float64", "col_1": "string", "col_2": "int64"},
    ]				,		)
def   __lowerCAmelCase					(							lowerCamelCase   :						List[Any]				,		lowerCamelCase   :						Optional[int]				,		lowerCamelCase   :						Any					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_3": "float64", "col_1": "string", "col_2": "int64"}
	__lowerCAmelCase												=  features.copy() if features else default_expected_features
	__lowerCAmelCase												=  (
	    Features({feature: Value(lowerCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
	)
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		features=lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	assert isinstance(lowerCamelCase				,		lowerCamelCase					)
	assert dataset.num_rows == 2
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_3", "col_1", "col_2"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype



def   __lowerCAmelCase					(							lowerCamelCase   :						Any				,		lowerCamelCase   :						Optional[int]					):






	'''simple docstring'''




	__lowerCAmelCase												=  {"col_2": "int64", "col_3": "float64", "col_1": "string"}
	__lowerCAmelCase												=  features.copy()
	__lowerCAmelCase												=  (
	    Features({feature: Value(lowerCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
	)
	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		features=lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	assert isinstance(lowerCamelCase				,		lowerCamelCase					)
	assert dataset.num_rows == 2
	assert dataset.num_columns == 3
	assert dataset.column_names == ["col_2", "col_3", "col_1"]
	for feature, expected_dtype in expected_features.items():
		assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("split"				,		[None, NamedSplit("train"					), "train", "test"]					)
def   __lowerCAmelCase					(							lowerCamelCase   :						List[Any]				,		lowerCamelCase   :						Optional[Any]				,		lowerCamelCase   :						Union[str, Any]					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		cache_dir=lowerCamelCase				,		split=lowerCamelCase					).read()
	_check_json_dataset(lowerCamelCase				,		lowerCamelCase					)
	assert dataset.split == split if split else "train"



@pytest.mark.parametrize("path_type"				,		[str, list]					)
def   __lowerCAmelCase					(							lowerCamelCase   :						Any				,		lowerCamelCase   :						List[str]				,		lowerCamelCase   :						Optional[int]					):






	'''simple docstring'''




	if issubclass(lowerCamelCase				,		lowerCamelCase					):
		__lowerCAmelCase												=  jsonl_path
	elif issubclass(lowerCamelCase				,		lowerCamelCase					):
		__lowerCAmelCase												=  [jsonl_path]
	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	_check_json_dataset(lowerCamelCase				,		lowerCamelCase					)



def   __lowerCAmelCase					(							lowerCamelCase   :						Optional[int]				,		lowerCamelCase   :						int				,		lowerCamelCase   :						str=("train",)					):






	'''simple docstring'''




	assert isinstance(lowerCamelCase				,		lowerCamelCase					)
	for split in splits:
		__lowerCAmelCase												=  dataset_dict[split]
		assert dataset.num_rows == 4
		assert dataset.num_columns == 3
		assert dataset.column_names == ["col_1", "col_2", "col_3"]
		for feature, expected_dtype in expected_features.items():
			assert dataset.features[feature].dtype == expected_dtype



@pytest.mark.parametrize("keep_in_memory"				,		[False, True]					)
def   __lowerCAmelCase					(							lowerCamelCase   :						Dict				,		lowerCamelCase   :						int				,		lowerCamelCase   :						List[str]					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
		__lowerCAmelCase												=  JsonDatasetReader({"train": jsonl_path}				,		cache_dir=lowerCamelCase				,		keep_in_memory=lowerCamelCase					).read()
	_check_json_datasetdict(lowerCamelCase				,		lowerCamelCase					)



@pytest.mark.parametrize(
    "features"				,		[
        None,
        {"col_1": "string", "col_2": "int64", "col_3": "float64"},
        {"col_1": "string", "col_2": "string", "col_3": "string"},
        {"col_1": "int32", "col_2": "int32", "col_3": "int32"},
        {"col_1": "float32", "col_2": "float32", "col_3": "float32"},
    ]				,		)
def   __lowerCAmelCase					(							lowerCamelCase   :						int				,		lowerCamelCase   :						Any				,		lowerCamelCase   :						Dict					):






	'''simple docstring'''




	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	__lowerCAmelCase												=  features.copy() if features else default_expected_features
	__lowerCAmelCase												=  (
	    Features({feature: Value(lowerCamelCase					) for feature, dtype in features.items()}					) if features is not None else None
	)
	__lowerCAmelCase												=  JsonDatasetReader({"train": jsonl_path}				,		features=lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	_check_json_datasetdict(lowerCamelCase				,		lowerCamelCase					)



@pytest.mark.parametrize("split"				,		[None, NamedSplit("train"					), "train", "test"]					)
def   __lowerCAmelCase					(							lowerCamelCase   :						int				,		lowerCamelCase   :						Optional[int]				,		lowerCamelCase   :						int					):






	'''simple docstring'''




	if split:
		__lowerCAmelCase												=  {split: jsonl_path}
	else:
		__lowerCAmelCase												=  "train"
		__lowerCAmelCase												=  {"train": jsonl_path, "test": jsonl_path}
	__lowerCAmelCase												=  tmp_path / "cache"
	__lowerCAmelCase												=  {"col_1": "string", "col_2": "int64", "col_3": "float64"}
	__lowerCAmelCase												=  JsonDatasetReader(lowerCamelCase				,		cache_dir=lowerCamelCase					).read()
	_check_json_datasetdict(lowerCamelCase				,		lowerCamelCase				,		splits=list(path.keys()					)					)
	assert all(dataset[split].split == split for split in path.keys()					)



def   __lowerCAmelCase					(							lowerCamelCase   :						Optional[Any]					):






	'''simple docstring'''




	return json.load(lowerCamelCase					)



def   __lowerCAmelCase					(							lowerCamelCase   :						Tuple					):






	'''simple docstring'''




	return [json.loads(lowerCamelCase					) for line in buffer]






class 					UpperCAmelCase__	:



					@pytest.mark.parametrize("lines, load_json_function"			,				[(True, load_json_lines), (False, load_json)]     )
					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			int:
						with io.BytesIO() as buffer:
							JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				lines=UpperCamelCase     ).write()
							buffer.seek(0     )
							__lowerCAmelCase												=  load_json_function(UpperCamelCase     )
						assert isinstance(UpperCamelCase			,				UpperCamelCase     )
						assert isinstance(exported_content[0]			,				UpperCamelCase     )
						assert len(UpperCamelCase     ) == 10



					@pytest.mark.parametrize(
					    "orient, container, keys, len_at"			,				[
					        ("records", list, {"tokens", "labels", "answers", "id"}, None),
					        ("split", dict, {"columns", "data"}, "data"),
					        ("index", dict, set("0123456789"     ), None),
					        ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
					        ("values", list, None, None),
					        ("table", dict, {"schema", "data"}, "data"),
					    ]			,				)
					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			int:
						with io.BytesIO() as buffer:
							JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				lines=UpperCamelCase			,				orient=UpperCamelCase     ).write()
							buffer.seek(0     )
							__lowerCAmelCase												=  load_json(UpperCamelCase     )
						assert isinstance(UpperCamelCase			,				UpperCamelCase     )
						if keys:
							if container is dict:
								assert exported_content.keys() == keys
							else:
								assert exported_content[0].keys() == keys
						else:
							assert not hasattr(UpperCamelCase			,				"keys"     ) and not hasattr(exported_content[0]			,				"keys"     )
						if len_at:
							assert len(exported_content[len_at]     ) == 10
						else:
							assert len(UpperCamelCase     ) == 10



					@pytest.mark.parametrize("lines, load_json_function"			,				[(True, load_json_lines), (False, load_json)]     )
					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			str:
						with io.BytesIO() as buffer:
							JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				lines=UpperCamelCase			,				num_proc=2     ).write()
							buffer.seek(0     )
							__lowerCAmelCase												=  load_json_function(UpperCamelCase     )
						assert isinstance(UpperCamelCase			,				UpperCamelCase     )
						assert isinstance(exported_content[0]			,				UpperCamelCase     )
						assert len(UpperCamelCase     ) == 10



					@pytest.mark.parametrize(
					    "orient, container, keys, len_at"			,				[
					        ("records", list, {"tokens", "labels", "answers", "id"}, None),
					        ("split", dict, {"columns", "data"}, "data"),
					        ("index", dict, set("0123456789"     ), None),
					        ("columns", dict, {"tokens", "labels", "answers", "id"}, "tokens"),
					        ("values", list, None, None),
					        ("table", dict, {"schema", "data"}, "data"),
					    ]			,				)
					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Union[str, Any]:
						with io.BytesIO() as buffer:
							JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				lines=UpperCamelCase			,				orient=UpperCamelCase			,				num_proc=2     ).write()
							buffer.seek(0     )
							__lowerCAmelCase												=  load_json(UpperCamelCase     )
						assert isinstance(UpperCamelCase			,				UpperCamelCase     )
						if keys:
							if container is dict:
								assert exported_content.keys() == keys
							else:
								assert exported_content[0].keys() == keys
						else:
							assert not hasattr(UpperCamelCase			,				"keys"     ) and not hasattr(exported_content[0]			,				"keys"     )
						if len_at:
							assert len(exported_content[len_at]     ) == 10
						else:
							assert len(UpperCamelCase     ) == 10



					def        UpperCAmelCase_ (    self			,				UpperCamelCase     )     ->			Any:
						with pytest.raises(UpperCamelCase     ):
							with io.BytesIO() as buffer:
								JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				num_proc=0     )



					@pytest.mark.parametrize("compression, extension"			,				[("gzip", "gz"), ("bz2", "bz2"), ("xz", "xz")]     )
					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  tmp_path_factory.mktemp("data"     ) / F'''test.json.{extension}'''
						__lowerCAmelCase												=  str(shared_datadir / F'''test_file.json.{extension}'''     )
						JsonDatasetWriter(UpperCamelCase			,				UpperCamelCase			,				compression=UpperCamelCase     ).write()

						with fsspec.open(UpperCamelCase			,				"rb"			,				compression="infer"     ) as f:
							__lowerCAmelCase												=  f.read()
						with fsspec.open(UpperCamelCase			,				"rb"			,				compression="infer"     ) as f:
							__lowerCAmelCase												=  f.read()
						assert exported_content == original_content