



"""simple docstring"""
import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
      import torch

      from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin



class    SCREAMING_SNAKE_CASE__						:

   def __init__(     self   ,  _SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE=None   ,  _SCREAMING_SNAKE_CASE=None   ,  _SCREAMING_SNAKE_CASE=None   ,  _SCREAMING_SNAKE_CASE="resnet50"   ,  _SCREAMING_SNAKE_CASE=3   ,  _SCREAMING_SNAKE_CASE=32   ,  _SCREAMING_SNAKE_CASE=3   ,  _SCREAMING_SNAKE_CASE=True   ,  _SCREAMING_SNAKE_CASE=True   ,  )						->   List[str]:





    '''simple docstring'''




    UpperCAmelCase			:      str			=			parent
    UpperCAmelCase			:      Any			=			out_indices if out_indices is not None else [4]
    UpperCAmelCase			:      List[Any]			=			stage_names
    UpperCAmelCase			:      Dict			=			out_features
    UpperCAmelCase			:      Union[str, Any]			=			backbone
    UpperCAmelCase			:      int			=			batch_size
    UpperCAmelCase			:      List[str]			=			image_size
    UpperCAmelCase			:      Tuple			=			num_channels
    UpperCAmelCase			:      List[Any]			=			use_pretrained_backbone
    UpperCAmelCase			:      str			=			is_training

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Tuple:





    '''simple docstring'''




    UpperCAmelCase			:      Optional[Any]			=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
    UpperCAmelCase			:      List[Any]			=			self.get_config()

    return config, pixel_values

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[Any]:





    '''simple docstring'''




    return TimmBackboneConfig(
        image_size=self.image_size   ,  num_channels=self.num_channels   ,  out_features=self.out_features   ,  out_indices=self.out_indices   ,  stage_names=self.stage_names   ,  use_pretrained_backbone=self.use_pretrained_backbone   ,  backbone=self.backbone   ,  )

   def 			SCREAMING_SNAKE_CASE  (     self   ,  _SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)						->   Any:





    '''simple docstring'''




    UpperCAmelCase			:      Dict			=			TimmBackbone(config=A_		)
    model.to(A_		)
    model.eval()
    with torch.no_grad():
     UpperCAmelCase			:      Optional[int]			=			model(A_		)
    self.parent.assertEqual(
        result.feature_map[-1].shape   ,  (self.batch_size, model.channels[-1], 14, 14)   ,  )




   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Any:





    '''simple docstring'''




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



@require_torch
@require_timm
class    SCREAMING_SNAKE_CASE__						(      __snake_case   ,    __snake_case   ,    __snake_case   ,    unittest.TestCase				):
   __lowerCAmelCase						:     List[Any]		=		(TimmBackbone,) if is_torch_available() else ()
   __lowerCAmelCase						:     Optional[int]		=		{'feature-extraction': TimmBackbone} if is_torch_available() else {}
   __lowerCAmelCase						:     List[Any]		=		False
   __lowerCAmelCase						:     List[str]		=		False
   __lowerCAmelCase						:     str		=		False
   __lowerCAmelCase						:     Optional[int]		=		False

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   str:





    '''simple docstring'''




    UpperCAmelCase			:      List[Any]			=			TimmBackboneModelTester(self		)
    UpperCAmelCase			:      Optional[int]			=			ConfigTester(self   ,  config_class=A_   ,  has_text_modality=A_		)

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Union[str, Any]:





    '''simple docstring'''




    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 			SCREAMING_SNAKE_CASE  (     self		)						->   int:





    '''simple docstring'''




    UpperCAmelCase			:      str			=			"resnet18"
    UpperCAmelCase			:      Optional[Any]			=			"microsoft/resnet-18"

    UpperCAmelCase			:      Optional[Any]			=			AutoBackbone.from_pretrained(A_   ,  use_timm_backbone=A_		)
    UpperCAmelCase			:      Union[str, Any]			=			AutoBackbone.from_pretrained(A_		)

    self.assertEqual(len(timm_model.out_features		)   ,  len(transformers_model.out_features		)		)
    self.assertEqual(len(timm_model.stage_names		)   ,  len(transformers_model.stage_names		)		)
    self.assertEqual(timm_model.channels   ,  transformers_model.channels		)
    # Out indices are set to the last layer by default. For timm models, we don't know
    # the number of layers in advance, so we set it to (-1,), whereas for transformers
    # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
    self.assertEqual(timm_model.out_indices   ,  (-1,)		)
    self.assertEqual(transformers_model.out_indices   ,  [len(timm_model.stage_names		) - 1]		)

    UpperCAmelCase			:      int			=			AutoBackbone.from_pretrained(A_   ,  use_timm_backbone=A_   ,  out_indices=[1, 2, 3]		)
    UpperCAmelCase			:      Dict			=			AutoBackbone.from_pretrained(A_   ,  out_indices=[1, 2, 3]		)

    self.assertEqual(timm_model.out_indices   ,  transformers_model.out_indices		)
    self.assertEqual(len(timm_model.out_features		)   ,  len(transformers_model.out_features		)		)
    self.assertEqual(timm_model.channels   ,  transformers_model.channels		)

   @unittest.skip("""TimmBackbone doesn't support feed forward chunking"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Any:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone initialization is managed on the timm side"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Union[str, Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   int:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   int:





    '''simple docstring'''




    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Optional[int]:





    '''simple docstring'''




    pass

   @unittest.skip("""model weights aren't tied in TimmBackbone."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Union[str, Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""model weights aren't tied in TimmBackbone."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Union[str, Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Dict:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Any:





    '''simple docstring'''




    pass

   @unittest.skip("""TimmBackbone doesn't support output_attentions."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    pass

   @unittest.skip("""Safetensors is not supported by timm."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Union[str, Any]:





    '''simple docstring'''




    pass

   @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""		)
   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Optional[Any]:





    '''simple docstring'''




    pass

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    UpperCAmelCase			:      Union[str, Any]			=			self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
     UpperCAmelCase			:      Optional[Any]			=			model_class(A_		)
     UpperCAmelCase			:      Optional[int]			=			inspect.signature(model.forward		)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     UpperCAmelCase			:      int			=			[*signature.parameters.keys()]

     UpperCAmelCase			:      int			=			["pixel_values"]
     self.assertListEqual(arg_names[:1]   ,  A_		)

   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    UpperCAmelCase			:      Any			=			self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase			:      Union[str, Any]			=			True
    UpperCAmelCase			:      str			=			self.has_attentions

    # no need to test all models as different heads yield the same functionality
    UpperCAmelCase			:      str			=			self.all_model_classes[0]
    UpperCAmelCase			:      Optional[Any]			=			model_class(A_		)
    model.to(A_		)

    UpperCAmelCase			:      Tuple			=			self._prepare_for_class(A_   ,  A_		)
    UpperCAmelCase			:      Any			=			model(**A_		)
    UpperCAmelCase			:      Tuple			=			outputs[0][-1]

    # Encoder-/Decoder-only models
    UpperCAmelCase			:      Optional[Any]			=			outputs.hidden_states[0]
    hidden_states.retain_grad()

    if self.has_attentions:
     UpperCAmelCase			:      List[str]			=			outputs.attentions[0]
     attentions.retain_grad()

    output.flatten()[0].backward(retain_graph=A_		)

    self.assertIsNotNone(hidden_states.grad		)

    if self.has_attentions:
     self.assertIsNotNone(attentions.grad		)




   def 			SCREAMING_SNAKE_CASE  (     self		)						->   List[str]:





    '''simple docstring'''




    UpperCAmelCase			:      Tuple			=			self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
     UpperCAmelCase			:      Union[str, Any]			=			model_class(A_		)
     model.to(A_		)
     model.eval()
     UpperCAmelCase			:      Any			=			model(**A_		)

     self.assertEqual(len(result.feature_maps		)   ,  len(config.out_indices		)		)
     self.assertEqual(len(model.channels		)   ,  len(config.out_indices		)		)

     # Check output of last stage is taken if out_features=None, out_indices=None
     UpperCAmelCase			:      Any			=			copy.deepcopy(A_		)
     UpperCAmelCase			:      Optional[int]			=			None
     UpperCAmelCase			:      Optional[int]			=			model_class(A_		)
     model.to(A_		)
     model.eval()
     UpperCAmelCase			:      Union[str, Any]			=			model(**A_		)

     self.assertEqual(len(result.feature_maps		)   ,  1		)
     self.assertEqual(len(model.channels		)   ,  1		)

     # Check backbone can be initialized with fresh weights
     UpperCAmelCase			:      Optional[int]			=			copy.deepcopy(A_		)
     UpperCAmelCase			:      Dict			=			False
     UpperCAmelCase			:      int			=			model_class(A_		)
     model.to(A_		)
     model.eval()
     UpperCAmelCase			:      Tuple			=			model(**A_		)











"""simple docstring"""
import math
from datetime import datetime, timedelta

def    _snake_case		(		UpperCamelCase		:	int		):
 UpperCAmelCase			:      Any			=			year % 19
 UpperCAmelCase			:      Any			=			year % 4
 UpperCAmelCase			:      str			=			year % 7
 UpperCAmelCase			:      Union[str, Any]			=			math.floor(year / 100		)
 UpperCAmelCase			:      Optional[Any]			=			math.floor((13 + 8 * leap_day_inhibits) / 25		)
 UpperCAmelCase			:      int			=			leap_day_inhibits / 4
 UpperCAmelCase			:      int			=			(
     15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
 ) % 30
 UpperCAmelCase			:      Tuple			=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

 # days to be added to March 21
 UpperCAmelCase			:      int			=			(19 * metonic_cycle + secular_moon_shift) % 30

 # PHM -> Paschal Full Moon
 UpperCAmelCase			:      Tuple			=			(
     2 * julian_leap_year
     + 4 * non_leap_year
     + 6 * days_to_add
     + century_starting_point
 ) % 7

 if days_to_add == 29 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	19		)
 elif days_to_add == 28 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	18		)
 else:
  return datetime(UpperCamelCase    ,	3    ,	22		) + timedelta(
      days=int(days_to_add + days_from_phm_to_sunday		)		)


if __name__ == "__main__":
      for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
            A:     Any										=	"will be" if year > datetime.now().year else "was"
            print(f"""Easter in {year} {tense} {gauss_easter(year)}""")
