





"""simple docstring"""






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

		if is_vision_available():
				from transformers import MaskaFormerImageProcessor

if is_vision_available():
		from PIL import Image




class 				__lowercase			:







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase	,			_UpperCAmelCase=2	,			_UpperCAmelCase=True	,			_UpperCAmelCase=False	,			_UpperCAmelCase=10	,			_UpperCAmelCase=3	,			_UpperCAmelCase=32 * 8	,			_UpperCAmelCase=32 * 8	,			_UpperCAmelCase=4	,			_UpperCAmelCase=64	,			):
									__a :						Union[str, Any]			       =  parent
									__a :						Any			       =  batch_size
									__a :						Any			       =  is_training
									__a :						List[Any]			       =  use_auxiliary_loss
									__a :						List[str]			       =  num_queries
									__a :						Tuple			       =  num_channels
									__a :						Optional[Any]			       =  min_size
									__a :						Any			       =  max_size
									__a :						Tuple			       =  num_labels
									__a :						int			       =  hidden_dim
									__a :						List[Any]			       =  hidden_dim







					def  _lowerCamelCase		(						self     ):
									__a :						Optional[Any]			       =  floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]     ).to(
									    A__     )

									__a :						Optional[Any]			       =  torch.ones([self.batch_size, self.min_size, self.max_size]	,			device=A__     )

									__a :						int			       =  (
									    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]	,			device=A__     ) > 0.5
									).float()
									__a :						List[str]			       =  (torch.rand((self.batch_size, self.num_labels)	,			device=A__     ) > 0.5).long()

									__a :						Optional[Any]			       =  self.get_config()
									return config, pixel_values, pixel_mask, mask_labels, class_labels







					def  _lowerCamelCase		(						self     ):
									__a :						Any			       =  MaskaFormerConfig(
									    hidden_size=self.hidden_dim	,			)
									__a :						str			       =  self.num_queries
									__a :						Optional[int]			       =  self.num_labels

									__a :						Union[str, Any]			       =  [1, 1, 1, 1]
									__a :						Dict			       =  self.num_channels

									__a :						str			       =  64
									__a :						Tuple			       =  128
									__a :						List[str]			       =  self.hidden_dim
									__a :						str			       =  self.hidden_dim
									__a :						Any			       =  self.hidden_dim
									return config







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a       ,						__a       ,						__a       ,						__a :						Any			       =  self.prepare_config_and_inputs()
									__a :						Union[str, Any]			       =  {'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
									return config, inputs_dict







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						int			       =  output.encoder_hidden_states
									__a :						Optional[int]			       =  output.pixel_decoder_hidden_states
									__a :						str			       =  output.transformer_decoder_hidden_states

									self.parent.assertTrue(len(A__     )	,			len(config.backbone_config.depths     )     )
									self.parent.assertTrue(len(A__     )	,			len(config.backbone_config.depths     )     )
									self.parent.assertTrue(len(A__     )	,			config.decoder_layers     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase=False     ):
									with torch.no_grad():
													__a :						Union[str, Any]			       =  MaskaFormerModel(config=A__     )
													model.to(A__     )
													model.eval()

													__a :						Optional[int]			       =  model(pixel_values=A__	,			pixel_mask=A__     )
													__a :						List[Any]			       =  model(A__	,			output_hidden_states=A__     )

									self.parent.assertEqual(
									    output.transformer_decoder_last_hidden_state.shape	,			(self.batch_size, self.num_queries, self.hidden_dim)	,			)
									# let's ensure the other two hidden state exists
									self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None     )
									self.parent.assertTrue(output.encoder_last_hidden_state is not None     )

									if output_hidden_states:
													self.check_output_hidden_state(A__	,			A__     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Dict			       =  MaskaFormerForUniversalSegmentation(config=A__     )
									model.to(A__     )
									model.eval()

									def comm_check_on_output(_UpperCAmelCase     ):
													# let's still check that all the required stuff is there
													self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None     )
													self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None     )
													self.parent.assertTrue(result.encoder_last_hidden_state is not None     )
													# okay, now we need to check the logits shape
													# due to the encoder compression, masks have a //4 spatial size
													self.parent.assertEqual(
													    result.masks_queries_logits.shape	,			(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)	,			)
													# + 1 for null class
													self.parent.assertEqual(
													    result.class_queries_logits.shape	,			(self.batch_size, self.num_queries, self.num_labels + 1)     )

									with torch.no_grad():
													__a :						List[str]			       =  model(pixel_values=A__	,			pixel_mask=A__     )
													__a :						List[str]			       =  model(A__     )

													comm_check_on_output(A__     )

													__a :						str			       =  model(
													    pixel_values=A__	,			pixel_mask=A__	,			mask_labels=A__	,			class_labels=A__     )

									comm_check_on_output(A__     )

									self.parent.assertTrue(result.loss is not None     )
									self.parent.assertEqual(result.loss.shape	,			torch.Size([1]     )     )






@require_torch
class 				__lowercase			(			__a   ,      __a   ,      unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
					__lowerCAmelCase  =  {'''feature-extraction''': MaskaFormerModel} if is_torch_available() else {}

					__lowerCAmelCase  =  False
					__lowerCAmelCase  =  False
					__lowerCAmelCase  =  False
					__lowerCAmelCase  =  False







					def  _lowerCamelCase		(						self     ):
									__a :						Optional[int]			       =  MaskaFormerModelTester(self     )
									__a :						int			       =  ConfigTester(self	,			config_class=A__	,			has_text_modality=A__     )







					def  _lowerCamelCase		(						self     ):
									self.config_tester.run_common_tests()







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						Optional[Any]			       =  self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.create_and_check_maskaformer_model(A__	,			**A__	,			output_hidden_states=A__     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*A__     )







					@unittest.skip(reason='''Mask2Former does not use inputs_embeds'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					@unittest.skip(reason='''Mask2Former does not have a get_input_embeddings method'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					@unittest.skip(reason='''Mask2Former is not a generative model'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					@unittest.skip(reason='''Mask2Former does not use token embeddings'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					@require_torch_multi_gpu
					@unittest.skip(
					    reason='''Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''     )
					def  _lowerCamelCase		(						self     ):
									pass







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						Union[str, Any]			       =  self.model_tester.prepare_config_and_inputs_for_common()

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

													__a :						List[str]			       =  ['''pixel_values''']
													self.assertListEqual(arg_names[:1]	,			A__     )







					@slow
					def  _lowerCamelCase		(						self     ):
									for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
													__a :						Optional[int]			       =  MaskaFormerModel.from_pretrained(A__     )
													self.assertIsNotNone(A__     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  (self.model_tester.min_size,) * 2
									__a :						int			       =  {
									    '''pixel_values''': torch.randn((2, 3, *size)	,			device=A__     ),
									    '''mask_labels''': torch.randn((2, 10, *size)	,			device=A__     ),
									    '''class_labels''': torch.zeros(2	,			10	,			device=A__     ).long(),
									}
									__a :						Optional[int]			       =  self.model_tester.get_config()

									__a :						Tuple			       =  MaskaFormerForUniversalSegmentation(A__     ).to(A__     )
									__a :						Dict			       =  model(**A__     )
									self.assertTrue(outputs.loss is not None     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						int			       =  self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.create_and_check_maskaformer_model(A__	,			**A__	,			output_hidden_states=A__     )







					def  _lowerCamelCase		(						self     ):
									__a       ,						__a :						str			       =  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__a :						Tuple			       =  model_class(A__     ).to(A__     )
													__a :						int			       =  model(**A__	,			output_attentions=A__     )
													self.assertTrue(outputs.attentions is not None     )







					def  _lowerCamelCase		(						self     ):
									if not self.model_tester.is_training:
													return

									__a :						Dict			       =  self.all_model_classes[1]
									__a       ,						__a       ,						__a       ,						__a       ,						__a :						Optional[Any]			       =  self.model_tester.prepare_config_and_inputs()

									__a :						Optional[int]			       =  model_class(A__     )
									model.to(A__     )
									model.train()

									__a :						int			       =  model(A__	,			mask_labels=A__	,			class_labels=A__     ).loss
									loss.backward()







					def  _lowerCamelCase		(						self     ):
									__a :						Optional[Any]			       =  self.all_model_classes[1]
									__a       ,						__a       ,						__a       ,						__a       ,						__a :						Any			       =  self.model_tester.prepare_config_and_inputs()
									__a :						Optional[Any]			       =  True
									__a :						Union[str, Any]			       =  True

									__a :						Tuple			       =  model_class(A__     ).to(A__     )
									model.train()

									__a :						Optional[Any]			       =  model(A__	,			mask_labels=A__	,			class_labels=A__     )

									__a :						Tuple			       =  outputs.encoder_hidden_states[0]
									encoder_hidden_states.retain_grad()

									__a :						Union[str, Any]			       =  outputs.pixel_decoder_hidden_states[0]
									pixel_decoder_hidden_states.retain_grad()

									__a :						List[Any]			       =  outputs.transformer_decoder_hidden_states[0]
									transformer_decoder_hidden_states.retain_grad()

									__a :						Union[str, Any]			       =  outputs.attentions[0]
									attentions.retain_grad()

									outputs.loss.backward(retain_graph=A__     )

									self.assertIsNotNone(encoder_hidden_states.grad     )
									self.assertIsNotNone(pixel_decoder_hidden_states.grad     )
									self.assertIsNotNone(transformer_decoder_hidden_states.grad     )
									self.assertIsNotNone(attentions.grad     )






A 			=  1e-4




def     __A      (			)		->		Union[str, Any]:
				__a :						Any			       =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image






@require_vision
@slow
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					@cached_property
					def  _lowerCamelCase		(						self     ):
									return "facebook/mask2former-swin-small-coco-instance"







					@cached_property
					def  _lowerCamelCase		(						self     ):
									return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints     ) if is_vision_available() else None







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  MaskaFormerModel.from_pretrained(self.model_checkpoints     ).to(A__     )
									__a :						List[Any]			       =  self.default_image_processor
									__a :						Dict			       =  prepare_img()
									__a :						List[str]			       =  image_processor(A__	,			return_tensors='''pt'''     ).to(A__     )
									__a :						int			       =  inputs['''pixel_values'''].shape
									# check size is divisible by 32
									self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0     )
									# check size
									self.assertEqual(A__	,			(1, 3, 384, 384)     )

									with torch.no_grad():
													__a :						List[str]			       =  model(**A__     )

									__a :						Union[str, Any]			       =  torch.tensor(
									    [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]]     ).to(A__     )
									self.assertTrue(
									    torch.allclose(
									        outputs.encoder_last_hidden_state[0, 0, :3, :3]	,			A__	,			atol=A__     )     )

									__a :						List[str]			       =  torch.tensor(
									    [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]]     ).to(A__     )
									self.assertTrue(
									    torch.allclose(
									        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]	,			A__	,			atol=A__     )     )

									__a :						Union[str, Any]			       =  torch.tensor(
									    [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]]     ).to(A__     )
									self.assertTrue(
									    torch.allclose(
									        outputs.transformer_decoder_last_hidden_state[0, :3, :3]	,			A__	,			atol=A__     )     )







					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints     ).to(A__     ).eval()
									__a :						Any			       =  self.default_image_processor
									__a :						Optional[Any]			       =  prepare_img()
									__a :						List[Any]			       =  image_processor(A__	,			return_tensors='''pt'''     ).to(A__     )
									__a :						List[str]			       =  inputs['''pixel_values'''].shape
									# check size is divisible by 32
									self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0     )
									# check size
									self.assertEqual(A__	,			(1, 3, 384, 384)     )

									with torch.no_grad():
													__a :						str			       =  model(**A__     )
									# masks_queries_logits
									__a :						List[str]			       =  outputs.masks_queries_logits
									self.assertEqual(
									    masks_queries_logits.shape	,			(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)     )
									__a :						Any			       =  [
									    [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1],
									    [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1],
									    [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5],
									]
									__a :						Any			       =  torch.tensor(A__     ).to(A__     )
									self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]	,			A__	,			atol=A__     )     )
									# class_queries_logits
									__a :						List[str]			       =  outputs.class_queries_logits
									self.assertEqual(class_queries_logits.shape	,			(1, model.config.num_queries, model.config.num_labels + 1)     )
									__a :						str			       =  torch.tensor(
									    [
									        [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2],
									        [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3],
									        [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5],
									    ]     ).to(A__     )
									self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]	,			A__	,			atol=A__     )     )







					def  _lowerCamelCase		(						self     ):
									__a :						Union[str, Any]			       =  MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints     ).to(A__     ).eval()
									__a :						Tuple			       =  self.default_image_processor

									__a :						Optional[Any]			       =  image_processor(
									    [np.zeros((3, 800, 1333)     ), np.zeros((3, 800, 1333)     )]	,			segmentation_maps=[np.zeros((384, 384)     ).astype(np.floataa     ), np.zeros((384, 384)     ).astype(np.floataa     )]	,			return_tensors='''pt'''	,			)

									__a :						str			       =  inputs['''pixel_values'''].to(A__     )
									__a :						Optional[int]			       =  [el.to(A__     ) for el in inputs['''mask_labels''']]
									__a :						Optional[Any]			       =  [el.to(A__     ) for el in inputs['''class_labels''']]

									with torch.no_grad():
													__a :						Tuple			       =  model(**A__     )

									self.assertTrue(outputs.loss is not None     )






"""simple docstring"""






import copy
from collections import OrderedDict
from typing import Dict, Mapping

from packaging import version

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


A 			=  logging.get_logger(__name__)

A 			=  {
    '''facebook/detr-resnet-50''': '''https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json''',
    # See all DETR models at https://huggingface.co/models?filter=detr
}




class 				__lowercase			(			_UpperCamelCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  '''detr'''
					__lowerCAmelCase  =  ['''past_key_values''']
					__lowerCAmelCase  =  {
					    '''hidden_size''': '''d_model''',
					    '''num_attention_heads''': '''encoder_attention_heads''',
					}







					def __init__(						self	,			_UpperCAmelCase=True	,			_UpperCAmelCase=None	,			_UpperCAmelCase=3	,			_UpperCAmelCase=100	,			_UpperCAmelCase=6	,			_UpperCAmelCase=2048	,			_UpperCAmelCase=8	,			_UpperCAmelCase=6	,			_UpperCAmelCase=2048	,			_UpperCAmelCase=8	,			_UpperCAmelCase=0.0	,			_UpperCAmelCase=0.0	,			_UpperCAmelCase=True	,			_UpperCAmelCase="relu"	,			_UpperCAmelCase=256	,			_UpperCAmelCase=0.1	,			_UpperCAmelCase=0.0	,			_UpperCAmelCase=0.0	,			_UpperCAmelCase=0.0_2	,			_UpperCAmelCase=1.0	,			_UpperCAmelCase=False	,			_UpperCAmelCase="sine"	,			_UpperCAmelCase="resnet50"	,			_UpperCAmelCase=True	,			_UpperCAmelCase=False	,			_UpperCAmelCase=1	,			_UpperCAmelCase=5	,			_UpperCAmelCase=2	,			_UpperCAmelCase=1	,			_UpperCAmelCase=1	,			_UpperCAmelCase=5	,			_UpperCAmelCase=2	,			_UpperCAmelCase=0.1	,			**_UpperCAmelCase	,			):
									if backbone_config is not None and use_timm_backbone:
													raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.'''     )

									if not use_timm_backbone:
													if backbone_config is None:
																	logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''     )
																	__a :						Any			       =  CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']     )
													elif isinstance(_UpperCAmelCase	,			_UpperCAmelCase     ):
																	__a :						Optional[int]			       =  backbone_config.get('''model_type'''     )
																	__a :						Tuple			       =  CONFIG_MAPPING[backbone_model_type]
																	__a :						Union[str, Any]			       =  config_class.from_dict(_UpperCAmelCase     )
													# set timm attributes to None
													__a       ,						__a       ,						__a :						Union[str, Any]			       =  None, None, None

									__a :						Union[str, Any]			       =  use_timm_backbone
									__a :						Any			       =  backbone_config
									__a :						Tuple			       =  num_channels
									__a :						int			       =  num_queries
									__a :						str			       =  d_model
									__a :						Any			       =  encoder_ffn_dim
									__a :						int			       =  encoder_layers
									__a :						Optional[int]			       =  encoder_attention_heads
									__a :						Any			       =  decoder_ffn_dim
									__a :						str			       =  decoder_layers
									__a :						Union[str, Any]			       =  decoder_attention_heads
									__a :						List[Any]			       =  dropout
									__a :						Union[str, Any]			       =  attention_dropout
									__a :						int			       =  activation_dropout
									__a :						Dict			       =  activation_function
									__a :						str			       =  init_std
									__a :						int			       =  init_xavier_std
									__a :						Optional[Any]			       =  encoder_layerdrop
									__a :						Optional[int]			       =  decoder_layerdrop
									__a :						str			       =  encoder_layers
									__a :						List[str]			       =  auxiliary_loss
									__a :						Optional[Any]			       =  position_embedding_type
									__a :						Any			       =  backbone
									__a :						Tuple			       =  use_pretrained_backbone
									__a :						int			       =  dilation
									# Hungarian matcher
									__a :						str			       =  class_cost
									__a :						Optional[Any]			       =  bbox_cost
									__a :						Any			       =  giou_cost
									# Loss coefficients
									__a :						List[str]			       =  mask_loss_coefficient
									__a :						Dict			       =  dice_loss_coefficient
									__a :						str			       =  bbox_loss_coefficient
									__a :						str			       =  giou_loss_coefficient
									__a :						Any			       =  eos_coefficient
									super().__init__(is_encoder_decoder=_UpperCAmelCase	,			**_UpperCAmelCase     )







					@property
					def  _lowerCamelCase		(						self     ):
									return self.encoder_attention_heads







					@property
					def  _lowerCamelCase		(						self     ):
									return self.d_model







					@classmethod
					def  _lowerCamelCase		(						cls	,			_UpperCAmelCase	,			**_UpperCAmelCase     ):
									return cls(backbone_config=_UpperCAmelCase	,			**_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a :						Dict			       =  copy.deepcopy(self.__dict__     )
									if output["backbone_config"] is not None:
													__a :						Tuple			       =  self.backbone_config.to_dict()
									__a :						Dict			       =  self.__class__.model_type
									return output






class 				__lowercase			(			_UpperCamelCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  version.parse('''1.11'''							)







					@property
					def  _lowerCamelCase		(						self     ):
									return OrderedDict(
									    [
									        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
									        ('''pixel_mask''', {0: '''batch'''}),
									    ]     )







					@property
					def  _lowerCamelCase		(						self     ):
									return 1e-5







					@property
					def  _lowerCamelCase		(						self     ):
									return 12