


'''simple docstring'''






import collections
import inspect
import unittest

from transformers import FocalNetConfig
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 (
     FocalNetBackbone,
     FocalNetForImageClassification,
     FocalNetForMaskedImageModeling,
     FocalNetModel,
 )
 from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor




class        a   :
 def __init__(       self					, __magic_name__					, __magic_name__=13					, __magic_name__=32					, __magic_name__=2					, __magic_name__=3					, __magic_name__=16					, __magic_name__=[32, 64, 1_28]					, __magic_name__=[1, 2, 1]					, __magic_name__=[2, 2, 4]					, __magic_name__=2					, __magic_name__=2.0					, __magic_name__=True					, __magic_name__=0.0					, __magic_name__=0.0					, __magic_name__=0.1					, __magic_name__="gelu"					, __magic_name__=False					, __magic_name__=True					, __magic_name__=0.0_2					, __magic_name__=1e-5					, __magic_name__=True					, __magic_name__=None					, __magic_name__=True					, __magic_name__=10					, __magic_name__=8					, __magic_name__=["stage1", "stage2"]					, __magic_name__=[1, 2]					, )    ->							List[Any]:
      _a						=							parent
      _a						=							batch_size
      _a						=							image_size
      _a						=							patch_size
      _a						=							num_channels
      _a						=							embed_dim
      _a						=							hidden_sizes
      _a						=							depths
      _a						=							num_heads
      _a						=							window_size
      _a						=							mlp_ratio
      _a						=							qkv_bias
      _a						=							hidden_dropout_prob
      _a						=							attention_probs_dropout_prob
      _a						=							drop_path_rate
      _a						=							hidden_act
      _a						=							use_absolute_embeddings
      _a						=							patch_norm
      _a						=							layer_norm_eps
      _a						=							initializer_range
      _a						=							is_training
      _a						=							scope
      _a						=							use_labels
      _a						=							type_sequence_label_size
      _a						=							encoder_stride
      _a						=							out_features
      _a						=							out_indices
 def 							__UpperCAmelCase						(       self  )    ->							Tuple:
      _a						=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

      _a						=							None
      if self.use_labels:
           _a						=							ids_tensor([self.batch_size]					, self.type_sequence_label_size  )

      _a						=							self.get_config()

      return config, pixel_values, labels
 def 							__UpperCAmelCase						(       self  )    ->							int:
      return FocalNetConfig(
          image_size=self.image_size					, patch_size=self.patch_size					, num_channels=self.num_channels					, embed_dim=self.embed_dim					, hidden_sizes=self.hidden_sizes					, 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 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__					, __magic_name__  )    ->							Optional[int]:
      _a						=							FocalNetModel(config=__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()
      _a						=							model(__SCREAMING_SNAKE_CASE  )

      _a						=							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
      _a						=							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 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__					, __magic_name__  )    ->							List[Any]:
      _a						=							FocalNetBackbone(config=__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()
      _a						=							model(__SCREAMING_SNAKE_CASE  )

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps  )					, len(config.out_features  )  )
      self.parent.assertListEqual(list(result.feature_maps[0].shape  )					, [self.batch_size, self.image_size, 8, 8]  )

      # verify channels
      self.parent.assertEqual(len(model.channels  )					, len(config.out_features  )  )
      self.parent.assertListEqual(model.channels					, config.hidden_sizes[:-1]  )

      # verify backbone works with out_features=None
      _a						=							None
      _a						=							FocalNetBackbone(config=__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()
      _a						=							model(__SCREAMING_SNAKE_CASE  )

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps  )					, 1  )
      self.parent.assertListEqual(list(result.feature_maps[0].shape  )					, [self.batch_size, self.image_size * 2, 4, 4]  )

      # verify channels
      self.parent.assertEqual(len(model.channels  )					, 1  )
      self.parent.assertListEqual(model.channels					, [config.hidden_sizes[-1]]  )
 def 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__					, __magic_name__  )    ->							Optional[int]:
      _a						=							FocalNetForMaskedImageModeling(config=__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()
      _a						=							model(__SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(
          result.reconstruction.shape					, (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

      # test greyscale images
      _a						=							1
      _a						=							FocalNetForMaskedImageModeling(__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()

      _a						=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
      _a						=							model(__SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(result.reconstruction.shape					, (self.batch_size, 1, self.image_size, self.image_size)  )
 def 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__					, __magic_name__  )    ->							int:
      _a						=							self.type_sequence_label_size
      _a						=							FocalNetForImageClassification(__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()
      _a						=							model(__SCREAMING_SNAKE_CASE					, labels=__SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size)  )

      # test greyscale images
      _a						=							1
      _a						=							FocalNetForImageClassification(__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()

      _a						=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
      _a						=							model(__SCREAMING_SNAKE_CASE  )
      self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size)  )




 def 							__UpperCAmelCase						(       self  )    ->							Dict:
      _a						=							self.prepare_config_and_inputs()

      _a					,      _a					,      _a						=							config_and_inputs
      _a						=							{'pixel_values': pixel_values}
      return config, inputs_dict





@require_torch
class        a   (   __snake_case     , __snake_case     , unittest.TestCase				):
 _lowerCAmelCase           =		(
     (
         FocalNetModel,
         FocalNetForImageClassification,
         FocalNetForMaskedImageModeling,
         FocalNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 _lowerCAmelCase           =		(
     {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
     if is_torch_available()
     else {}
 )
 _lowerCAmelCase           =		False

 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 def 							__UpperCAmelCase						(       self  )    ->							Dict:
      _a						=							FocalNetModelTester(self  )
      _a						=							ConfigTester(self					, config_class=__SCREAMING_SNAKE_CASE					, embed_dim=37					, has_text_modality=__SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self  )    ->							Union[str, Any]:
      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  )    ->							int:
      return
 def 							__UpperCAmelCase						(       self  )    ->							str:
      _a						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      _a						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self  )    ->							Union[str, Any]:
      _a						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      _a						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE  )
 @unittest.skip(reason='FocalNet does not use inputs_embeds'  )
 def 							__UpperCAmelCase						(       self  )    ->							str:
      pass
 @unittest.skip(reason='FocalNet does not use feedforward chunking'  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      pass
 def 							__UpperCAmelCase						(       self  )    ->							List[str]:
      _a					,      _a						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes[:-1]:
           _a						=							model_class(__SCREAMING_SNAKE_CASE  )
           self.assertIsInstance(model.get_input_embeddings()					, (nn.Module)  )
           _a						=							model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(__SCREAMING_SNAKE_CASE					, nn.Linear  )  )
 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      _a					,      _a						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes[:-1]:
           _a						=							model_class(__SCREAMING_SNAKE_CASE  )
           _a						=							inspect.signature(model.forward  )
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _a						=							[*signature.parameters.keys()]

           _a						=							['pixel_values']
           self.assertListEqual(arg_names[:1]					, __SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__					, __magic_name__					, __magic_name__  )    ->							Optional[int]:
      _a						=							model_class(__SCREAMING_SNAKE_CASE  )
      model.to(__SCREAMING_SNAKE_CASE  )
      model.eval()

      with torch.no_grad():
           _a						=							model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE  )  )

      _a						=							outputs.hidden_states

      _a						=							getattr(
          self.model_tester					, 'expected_num_hidden_layers'					, len(self.model_tester.depths  ) + 1  )
      self.assertEqual(len(__SCREAMING_SNAKE_CASE  )					, __SCREAMING_SNAKE_CASE  )

      # FocalNet has a different seq_length
      _a						=							(
          config.patch_size
          if isinstance(config.patch_size					, collections.abc.Iterable  )
          else (config.patch_size, config.patch_size)
      )

      _a						=							(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]					, )

      _a						=							outputs.reshaped_hidden_states
      self.assertEqual(len(__SCREAMING_SNAKE_CASE  )					, __SCREAMING_SNAKE_CASE  )

      _a					,      _a					,      _a					,      _a						=							reshaped_hidden_states[0].shape
      _a						=							(
          reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, height * width  ).permute(0					, 2					, 1  )
      )
      self.assertListEqual(
          list(reshaped_hidden_states.shape[-2:]  )					, [num_patches, self.model_tester.embed_dim]					, )
 def 							__UpperCAmelCase						(       self  )    ->							Tuple:
      _a					,      _a						=							self.model_tester.prepare_config_and_inputs_for_common()

      _a						=							(
          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[:-1]:
           _a						=							True
           self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE  )

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

           self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE  )
 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      _a					,      _a						=							self.model_tester.prepare_config_and_inputs_for_common()
      _a						=							3

      _a						=							(
          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)
      )
      _a						=							(
          config.patch_size
          if isinstance(config.patch_size					, collections.abc.Iterable  )
          else (config.patch_size, config.patch_size)
      )

      _a						=							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      _a						=							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes[:-1]:
           _a						=							True
           self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, (padded_height, padded_width)  )

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _a						=							True
           self.check_hidden_states_output(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, (padded_height, padded_width)  )
 @slow
 def 							__UpperCAmelCase						(       self  )    ->							Any:
      for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a						=							FocalNetModel.from_pretrained(__SCREAMING_SNAKE_CASE  )
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE  )




 def 							__UpperCAmelCase						(       self  )    ->							str:
      _a					,      _a						=							self.model_tester.prepare_config_and_inputs_for_common()

      _a						=							_config_zero_init(__SCREAMING_SNAKE_CASE  )
      for model_class in self.all_model_classes:
           _a						=							model_class(config=__SCREAMING_SNAKE_CASE  )
           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        a   (   unittest.TestCase				):
 @cached_property
 def 							__UpperCAmelCase						(       self  )    ->							int:
      # TODO update organization
      return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'  ) if is_vision_available() else None




 @slow
 def 							__UpperCAmelCase						(       self  )    ->							Tuple:
      _a						=							FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'  ).to(__SCREAMING_SNAKE_CASE  )
      _a						=							self.default_image_processor

      _a						=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
      _a						=							image_processor(images=__SCREAMING_SNAKE_CASE					, return_tensors='pt'  ).to(__SCREAMING_SNAKE_CASE  )

      # forward pass
      with torch.no_grad():
           _a						=							model(**__SCREAMING_SNAKE_CASE  )

      # verify the logits
      _a						=							torch.Size((1, 10_00)  )
      self.assertEqual(outputs.logits.shape					, __SCREAMING_SNAKE_CASE  )
      _a						=							torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]  ).to(__SCREAMING_SNAKE_CASE  )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]					, __SCREAMING_SNAKE_CASE					, atol=1e-4  )  )
      self.assertTrue(outputs.logits.argmax(dim=-1  ).item()					, 2_81  )





@require_torch
class        a   (   __snake_case     , unittest.TestCase				):
 _lowerCAmelCase           =		(FocalNetBackbone,) if is_torch_available() else ()
 _lowerCAmelCase           =		FocalNetConfig

 _lowerCAmelCase           =		False
 def 							__UpperCAmelCase						(       self  )    ->							Any:
      _a						=							FocalNetModelTester(self  )









"""simple docstring"""





import argparse
import json
import subprocess







def      lowerCamelCase__       (							_lowerCamelCase       :		Tuple		,				_lowerCamelCase       :		str )      ->				List[Any]:
  lowerCamelCase_         =						[]

  lowerCamelCase_         =						(
      F'''curl -H "Accept: application/vnd.github+json" -H "Authorization: Bearer {token}"'''
      ' https://api.github.com/repos/huggingface/transformers/actions/runners'
  )
  lowerCamelCase_         =						subprocess.run(_lowerCamelCase		,				shell=_lowerCamelCase		,				stdout=subprocess.PIPE )
  lowerCamelCase_         =						output.stdout.decode('utf-8' )
  lowerCamelCase_         =						json.loads(_lowerCamelCase )

  lowerCamelCase_         =						status['runners']
  for runner in runners:
    if runner["name"] in target_runners:
      if runner["status"] == "offline":
        offline_runners.append(_lowerCamelCase )

    # save the result so we can report them on Slack
  with open('offline_runners.txt'		,				'w' ) as fp:
    fp.write(json.dumps(_lowerCamelCase ) )

  if len(_lowerCamelCase ) > 0:
    lowerCamelCase_         =						'\n'.join([x['name'] for x in offline_runners] )
    raise ValueError(F'''The following runners are offline:\n{failed}''' )


if __name__ == "__main__":







  def      lowerCamelCase__       (							_lowerCamelCase       :		Dict )      ->				Tuple:
    return values.split(',' )

  _SCREAMING_SNAKE_CASE					:				Union[str, Any]					    =						argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--target_runners''',
      default=None,
      type=list_str,
      required=True,
      help='''Comma-separated list of runners to check status.''',
  )

  parser.add_argument(
      '''--token''', default=None, type=str, required=True, help='''A token that has actions:read permission.'''
  )
  _SCREAMING_SNAKE_CASE					:				Any					    =						parser.parse_args()






  get_runner_status(args.target_runners, args.token)




