

import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
						import torch
						from torch import nn

						from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
						from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor






class     _UpperCAmelCase			:
			def __init__(		self      ,		_A      ,		_A=13      ,		_A=32      ,		_A=2      ,		_A=3      ,		_A=16      ,		_A=[1, 2, 1]      ,		_A=[2, 2, 4]      ,		_A=2      ,		_A=2.0      ,		_A=True      ,		_A=0.0      ,		_A=0.0      ,		_A=0.1      ,		_A="gelu"      ,		_A=False      ,		_A=True      ,		_A=0.02      ,		_A=1e-5      ,		_A=True      ,		_A=None      ,		_A=True      ,		_A=10      ,		_A=8      ,		_A=["stage1", "stage2"]      ,		_A=[1, 2]      ,		)    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					parent
				_UpperCAmelCase    :							Optional[int]									=					batch_size
				_UpperCAmelCase    :							Union[str, Any]									=					image_size
				_UpperCAmelCase    :							Tuple									=					patch_size
				_UpperCAmelCase    :							Any									=					num_channels
				_UpperCAmelCase    :							Dict									=					embed_dim
				_UpperCAmelCase    :							str									=					depths
				_UpperCAmelCase    :							List[Any]									=					num_heads
				_UpperCAmelCase    :							Dict									=					window_size
				_UpperCAmelCase    :							Dict									=					mlp_ratio
				_UpperCAmelCase    :							Optional[Any]									=					qkv_bias
				_UpperCAmelCase    :							List[Any]									=					hidden_dropout_prob
				_UpperCAmelCase    :							Tuple									=					attention_probs_dropout_prob
				_UpperCAmelCase    :							Dict									=					drop_path_rate
				_UpperCAmelCase    :							Optional[int]									=					hidden_act
				_UpperCAmelCase    :							int									=					use_absolute_embeddings
				_UpperCAmelCase    :							str									=					patch_norm
				_UpperCAmelCase    :							List[str]									=					layer_norm_eps
				_UpperCAmelCase    :							List[Any]									=					initializer_range
				_UpperCAmelCase    :							Dict									=					is_training
				_UpperCAmelCase    :							Optional[int]									=					scope
				_UpperCAmelCase    :							int									=					use_labels
				_UpperCAmelCase    :							Optional[int]									=					type_sequence_label_size
				_UpperCAmelCase    :							Tuple									=					encoder_stride
				_UpperCAmelCase    :							Union[str, Any]									=					out_features
				_UpperCAmelCase    :							List[str]									=					out_indices
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

				_UpperCAmelCase    :							Tuple									=					None
				if self.use_labels:
					_UpperCAmelCase    :							List[Any]									=					ids_tensor([self.batch_size]      ,		self.type_sequence_label_size     )

				_UpperCAmelCase    :							Union[str, Any]									=					self.get_config()

				return config, pixel_values, labels
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				return SwinConfig(
				    image_size=self.image_size      ,		patch_size=self.patch_size      ,		num_channels=self.num_channels      ,		embed_dim=self.embed_dim      ,		depths=self.depths      ,		num_heads=self.num_heads      ,		window_size=self.window_size      ,		mlp_ratio=self.mlp_ratio      ,		qkv_bias=self.qkv_bias      ,		hidden_dropout_prob=self.hidden_dropout_prob      ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,		drop_path_rate=self.drop_path_rate      ,		hidden_act=self.hidden_act      ,		use_absolute_embeddings=self.use_absolute_embeddings      ,		path_norm=self.patch_norm      ,		layer_norm_eps=self.layer_norm_eps      ,		initializer_range=self.initializer_range      ,		encoder_stride=self.encoder_stride      ,		out_features=self.out_features      ,		out_indices=self.out_indices      ,		)
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					SwinModel(config=_A     )
				model.to(_A     )
				model.eval()
				_UpperCAmelCase    :							int									=					model(_A     )

				_UpperCAmelCase    :							str									=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths     ) - 1))
				_UpperCAmelCase    :							Union[str, Any]									=					int(config.embed_dim * 2 ** (len(config.depths     ) - 1)     )

				self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, expected_seq_len, expected_dim)     )
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					SwinBackbone(config=_A     )
				model.to(_A     )
				model.eval()
				_UpperCAmelCase    :							Dict									=					model(_A     )

				# verify hidden states
				self.parent.assertEqual(len(result.feature_maps     )      ,		len(config.out_features     )     )
				self.parent.assertListEqual(list(result.feature_maps[0].shape     )      ,		[self.batch_size, model.channels[0], 16, 16]     )

				# verify channels
				self.parent.assertEqual(len(model.channels     )      ,		len(config.out_features     )     )

				# verify backbone works with out_features=None
				_UpperCAmelCase    :							Optional[int]									=					None
				_UpperCAmelCase    :							str									=					SwinBackbone(config=_A     )
				model.to(_A     )
				model.eval()
				_UpperCAmelCase    :							str									=					model(_A     )

				# verify feature maps
				self.parent.assertEqual(len(result.feature_maps     )      ,		1     )
				self.parent.assertListEqual(list(result.feature_maps[0].shape     )      ,		[self.batch_size, model.channels[-1], 4, 4]     )

				# verify channels
				self.parent.assertEqual(len(model.channels     )      ,		1     )
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A     )    ->    Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					SwinForMaskedImageModeling(config=_A     )
				model.to(_A     )
				model.eval()
				_UpperCAmelCase    :							str									=					model(_A     )
				self.parent.assertEqual(
				    result.logits.shape      ,		(self.batch_size, self.num_channels, self.image_size, self.image_size)     )

				# test greyscale images
				_UpperCAmelCase    :							Tuple									=					1
				_UpperCAmelCase    :							Tuple									=					SwinForMaskedImageModeling(_A     )
				model.to(_A     )
				model.eval()

				_UpperCAmelCase    :							Dict									=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
				_UpperCAmelCase    :							Optional[int]									=					model(_A     )
				self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, 1, self.image_size, self.image_size)     )
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					self.type_sequence_label_size
				_UpperCAmelCase    :							Optional[int]									=					SwinForImageClassification(_A     )
				model.to(_A     )
				model.eval()
				_UpperCAmelCase    :							Union[str, Any]									=					model(_A      ,		labels=_A     )
				self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)     )

				# test greyscale images
				_UpperCAmelCase    :							Dict									=					1
				_UpperCAmelCase    :							Tuple									=					SwinForImageClassification(_A     )
				model.to(_A     )
				model.eval()

				_UpperCAmelCase    :							Optional[Any]									=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]     )
				_UpperCAmelCase    :							int									=					model(_A     )
				self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)     )
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					self.prepare_config_and_inputs()
				(
				    _UpperCAmelCase   
				)    :							Optional[int]									=					config_and_inputs
				_UpperCAmelCase    :							Optional[int]									=					{"""pixel_values""": pixel_values}
				return config, inputs_dict






@require_torch
class     _UpperCAmelCase			(		__a    ,     __a    ,     unittest.TestCase):
			__a :       Union[str, Any]									=							(
			    (
			        SwinModel,
			        SwinBackbone,
			        SwinForImageClassification,
			        SwinForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			__a :       List[str]									=							(
			    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
			    if is_torch_available()
			    else {}
			)
			__a :       Any									=							True

			__a :       int									=							False
			__a :       Any									=							False
			__a :       str									=							False
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					SwinModelTester(self     )
				_UpperCAmelCase    :							Optional[Any]									=					ConfigTester(self      ,		config_class=_A      ,		embed_dim=37     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				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 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				return
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							str									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_A     )
			@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""     )
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				pass
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				super().test_training_gradient_checkpointing()
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							Tuple									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*_A     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*_A     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[Any]									=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_A     )
			@unittest.skip(reason="""Swin does not use inputs_embeds"""     )
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







				pass
			@unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""     )
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				pass
			def 							__snake_case (		self     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							str									=					model_class(_A     )
					self.assertIsInstance(model.get_input_embeddings()      ,		(nn.Module)     )
					_UpperCAmelCase    :							List[Any]									=					model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(_A      ,		nn.Linear     )     )
			def 							__snake_case (		self     )    ->    Any:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							Any									=					model_class(_A     )
					_UpperCAmelCase    :							Optional[Any]									=					inspect.signature(model.forward     )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					_UpperCAmelCase    :							Union[str, Any]									=					[*signature.parameters.keys()]

					_UpperCAmelCase    :							Optional[int]									=					["""pixel_values"""]
					self.assertListEqual(arg_names[:1]      ,		_A     )
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					self.model_tester.prepare_config_and_inputs_for_common()
				_UpperCAmelCase    :							Dict									=					True

				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							List[str]									=					True
					_UpperCAmelCase    :							Any									=					False
					_UpperCAmelCase    :							List[str]									=					True
					_UpperCAmelCase    :							List[Any]									=					model_class(_A     )
					model.to(_A     )
					model.eval()
					with torch.no_grad():
						_UpperCAmelCase    :							str									=					model(**self._prepare_for_class(_A      ,		_A     )     )
					_UpperCAmelCase    :							Optional[Any]									=					outputs.attentions
					_UpperCAmelCase    :							int									=					len(self.model_tester.depths     )
					self.assertEqual(len(_A     )      ,		_A     )

					# check that output_attentions also work using config
					del inputs_dict["output_attentions"]
					_UpperCAmelCase    :							Dict									=					True
					_UpperCAmelCase    :							Union[str, Any]									=					config.window_size**2
					_UpperCAmelCase    :							List[Any]									=					model_class(_A     )
					model.to(_A     )
					model.eval()
					with torch.no_grad():
						_UpperCAmelCase    :							str									=					model(**self._prepare_for_class(_A      ,		_A     )     )
					_UpperCAmelCase    :							str									=					outputs.attentions
					self.assertEqual(len(_A     )      ,		_A     )

					self.assertListEqual(
					    list(attentions[0].shape[-3:]     )      ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,		)
					_UpperCAmelCase    :							Tuple									=					len(_A     )

					# Check attention is always last and order is fine
					_UpperCAmelCase    :							List[Any]									=					True
					_UpperCAmelCase    :							Union[str, Any]									=					True
					_UpperCAmelCase    :							Dict									=					model_class(_A     )
					model.to(_A     )
					model.eval()
					with torch.no_grad():
						_UpperCAmelCase    :							Dict									=					model(**self._prepare_for_class(_A      ,		_A     )     )

					# also another +1 for reshaped_hidden_states
					_UpperCAmelCase    :							Tuple									=					1 if model_class.__name__ == """SwinBackbone""" else 2
					self.assertEqual(out_len + added_hidden_states      ,		len(_A     )     )

					_UpperCAmelCase    :							List[str]									=					outputs.attentions

					self.assertEqual(len(_A     )      ,		_A     )

					self.assertListEqual(
					    list(self_attentions[0].shape[-3:]     )      ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,		)
			def 							__snake_case (		self      ,		_A      ,		_A      ,		_A      ,		_A     )    ->    List[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					model_class(_A     )
				model.to(_A     )
				model.eval()

				with torch.no_grad():
					_UpperCAmelCase    :							List[Any]									=					model(**self._prepare_for_class(_A      ,		_A     )     )

				_UpperCAmelCase    :							Tuple									=					outputs.hidden_states

				_UpperCAmelCase    :							Union[str, Any]									=					getattr(
				    self.model_tester      ,		"""expected_num_hidden_layers"""      ,		len(self.model_tester.depths     ) + 1     )
				self.assertEqual(len(_A     )      ,		_A     )

				# Swin has a different seq_length
				_UpperCAmelCase    :							List[Any]									=					(
				    config.patch_size
				    if isinstance(config.patch_size      ,		collections.abc.Iterable     )
				    else (config.patch_size, config.patch_size)
				)

				_UpperCAmelCase    :							int									=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

				self.assertListEqual(
				    list(hidden_states[0].shape[-2:]     )      ,		[num_patches, self.model_tester.embed_dim]      ,		)

				if not model_class.__name__ == "SwinBackbone":
					_UpperCAmelCase    :							List[Any]									=					outputs.reshaped_hidden_states
					self.assertEqual(len(_A     )      ,		_A     )

					_UpperCAmelCase    :							Tuple									=					reshaped_hidden_states[0].shape
					_UpperCAmelCase    :							str									=					(
					    reshaped_hidden_states[0].view(_A      ,		_A      ,		height * width     ).permute(0      ,		2      ,		1     )
					)
					self.assertListEqual(
					    list(reshaped_hidden_states.shape[-2:]     )      ,		[num_patches, self.model_tester.embed_dim]      ,		)
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Dict									=					self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCAmelCase    :							Any									=					(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size      ,		collections.abc.Iterable     )
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)

				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							List[str]									=					True
					self.check_hidden_states_output(_A      ,		_A      ,		_A      ,		_A     )

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					_UpperCAmelCase    :							Any									=					True

					self.check_hidden_states_output(_A      ,		_A      ,		_A      ,		_A     )
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							List[str]									=					self.model_tester.prepare_config_and_inputs_for_common()
				_UpperCAmelCase    :							str									=					3

				_UpperCAmelCase    :							Optional[Any]									=					(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size      ,		collections.abc.Iterable     )
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)
				_UpperCAmelCase    :							Tuple									=					(
				    config.patch_size
				    if isinstance(config.patch_size      ,		collections.abc.Iterable     )
				    else (config.patch_size, config.patch_size)
				)

				_UpperCAmelCase    :							int									=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
				_UpperCAmelCase    :							List[str]									=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							Any									=					True
					self.check_hidden_states_output(_A      ,		_A      ,		_A      ,		(padded_height, padded_width)     )

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					_UpperCAmelCase    :							str									=					True
					self.check_hidden_states_output(_A      ,		_A      ,		_A      ,		(padded_height, padded_width)     )
			@slow
			def 							__snake_case (		self     )    ->    Optional[Any]:






				'''simple docstring'''







				for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_UpperCAmelCase    :							Tuple									=					SwinModel.from_pretrained(_A     )
					self.assertIsNotNone(_A     )
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Tuple									=					self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCAmelCase    :							str									=					_config_zero_init(_A     )
				for model_class in self.all_model_classes:
					_UpperCAmelCase    :							Any									=					model_class(config=_A     )
					for name, param in model.named_parameters():
						if "embeddings" not in name and param.requires_grad:
							self.assertIn(
							    ((param.data.mean() * 1e9).round() / 1e9).item()      ,		[0.0, 1.0]      ,		msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''      ,		)






@require_vision
@require_torch
class     _UpperCAmelCase			(		unittest.TestCase):
			@cached_property
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				return (
				    AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""     )
				    if is_vision_available()
				    else None
				)
			@slow
			def 							__snake_case (		self     )    ->    str:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""     ).to(_A     )
				_UpperCAmelCase    :							Optional[Any]									=					self.default_image_processor

				_UpperCAmelCase    :							Optional[Any]									=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
				_UpperCAmelCase    :							str									=					image_processor(images=_A      ,		return_tensors="""pt"""     ).to(_A     )

				# forward pass
				with torch.no_grad():
					_UpperCAmelCase    :							Tuple									=					model(**_A     )

				# verify the logits
				_UpperCAmelCase    :							Tuple									=					torch.Size((1, 10_00)     )
				self.assertEqual(outputs.logits.shape      ,		_A     )
				_UpperCAmelCase    :							Any									=					torch.tensor([-0.0948, -0.6454, -0.0921]     ).to(_A     )
				self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,		_A      ,		atol=1e-4     )     )






@require_torch
class     _UpperCAmelCase			(		unittest.TestCase    ,     __a):
			__a :       Any									=							(SwinBackbone,) if is_torch_available() else ()
			__a :       Dict									=							SwinConfig
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					SwinModelTester(self     )








"""simple docstring"""






def       UpperCamelCase					(			_lowerCAmelCase     :						int )				->			str:
	_UpperCAmelCase    :							Any									=					1
	_UpperCAmelCase    :							List[str]									=					0
	_UpperCAmelCase    :							str									=					1
	_UpperCAmelCase    :							Union[str, Any]									=					1
	_UpperCAmelCase    :							int									=					3
	_UpperCAmelCase    :							int									=					3
	_UpperCAmelCase    :							List[str]									=					limit
	_UpperCAmelCase    :							Optional[Any]									=					0

	_UpperCAmelCase    :							Any									=					""""""
	while counter != decimal + 1:
		if 4 * q + r - t < n * t:
			result += str(_lowerCAmelCase )
			if counter == 0:
				result += "."

			if decimal == counter:
				break

			counter += 1
			_UpperCAmelCase    :							str									=					10 * (r - n * t)
			_UpperCAmelCase    :							List[Any]									=					((10 * (3 * q + r)) // t) - 10 * n
			q *= 10
			_UpperCAmelCase    :							int									=					nr
		else:
			_UpperCAmelCase    :							Any									=					(2 * q + r) * l
			_UpperCAmelCase    :							str									=					(q * (7 * k) + 2 + (r * l)) // (t * l)
			q *= k
			t *= l
			l += 2
			k += 1
			_UpperCAmelCase    :							List[Any]									=					nn
			_UpperCAmelCase    :							Optional[int]									=					nr
	return result
def       UpperCamelCase					(			)				->			None:
	print(f'''{calculate_pi(50 ) = }''' )
	import doctest

	doctest.testmod()


if __name__ == "__main__":
						main()





