




from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    TFConvBertForMaskedLM,
						    TFConvBertForMultipleChoice,
						    TFConvBertForQuestionAnswering,
						    TFConvBertForSequenceClassification,
						    TFConvBertForTokenClassification,
						    TFConvBertModel,
						)







class 				lowerCAmelCase_       :






				def __init__(			self      ,snake_case__      ,snake_case__=13      ,snake_case__=7      ,snake_case__=True      ,snake_case__=True      ,snake_case__=True      ,snake_case__=True      ,snake_case__=99      ,snake_case__=32      ,snake_case__=2      ,snake_case__=4      ,snake_case__=37      ,snake_case__="gelu"      ,snake_case__=0.1      ,snake_case__=0.1      ,snake_case__=512      ,snake_case__=16      ,snake_case__=2      ,snake_case__=0.02      ,snake_case__=3      ,snake_case__=4      ,snake_case__=None      ,):
							SCREAMING_SNAKE_CASE_   : str					  =      parent
							SCREAMING_SNAKE_CASE_   : Any					  =      13
							SCREAMING_SNAKE_CASE_   : int					  =      7
							SCREAMING_SNAKE_CASE_   : str					  =      True
							SCREAMING_SNAKE_CASE_   : Tuple					  =      True
							SCREAMING_SNAKE_CASE_   : str					  =      True
							SCREAMING_SNAKE_CASE_   : List[str]					  =      True
							SCREAMING_SNAKE_CASE_   : Dict					  =      99
							SCREAMING_SNAKE_CASE_   : int					  =      384
							SCREAMING_SNAKE_CASE_   : Dict					  =      2
							SCREAMING_SNAKE_CASE_   : Tuple					  =      4
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      37
							SCREAMING_SNAKE_CASE_   : Tuple					  =      'gelu'
							SCREAMING_SNAKE_CASE_   : Any					  =      0.1
							SCREAMING_SNAKE_CASE_   : Tuple					  =      0.1
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      512
							SCREAMING_SNAKE_CASE_   : str					  =      16
							SCREAMING_SNAKE_CASE_   : List[str]					  =      2
							SCREAMING_SNAKE_CASE_   : Tuple					  =      0.02
							SCREAMING_SNAKE_CASE_   : Dict					  =      3
							SCREAMING_SNAKE_CASE_   : List[str]					  =      4
							SCREAMING_SNAKE_CASE_   : Tuple					  =      128
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      2
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      9
							SCREAMING_SNAKE_CASE_   : List[str]					  =      1
							SCREAMING_SNAKE_CASE_   : int					  =      None






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size )

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      None
							if self.use_input_mask:
										SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      random_attention_mask([self.batch_size, self.seq_length] )

							SCREAMING_SNAKE_CASE_   : str					  =      None
							if self.use_token_type_ids:
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      ids_tensor([self.batch_size, self.seq_length]      ,self.type_vocab_size )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      None
							SCREAMING_SNAKE_CASE_   : List[str]					  =      None
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      None
							if self.use_labels:
										SCREAMING_SNAKE_CASE_   : Optional[int]					  =      ids_tensor([self.batch_size]      ,self.type_sequence_label_size )
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      ids_tensor([self.batch_size, self.seq_length]      ,self.num_labels )
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      ids_tensor([self.batch_size]      ,self.num_choices )

							SCREAMING_SNAKE_CASE_   : str					  =      ConvBertConfig(
							    vocab_size=self.vocab_size      ,hidden_size=self.hidden_size      ,num_hidden_layers=self.num_hidden_layers      ,num_attention_heads=self.num_attention_heads      ,intermediate_size=self.intermediate_size      ,hidden_act=self.hidden_act      ,hidden_dropout_prob=self.hidden_dropout_prob      ,attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,max_position_embeddings=self.max_position_embeddings      ,type_vocab_size=self.type_vocab_size      ,initializer_range=self.initializer_range      ,return_dict=snake_case__      ,)

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      TFConvBertModel(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      [input_ids, input_mask]
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      model(snake_case__ )

							SCREAMING_SNAKE_CASE_   : Any					  =      model(snake_case__ )

							self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size) )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      TFConvBertForMaskedLM(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      {
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      model(snake_case__ )
							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size) )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      self.num_labels
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      TFConvBertForSequenceClassification(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      {
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      model(snake_case__ )
							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels) )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.num_choices
							SCREAMING_SNAKE_CASE_   : Any					  =      TFConvBertForMultipleChoice(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      tf.tile(tf.expand_dims(snake_case__      ,1 )      ,(1, self.num_choices, 1) )
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.tile(tf.expand_dims(snake_case__      ,1 )      ,(1, self.num_choices, 1) )
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tf.tile(tf.expand_dims(snake_case__      ,1 )      ,(1, self.num_choices, 1) )
							SCREAMING_SNAKE_CASE_   : int					  =      {
							    'input_ids': multiple_choice_inputs_ids,
							    'attention_mask': multiple_choice_input_mask,
							    'token_type_ids': multiple_choice_token_type_ids,
							}
							SCREAMING_SNAKE_CASE_   : int					  =      model(snake_case__ )
							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_choices) )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      self.num_labels
							SCREAMING_SNAKE_CASE_   : Any					  =      TFConvBertForTokenClassification(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      {
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}
							SCREAMING_SNAKE_CASE_   : Dict					  =      model(snake_case__ )
							self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.num_labels) )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      TFConvBertForQuestionAnswering(config=snake_case__ )
							SCREAMING_SNAKE_CASE_   : List[str]					  =      {
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      model(snake_case__ )
							self.parent.assertEqual(result.start_logits.shape      ,(self.batch_size, self.seq_length) )
							self.parent.assertEqual(result.end_logits.shape      ,(self.batch_size, self.seq_length) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.prepare_config_and_inputs()
							(
							    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    (
							    SCREAMING_SNAKE_CASE_
							)  ,    
							)   : int					  =      config_and_inputs
							SCREAMING_SNAKE_CASE_   : Tuple					  =      {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
							return config, inputs_dict







@require_tf
class 				lowerCAmelCase_       (					lowerCamelCase_						,     lowerCamelCase_						,     unittest.TestCase							):
				__a     :       Dict						=     (
				    (
				        TFConvBertModel,
				        TFConvBertForMaskedLM,
				        TFConvBertForQuestionAnswering,
				        TFConvBertForSequenceClassification,
				        TFConvBertForTokenClassification,
				        TFConvBertForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				__a     :       Optional[Any]						=     (
				    {
				        "feature-extraction": TFConvBertModel,
				        "fill-mask": TFConvBertForMaskedLM,
				        "question-answering": TFConvBertForQuestionAnswering,
				        "text-classification": TFConvBertForSequenceClassification,
				        "token-classification": TFConvBertForTokenClassification,
				        "zero-shot": TFConvBertForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__a     :       Any						=     False
				__a     :       List[Any]						=     False
				__a     :       Tuple						=     False






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      TFConvBertModelTester(self )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      ConfigTester(self      ,config_class=snake_case__      ,hidden_size=37 )






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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*snake_case__ )






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Any					  =      self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE_   : int					  =      True
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      True

							if hasattr(snake_case__      ,'use_cache' ):
										SCREAMING_SNAKE_CASE_   : Dict					  =      True

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      getattr(self.model_tester      ,'encoder_seq_length'      ,self.model_tester.seq_length )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      getattr(self.model_tester      ,'key_length'      ,snake_case__ )

							for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_   : Tuple					  =      self._prepare_for_class(snake_case__      ,snake_case__ )
										SCREAMING_SNAKE_CASE_   : List[str]					  =      model_class(snake_case__ )
										SCREAMING_SNAKE_CASE_   : Optional[int]					  =      len(model(snake_case__ ) )

										with tempfile.TemporaryDirectory() as tmpdirname:
													model.save_pretrained(snake_case__      ,saved_model=snake_case__ )
													SCREAMING_SNAKE_CASE_   : List[Any]					  =      os.path.join(snake_case__      ,'saved_model'      ,'1' )
													SCREAMING_SNAKE_CASE_   : Tuple					  =      tf.keras.models.load_model(snake_case__ )
													SCREAMING_SNAKE_CASE_   : Any					  =      model(snake_case__ )

													if self.is_encoder_decoder:
																SCREAMING_SNAKE_CASE_   : int					  =      outputs['encoder_hidden_states']
																SCREAMING_SNAKE_CASE_   : Any					  =      outputs['encoder_attentions']
													else:
																SCREAMING_SNAKE_CASE_   : Optional[int]					  =      outputs['hidden_states']
																SCREAMING_SNAKE_CASE_   : List[Any]					  =      outputs['attentions']

													self.assertEqual(len(snake_case__ )      ,snake_case__ )

													SCREAMING_SNAKE_CASE_   : List[str]					  =      getattr(
													    self.model_tester      ,'expected_num_hidden_layers'      ,self.model_tester.num_hidden_layers + 1 )

													self.assertEqual(len(snake_case__ )      ,snake_case__ )
													self.assertListEqual(
													    list(output_hidden_states[0].shape[-2:] )      ,[self.model_tester.seq_length, self.model_tester.hidden_size]      ,)

													self.assertEqual(len(snake_case__ )      ,self.model_tester.num_hidden_layers )
													self.assertListEqual(
													    list(output_attentions[0].shape[-3:] )      ,[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]      ,)






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      TFConvBertModel.from_pretrained('YituTech/conv-bert-base' )
							self.assertIsNotNone(snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.model_tester.prepare_config_and_inputs_for_common()
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      True
							SCREAMING_SNAKE_CASE_   : Any					  =      getattr(self.model_tester      ,'decoder_seq_length'      ,self.model_tester.seq_length )
							SCREAMING_SNAKE_CASE_   : int					  =      getattr(self.model_tester      ,'encoder_seq_length'      ,self.model_tester.seq_length )
							SCREAMING_SNAKE_CASE_   : str					  =      getattr(self.model_tester      ,'key_length'      ,snake_case__ )
							SCREAMING_SNAKE_CASE_   : List[str]					  =      getattr(self.model_tester      ,'key_length'      ,snake_case__ )

							def check_decoder_attentions_output(snake_case__ ):
										SCREAMING_SNAKE_CASE_   : Tuple					  =      len(snake_case__ )
										self.assertEqual(out_len % 2      ,0 )
										SCREAMING_SNAKE_CASE_   : Tuple					  =      outputs.decoder_attentions
										self.assertEqual(len(snake_case__ )      ,self.model_tester.num_hidden_layers )
										self.assertListEqual(
										    list(decoder_attentions[0].shape[-3:] )      ,[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]      ,)

							def check_encoder_attentions_output(snake_case__ ):
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      [
										    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
										]
										self.assertEqual(len(snake_case__ )      ,self.model_tester.num_hidden_layers )
										self.assertListEqual(
										    list(attentions[0].shape[-3:] )      ,[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]      ,)

							for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_   : Any					  =      True
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      False
										SCREAMING_SNAKE_CASE_   : int					  =      model_class(snake_case__ )
										SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      model(self._prepare_for_class(snake_case__      ,snake_case__ ) )
										SCREAMING_SNAKE_CASE_   : str					  =      len(snake_case__ )
										self.assertEqual(config.output_hidden_states      ,snake_case__ )
										check_encoder_attentions_output(snake_case__ )

										if self.is_encoder_decoder:
													SCREAMING_SNAKE_CASE_   : Any					  =      model_class(snake_case__ )
													SCREAMING_SNAKE_CASE_   : Optional[int]					  =      model(self._prepare_for_class(snake_case__      ,snake_case__ ) )
													self.assertEqual(config.output_hidden_states      ,snake_case__ )
													check_decoder_attentions_output(snake_case__ )

										# Check that output attentions can also be changed via the config
										del inputs_dict["output_attentions"]
										SCREAMING_SNAKE_CASE_   : Dict					  =      True
										SCREAMING_SNAKE_CASE_   : Dict					  =      model_class(snake_case__ )
										SCREAMING_SNAKE_CASE_   : str					  =      model(self._prepare_for_class(snake_case__      ,snake_case__ ) )
										self.assertEqual(config.output_hidden_states      ,snake_case__ )
										check_encoder_attentions_output(snake_case__ )

										# Check attention is always last and order is fine
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      True
										SCREAMING_SNAKE_CASE_   : Tuple					  =      True
										SCREAMING_SNAKE_CASE_   : Dict					  =      model_class(snake_case__ )
										SCREAMING_SNAKE_CASE_   : int					  =      model(self._prepare_for_class(snake_case__      ,snake_case__ ) )

										self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)      ,len(snake_case__ ) )
										self.assertEqual(model.config.output_hidden_states      ,snake_case__ )
										check_encoder_attentions_output(snake_case__ )







@require_tf
class 				lowerCAmelCase_       (					unittest.TestCase							):






				@slow
				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      TFConvBertModel.from_pretrained('YituTech/conv-bert-base' )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      tf.constant([[0, 1, 2, 3, 4, 5]] )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      model(snake_case__ )[0]

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      [1, 6, 768]
							self.assertEqual(output.shape      ,snake_case__ )

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      tf.constant(
							    [
							        [
							            [-0.03475493, -0.4686034, -0.30638832],
							            [0.22637248, -0.26988646, -0.7423424],
							            [0.10324868, -0.45013508, -0.58280784],
							        ]
							    ] )
							tf.debugging.assert_near(output[:, :3, :3]      ,snake_case__      ,atol=1E-4 )








"""simple docstring"""







# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


a_							=    re.compile(r"""^(?P<major>\d+)""" r"""\.(?P<minor>\d+)""" r"""\.(?P<patch>\d+)$""")







@total_ordering
@dataclass
class 					A_:







			"""simple docstring"""



			a_       :			str
			a_       :			Optional[str]												=			None
			a_       :			Optional[Union[str, int]]												=			None
			a_       :			Optional[Union[str, int]]												=			None
			a_       :			Optional[Union[str, int]]												=			None
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase       ,							_lowerCamelCase       ,							_lowerCamelCase					:					List[str]	       =    _str_to_version_tuple(self.version_str							)
			def __repr__(	self							):
						return F"{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"
			@property
			def    _lowerCAmelCase		(	self							):
						return self.major, self.minor, self.patch
			def    _lowerCAmelCase		(	self				,   A							):
						if isinstance(A				,   A							):
									return Version(A							)
						elif isinstance(A				,   A							):
									return other
						raise TypeError(F"{other} (type {type(A							)}) cannot be compared to version."							)
			def __eq__(	self				,   A							):
						try:
									_lowerCamelCase					:					Dict	       =    self._validate_operand(A							)
						except (TypeError, ValueError):
									return False
						else:
									return self.tuple == other.tuple
			def __lt__(	self				,   A							):
						_lowerCamelCase					:					Any	       =    self._validate_operand(A							)
						return self.tuple < other.tuple
			def __hash__(	self							):
						return hash(_version_tuple_to_str(self.tuple							)							)
			@classmethod
			def    _lowerCAmelCase		(	cls				,   A							):
						_lowerCamelCase					:					Optional[Any]	       =    {f.name for f in dataclasses.fields(cls							)}
						return cls(**{k: v for k, v in dic.items() if k in field_names}							)

			def    _lowerCAmelCase		(	self							):
						return self.version_str






def     UpperCAmelCase_					(				__a   :			Any						):




			'''simple docstring'''



			_lowerCamelCase					:					Union[str, Any]	       =    _VERSION_REG.match(__a						)
			if not res:
						raise ValueError(f"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits."						)
			return tuple(int(__a						) for v in [res.group('major'						), res.group('minor'						), res.group('patch'						)]						)



def     UpperCAmelCase_					(				__a   :			List[str]						):




			'''simple docstring'''



			return ".".join(str(__a						) for v in version_tuple						)





