



'''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]      ):
		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:     Any ,   _lowerCamelCase:     Optional[Any] ,   _lowerCamelCase:     Any      ):
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	List[Any]					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
				__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	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[str] ,   _lowerCamelCase:     Dict ,   _lowerCamelCase:     Optional[Any]      ):
		__SCREAMING_SNAKE_CASE :	Tuple					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	Tuple					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	features.copy() if features else default_expected_features
		__SCREAMING_SNAKE_CASE :	int					 =	(
		    Features({feature: Value(_lowerCamelCase      ) for feature, dtype in features.items()}      ) if features is not None else None
		)
		__SCREAMING_SNAKE_CASE :	int					 =	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:     Tuple ,   _lowerCamelCase:     Dict ,   _lowerCamelCase:     Tuple      ):
		__SCREAMING_SNAKE_CASE :	Any					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	{"""col_3""": """float64""", """col_1""": """string""", """col_2""": """int64"""}
		__SCREAMING_SNAKE_CASE :	Any					 =	features.copy() if features else default_expected_features
		__SCREAMING_SNAKE_CASE :	str					 =	(
		    Features({feature: Value(_lowerCamelCase      ) for feature, dtype in features.items()}      ) if features is not None else None
		)
		__SCREAMING_SNAKE_CASE :	List[Any]					 =	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:     List[str] ,   _lowerCamelCase:     List[str]      ):
		# jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
		__SCREAMING_SNAKE_CASE :	Dict					 =	{"""col_2""": """int64""", """col_3""": """float64""", """col_1""": """string"""}
		__SCREAMING_SNAKE_CASE :	int					 =	features.copy()
		__SCREAMING_SNAKE_CASE :	Any					 =	(
		    Features({feature: Value(_lowerCamelCase      ) for feature, dtype in features.items()}      ) if features is not None else None
		)
		__SCREAMING_SNAKE_CASE :	int					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	Dict					 =	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:     Union[str, Any] ,   _lowerCamelCase:     Any ,   _lowerCamelCase:     List[str]      ):
		__SCREAMING_SNAKE_CASE :	Tuple					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		__SCREAMING_SNAKE_CASE :	str					 =	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:     Optional[int] ,   _lowerCamelCase:     Any ,   _lowerCamelCase:     int      ):
		if issubclass(_lowerCamelCase ,   _lowerCamelCase      ):
				__SCREAMING_SNAKE_CASE :	Any					 =	jsonl_path
		elif issubclass(_lowerCamelCase ,   _lowerCamelCase      ):
				__SCREAMING_SNAKE_CASE :	Any					 =	[jsonl_path]
		__SCREAMING_SNAKE_CASE :	int					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	List[str]					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		__SCREAMING_SNAKE_CASE :	Tuple					 =	JsonDatasetReader(_lowerCamelCase ,   cache_dir=_lowerCamelCase      ).read()
		_check_json_dataset(_lowerCamelCase ,   _lowerCamelCase      )


def        lowerCAmelCase_     (			_lowerCamelCase:     Optional[Any] ,   _lowerCamelCase:     Dict ,   _lowerCamelCase:     str=("train",)      ):
		assert isinstance(_lowerCamelCase ,   _lowerCamelCase      )
		for split in splits:
				__SCREAMING_SNAKE_CASE :	Dict					 =	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:     str ,   _lowerCamelCase:     int ,   _lowerCamelCase:     Dict      ):
		__SCREAMING_SNAKE_CASE :	str					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	int					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
				__SCREAMING_SNAKE_CASE :	int					 =	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:     List[Any] ,   _lowerCamelCase:     Any ,   _lowerCamelCase:     Dict      ):
		__SCREAMING_SNAKE_CASE :	List[str]					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		__SCREAMING_SNAKE_CASE :	Dict					 =	features.copy() if features else default_expected_features
		__SCREAMING_SNAKE_CASE :	str					 =	(
		    Features({feature: Value(_lowerCamelCase      ) for feature, dtype in features.items()}      ) if features is not None else None
		)
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	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:     Optional[Any] ,   _lowerCamelCase:     Any ,   _lowerCamelCase:     Tuple      ):
		if split:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	{split: jsonl_path}
		else:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	"""train"""
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	{"""train""": jsonl_path, """test""": jsonl_path}
		__SCREAMING_SNAKE_CASE :	str					 =	tmp_path / """cache"""
		__SCREAMING_SNAKE_CASE :	List[Any]					 =	{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
		__SCREAMING_SNAKE_CASE :	List[str]					 =	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:     Union[str, Any]      ):
		return json.load(_lowerCamelCase      )


def        lowerCAmelCase_     (			_lowerCamelCase:     Dict      ):
		return [json.loads(_lowerCamelCase      ) for line in buffer]






class 		_UpperCamelCase						:


			'''simple docstring'''

			@pytest.mark.parametrize("""lines, load_json_function"""							,  [(True, load_json_lines), (False, load_json)]		)
			def UpperCamelCase__      (							self  :				Union[str, Any]							,  lowerCAmelCase__  :				Tuple							,  lowerCAmelCase__  :				int							,  lowerCAmelCase__  :				List[str]		):





					"""simple docstring"""






					with io.BytesIO() as buffer:
							JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  lines=lowerCAmelCase__		).write()
							buffer.seek(0		)
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	load_json_function(lowerCAmelCase__		)
					assert isinstance(lowerCAmelCase__							,  lowerCAmelCase__		)
					assert isinstance(exported_content[0]							,  lowerCAmelCase__		)
					assert len(lowerCAmelCase__		) == 1_0

			@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  :				Dict							,  lowerCAmelCase__  :				Tuple							,  lowerCAmelCase__  :				Optional[Any]							,  lowerCAmelCase__  :				Optional[Any]							,  lowerCAmelCase__  :				List[Any]							,  lowerCAmelCase__  :				Optional[int]		):





					"""simple docstring"""






					with io.BytesIO() as buffer:
							JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  lines=lowerCAmelCase__							,  orient=lowerCAmelCase__		).write()
							buffer.seek(0		)
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	load_json(lowerCAmelCase__		)
					assert isinstance(lowerCAmelCase__							,  lowerCAmelCase__		)
					if keys:
							if container is dict:
									assert exported_content.keys() == keys
							else:
									assert exported_content[0].keys() == keys
					else:
							assert not hasattr(lowerCAmelCase__							,  """keys"""		) and not hasattr(exported_content[0]							,  """keys"""		)
					if len_at:
							assert len(exported_content[len_at]		) == 1_0
					else:
							assert len(lowerCAmelCase__		) == 1_0

			@pytest.mark.parametrize("""lines, load_json_function"""							,  [(True, load_json_lines), (False, load_json)]		)
			def UpperCamelCase__      (							self  :				List[str]							,  lowerCAmelCase__  :				str							,  lowerCAmelCase__  :				Dict							,  lowerCAmelCase__  :				Tuple		):





					"""simple docstring"""






					with io.BytesIO() as buffer:
							JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  lines=lowerCAmelCase__							,  num_proc=2		).write()
							buffer.seek(0		)
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	load_json_function(lowerCAmelCase__		)
					assert isinstance(lowerCAmelCase__							,  lowerCAmelCase__		)
					assert isinstance(exported_content[0]							,  lowerCAmelCase__		)
					assert len(lowerCAmelCase__		) == 1_0

			@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  :				str							,  lowerCAmelCase__  :				Optional[Any]							,  lowerCAmelCase__  :				Tuple							,  lowerCAmelCase__  :				Union[str, Any]							,  lowerCAmelCase__  :				Optional[int]							,  lowerCAmelCase__  :				Dict		):





					"""simple docstring"""






					with io.BytesIO() as buffer:
							JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  lines=lowerCAmelCase__							,  orient=lowerCAmelCase__							,  num_proc=2		).write()
							buffer.seek(0		)
							__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	load_json(lowerCAmelCase__		)
					assert isinstance(lowerCAmelCase__							,  lowerCAmelCase__		)
					if keys:
							if container is dict:
									assert exported_content.keys() == keys
							else:
									assert exported_content[0].keys() == keys
					else:
							assert not hasattr(lowerCAmelCase__							,  """keys"""		) and not hasattr(exported_content[0]							,  """keys"""		)
					if len_at:
							assert len(exported_content[len_at]		) == 1_0
					else:
							assert len(lowerCAmelCase__		) == 1_0

			def UpperCamelCase__      (							self  :				Union[str, Any]							,  lowerCAmelCase__  :				Dict		):





					"""simple docstring"""






					with pytest.raises(lowerCAmelCase__		):
							with io.BytesIO() as buffer:
									JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  num_proc=0		)



			@pytest.mark.parametrize("""compression, extension"""							,  [("""gzip""", """gz"""), ("""bz2""", """bz2"""), ("""xz""", """xz""")]		)
			def UpperCamelCase__      (							self  :				Any							,  lowerCAmelCase__  :				Union[str, Any]							,  lowerCAmelCase__  :				Union[str, Any]							,  lowerCAmelCase__  :				List[str]							,  lowerCAmelCase__  :				Optional[Any]							,  lowerCAmelCase__  :				Dict		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	int					 =	tmp_path_factory.mktemp("""data"""		) / F"test.json.{extension}"
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	str(shared_datadir / F"test_file.json.{extension}"		)
					JsonDatasetWriter(lowerCAmelCase__							,  lowerCAmelCase__							,  compression=lowerCAmelCase__		).write()

					with fsspec.open(lowerCAmelCase__							,  """rb"""							,  compression="""infer"""		) as f:
							__SCREAMING_SNAKE_CASE :	List[Any]					 =	f.read()
					with fsspec.open(lowerCAmelCase__							,  """rb"""							,  compression="""infer"""		) as f:
							__SCREAMING_SNAKE_CASE :	Tuple					 =	f.read()
					assert exported_content == original_content




'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCamelCase__ :			Any												=				logging.get_logger(__name__)

UpperCamelCase__ :			Dict												=				{
    '''microsoft/beit-base-patch16-224-pt22k''': (
        '''https://huggingface.co/microsoft/beit-base-patch16-224-pt22k/resolve/main/config.json'''
    ),
    # See all BEiT models at https://huggingface.co/models?filter=beit
}






class 		_UpperCamelCase						(							lowerCamelCase__					):


			'''simple docstring'''

			_A   :	Optional[int]    					=	'''beit'''

			def __init__(							self  :				Tuple							,  lowerCAmelCase__  :				List[Any]=8_1_9_2							,  lowerCAmelCase__  :				List[Any]=7_6_8							,  lowerCAmelCase__  :				List[Any]=1_2							,  lowerCAmelCase__  :				Union[str, Any]=1_2							,  lowerCAmelCase__  :				Dict=3_0_7_2							,  lowerCAmelCase__  :				List[Any]="gelu"							,  lowerCAmelCase__  :				List[Any]=0.0							,  lowerCAmelCase__  :				int=0.0							,  lowerCAmelCase__  :				Tuple=0.02							,  lowerCAmelCase__  :				Any=1E-12							,  lowerCAmelCase__  :				Dict=2_2_4							,  lowerCAmelCase__  :				List[str]=1_6							,  lowerCAmelCase__  :				int=3							,  lowerCAmelCase__  :				Union[str, Any]=False							,  lowerCAmelCase__  :				Union[str, Any]=False							,  lowerCAmelCase__  :				Any=False							,  lowerCAmelCase__  :				Union[str, Any]=False							,  lowerCAmelCase__  :				Optional[int]=0.1							,  lowerCAmelCase__  :				Dict=0.1							,  lowerCAmelCase__  :				Tuple=True							,  lowerCAmelCase__  :				str=[3, 5, 7, 1_1]							,  lowerCAmelCase__  :				str=[1, 2, 3, 6]							,  lowerCAmelCase__  :				Dict=True							,  lowerCAmelCase__  :				Dict=0.4							,  lowerCAmelCase__  :				int=2_5_6							,  lowerCAmelCase__  :				Any=1							,  lowerCAmelCase__  :				str=False							,  lowerCAmelCase__  :				Union[str, Any]=2_5_5							,  **lowerCAmelCase__  :				Optional[int]							,  ):





					"""simple docstring"""






					super().__init__(**lowerCAmelCase__		)

					__SCREAMING_SNAKE_CASE :	int					 =	vocab_size
					__SCREAMING_SNAKE_CASE :	int					 =	hidden_size
					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	num_hidden_layers
					__SCREAMING_SNAKE_CASE :	List[str]					 =	num_attention_heads
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	intermediate_size
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	hidden_act
					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	hidden_dropout_prob
					__SCREAMING_SNAKE_CASE :	Any					 =	attention_probs_dropout_prob
					__SCREAMING_SNAKE_CASE :	Dict					 =	initializer_range
					__SCREAMING_SNAKE_CASE :	Any					 =	layer_norm_eps

					__SCREAMING_SNAKE_CASE :	Dict					 =	image_size
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	patch_size
					__SCREAMING_SNAKE_CASE :	int					 =	num_channels
					__SCREAMING_SNAKE_CASE :	Tuple					 =	use_mask_token
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	use_absolute_position_embeddings
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	use_relative_position_bias
					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	use_shared_relative_position_bias
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	layer_scale_init_value
					__SCREAMING_SNAKE_CASE :	Any					 =	drop_path_rate
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	use_mean_pooling
					# decode head attributes (semantic segmentation)
					__SCREAMING_SNAKE_CASE :	Any					 =	out_indices
					__SCREAMING_SNAKE_CASE :	List[Any]					 =	pool_scales
					# auxiliary head attributes (semantic segmentation)
					__SCREAMING_SNAKE_CASE :	List[Any]					 =	use_auxiliary_head
					__SCREAMING_SNAKE_CASE :	str					 =	auxiliary_loss_weight
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	auxiliary_channels
					__SCREAMING_SNAKE_CASE :	str					 =	auxiliary_num_convs
					__SCREAMING_SNAKE_CASE :	int					 =	auxiliary_concat_input
					__SCREAMING_SNAKE_CASE :	Dict					 =	semantic_loss_ignore_index






class 		_UpperCamelCase						(							lowerCamelCase__					):


			'''simple docstring'''

			_A   :	List[str]    					=	version.parse('''1.11'''					)

			@property
			def UpperCamelCase__      (							self  :				List[str]		):





					"""simple docstring"""






					return OrderedDict(
					    [
					        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
					    ]		)



			@property
			def UpperCamelCase__      (							self  :				Any		):





					"""simple docstring"""






					return 1E-4