






'''simple docstring'''







from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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


if is_tf_available():
							import tensorflow as tf

							from transformers import TFResNetForImageClassification, TFResNetModel
							from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor




class 		UpperCamelCase__    :




		'''simple docstring'''





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






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

								lowerCamelCase__         =  self.get_config()

								return config, pixel_values, labels






		def 			UpperCamelCase_					(      self       ):
								return ResNetConfig(
								    num_channels=self.num_channels   ,embeddings_size=self.embeddings_size   ,hidden_sizes=self.hidden_sizes   ,depths=self.depths   ,hidden_act=self.hidden_act   ,num_labels=self.num_labels   ,image_size=self.image_size   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFResNetModel(config=_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase       )
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape   ,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  self.num_labels
								lowerCamelCase__         =  TFResNetForImageClassification(_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,labels=_lowerCAmelCase       )
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels)       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.prepare_config_and_inputs()
								lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__         =  config_and_inputs
								lowerCamelCase__         =  {"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_tf
class 		UpperCamelCase__    (a   ,a   ,unittest.TestCase			):




		'''simple docstring'''





		_UpperCamelCase				  =					(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
		_UpperCamelCase				  =					(
		    {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
		    if is_tf_available()
		    else {}
		)

		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFResNetModelTester(self       )
								lowerCamelCase__         =  ConfigTester(self   ,config_class=_lowerCAmelCase   ,has_text_modality=_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()






		def 			UpperCamelCase_					(      self       ):
								return






		@unittest.skip(reason="""ResNet does not use inputs_embeds"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		@unittest.skip(reason="""ResNet does not support input and output embeddings"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

														lowerCamelCase__         =  ["""pixel_values"""]
														self.assertListEqual(arg_names[:1]   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								def check_hidden_states_output(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  model(**self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )       )

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

														lowerCamelCase__         =  self.model_tester.num_stages
														self.assertEqual(len(_lowerCAmelCase       )   ,expected_num_stages + 1       )

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

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

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

																				check_hidden_states_output(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase       )






		@slow
		def 			UpperCamelCase_					(      self       ):
								for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__         =  TFResNetModel.from_pretrained(_lowerCAmelCase       )
														self.assertIsNotNone(_lowerCAmelCase       )



def 						A__			(				):
						lowerCamelCase__         =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
						return image





@require_tf
@require_vision
class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		@cached_property
		def 			UpperCamelCase_					(      self       ):
								return (
								    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
								    if is_vision_available()
								    else None
								)






		@slow
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

								lowerCamelCase__         =  self.default_image_processor
								lowerCamelCase__         =  prepare_img()
								lowerCamelCase__         =  image_processor(images=_lowerCAmelCase   ,return_tensors="""tf"""       )

								# forward pass
								lowerCamelCase__         =  model(**_lowerCAmelCase       )

								# verify the logits
								lowerCamelCase__         =  tf.TensorShape((1, 10_00)       )
								self.assertEqual(outputs.logits.shape   ,_lowerCAmelCase       )

								lowerCamelCase__         =  tf.constant([-11.1069, -9.7877, -8.3777]       )

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









'''simple docstring'''







from __future__ import annotations

import math
def 						A__			(				__lowerCAmelCase		:			int						):

						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5   ,    int(math.sqrt(__lowerCAmelCase						) + 1						)   ,    6						):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


UpperCamelCase    :      str  			=		[num for num in range(3, 10_00_01, 2) if not is_prime(num)]
def 						A__			(				__lowerCAmelCase		:			int						):
						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												raise ValueError("""n must be an integer"""						)
						if n <= 0:
												raise ValueError("""n must be >= 0"""						)

						lowerCamelCase__         =  []
						for num in range(len(__lowerCAmelCase						)						):
												lowerCamelCase__         =  0
												while 2 * i * i <= odd_composites[num]:
																		lowerCamelCase__         =  odd_composites[num] - 2 * i * i
																		if is_prime(__lowerCAmelCase						):
																								break
																		i += 1
												else:
																		list_nums.append(odd_composites[num]						)
																		if len(__lowerCAmelCase						) == n:
																								return list_nums

						return []
def 						A__			(				):
						return compute_nums(1						)[0]


if __name__ == "__main__":
							print(F'{solution() = }')

