



import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

       if is_vision_available():
              from transformers import MaskaFormerImageProcessor

if is_vision_available():
       from PIL import Image
class 			_snake_case     :




    def __init__(  self   :  List[Any],   __lowercase   :  str,   __lowercase   :  List[Any]=2,   __lowercase   :  Optional[Any]=True,   __lowercase   :  Dict=False,   __lowercase   :  Dict=10,   __lowercase   :  Tuple=3,   __lowercase   :  List[Any]=32 * 8,   __lowercase   :  Dict=32 * 8,   __lowercase   :  str=4,   __lowercase   :  List[Any]=64,   ):
       lowercase__   					=			parent
       lowercase__   					=			batch_size
       lowercase__   					=			is_training
       lowercase__   					=			use_auxiliary_loss
       lowercase__   					=			num_queries
       lowercase__   					=			num_channels
       lowercase__   					=			min_size
       lowercase__   					=			max_size
       lowercase__   					=			num_labels
       lowercase__   					=			hidden_dim
       lowercase__   					=			hidden_dim




    def 							A__ (  self   :  Dict  ):
       lowercase__   					=			floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]  ).to(
           __lowercase  )

       lowercase__   					=			torch.ones([self.batch_size, self.min_size, self.max_size],   device=__lowercase  )

       lowercase__   					=			(
           torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size],   device=__lowercase  ) > 0.5
       ).float()
       lowercase__   					=			(torch.rand((self.batch_size, self.num_labels),   device=__lowercase  ) > 0.5).long()

       lowercase__   					=			self.get_config()
       return config, pixel_values, pixel_mask, mask_labels, class_labels




    def 							A__ (  self   :  int  ):
       lowercase__   					=			MaskaFormerConfig(
           hidden_size=self.hidden_dim,   )
       lowercase__   					=			self.num_queries
       lowercase__   					=			self.num_labels

       lowercase__   					=			[1, 1, 1, 1]
       lowercase__   					=			self.num_channels

       lowercase__   					=			64
       lowercase__   					=			128
       lowercase__   					=			self.hidden_dim
       lowercase__   					=			self.hidden_dim
       lowercase__   					=			self.hidden_dim
       return config




    def 							A__ (  self   :  Dict  ):
       lowercase__   					=			self.prepare_config_and_inputs()
       lowercase__   					=			{"pixel_values": pixel_values, "pixel_mask": pixel_mask}
       return config, inputs_dict




    def 							A__ (  self   :  int,   __lowercase   :  List[Any],   __lowercase   :  Optional[int]  ):
       lowercase__   					=			output.encoder_hidden_states
       lowercase__   					=			output.pixel_decoder_hidden_states
       lowercase__   					=			output.transformer_decoder_hidden_states

       self.parent.assertTrue(len(__lowercase  ),   len(config.backbone_config.depths  )  )
       self.parent.assertTrue(len(__lowercase  ),   len(config.backbone_config.depths  )  )
       self.parent.assertTrue(len(__lowercase  ),   config.decoder_layers  )




    def 							A__ (  self   :  str,   __lowercase   :  Optional[int],   __lowercase   :  Optional[Any],   __lowercase   :  Optional[int],   __lowercase   :  List[str]=False  ):




       with torch.no_grad():
          lowercase__   					=			MaskaFormerModel(config=__lowercase  )
          model.to(__lowercase  )
          model.eval()

          lowercase__   					=			model(pixel_values=__lowercase,   pixel_mask=__lowercase  )
          lowercase__   					=			model(__lowercase,   output_hidden_states=__lowercase  )

       self.parent.assertEqual(
           output.transformer_decoder_last_hidden_state.shape,   (self.batch_size, self.num_queries, self.hidden_dim),   )
       # let's ensure the other two hidden state exists
       self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None  )
       self.parent.assertTrue(output.encoder_last_hidden_state is not None  )

       if output_hidden_states:
          self.check_output_hidden_state(__lowercase,   __lowercase  )




    def 							A__ (  self   :  List[str],   __lowercase   :  Optional[int],   __lowercase   :  List[Any],   __lowercase   :  Optional[Any],   __lowercase   :  List[str],   __lowercase   :  Union[str, Any]  ):
       lowercase__   					=			MaskaFormerForUniversalSegmentation(config=__lowercase  )
       model.to(__lowercase  )
       model.eval()

       def comm_check_on_output(__lowercase   :  Any  ):
          # let's still check that all the required stuff is there
          self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None  )
          self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None  )
          self.parent.assertTrue(result.encoder_last_hidden_state is not None  )
          # okay, now we need to check the logits shape
          # due to the encoder compression, masks have a //4 spatial size
          self.parent.assertEqual(
              result.masks_queries_logits.shape,   (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4),   )
          # + 1 for null class
          self.parent.assertEqual(
              result.class_queries_logits.shape,   (self.batch_size, self.num_queries, self.num_labels + 1)  )

       with torch.no_grad():
          lowercase__   					=			model(pixel_values=__lowercase,   pixel_mask=__lowercase  )
          lowercase__   					=			model(__lowercase  )

          comm_check_on_output(__lowercase  )

          lowercase__   					=			model(
              pixel_values=__lowercase,   pixel_mask=__lowercase,   mask_labels=__lowercase,   class_labels=__lowercase  )

       comm_check_on_output(__lowercase  )

       self.parent.assertTrue(result.loss is not None  )
       self.parent.assertEqual(result.loss.shape,   torch.Size([1]  )  )
@require_torch
class 			_snake_case     (   lowerCamelCase__      ,		lowerCamelCase__      ,		unittest.TestCase):
    UpperCamelCase__			:   Tuple       						=(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
    UpperCamelCase__			:   Tuple       						={"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {}

    UpperCamelCase__			:   int       						=False
    UpperCamelCase__			:   Dict       						=False
    UpperCamelCase__			:   List[str]       						=False
    UpperCamelCase__			:   Union[str, Any]       						=False




    def 							A__ (  self   :  Union[str, Any]  ):
       lowercase__   					=			MaskaFormerModelTester(self  )
       lowercase__   					=			ConfigTester(self,   config_class=__lowercase,   has_text_modality=__lowercase  )




    def 							A__ (  self   :  List[str]  ):
       self.config_tester.run_common_tests()




    def 							A__ (  self   :  Optional[Any]  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(__lowercase,   **__lowercase,   output_hidden_states=__lowercase  )




    def 							A__ (  self   :  int  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*__lowercase  )




    @unittest.skip(reason="Mask2Former does not use inputs_embeds"  )
    def 							A__ (  self   :  List[Any]  ):
       pass




    @unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"  )
    def 							A__ (  self   :  Dict  ):
       pass




    @unittest.skip(reason="Mask2Former is not a generative model"  )
    def 							A__ (  self   :  List[Any]  ):
       pass




    @unittest.skip(reason="Mask2Former does not use token embeddings"  )
    def 							A__ (  self   :  Optional[int]  ):
       pass




    @require_torch_multi_gpu
    @unittest.skip(
        reason="Mask2Former has some layers using `add_module` which doesn't work well with `nn.DataParallel`"  )
    def 							A__ (  self   :  str  ):
       pass




    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."  )
    def 							A__ (  self   :  Union[str, Any]  ):
       pass




    def 							A__ (  self   :  List[str]  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()

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

          lowercase__   					=			["pixel_values"]
          self.assertListEqual(arg_names[:1],   __lowercase  )




    @slow
    def 							A__ (  self   :  int  ):




       for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
          lowercase__   					=			MaskaFormerModel.from_pretrained(__lowercase  )
          self.assertIsNotNone(__lowercase  )




    def 							A__ (  self   :  str  ):
       lowercase__   					=			(self.model_tester.min_size,) * 2
       lowercase__   					=			{
           "pixel_values": torch.randn((2, 3, *size),   device=__lowercase  ),
           "mask_labels": torch.randn((2, 10, *size),   device=__lowercase  ),
           "class_labels": torch.zeros(2,   10,   device=__lowercase  ).long(),
       }
       lowercase__   					=			self.model_tester.get_config()

       lowercase__   					=			MaskaFormerForUniversalSegmentation(__lowercase  ).to(__lowercase  )
       lowercase__   					=			model(**__lowercase  )
       self.assertTrue(outputs.loss is not None  )




    def 							A__ (  self   :  List[str]  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.create_and_check_maskaformer_model(__lowercase,   **__lowercase,   output_hidden_states=__lowercase  )




    def 							A__ (  self   :  Optional[int]  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          lowercase__   					=			model_class(__lowercase  ).to(__lowercase  )
          lowercase__   					=			model(**__lowercase,   output_attentions=__lowercase  )
          self.assertTrue(outputs.attentions is not None  )




    def 							A__ (  self   :  str  ):




       if not self.model_tester.is_training:
          return

       lowercase__   					=			self.all_model_classes[1]
       lowercase__   					=			self.model_tester.prepare_config_and_inputs()

       lowercase__   					=			model_class(__lowercase  )
       model.to(__lowercase  )
       model.train()

       lowercase__   					=			model(__lowercase,   mask_labels=__lowercase,   class_labels=__lowercase  ).loss
       loss.backward()




    def 							A__ (  self   :  Dict  ):
       lowercase__   					=			self.all_model_classes[1]
       lowercase__   					=			self.model_tester.prepare_config_and_inputs()
       lowercase__   					=			True
       lowercase__   					=			True

       lowercase__   					=			model_class(__lowercase  ).to(__lowercase  )
       model.train()

       lowercase__   					=			model(__lowercase,   mask_labels=__lowercase,   class_labels=__lowercase  )

       lowercase__   					=			outputs.encoder_hidden_states[0]
       encoder_hidden_states.retain_grad()

       lowercase__   					=			outputs.pixel_decoder_hidden_states[0]
       pixel_decoder_hidden_states.retain_grad()

       lowercase__   					=			outputs.transformer_decoder_hidden_states[0]
       transformer_decoder_hidden_states.retain_grad()

       lowercase__   					=			outputs.attentions[0]
       attentions.retain_grad()

       outputs.loss.backward(retain_graph=__lowercase  )

       self.assertIsNotNone(encoder_hidden_states.grad  )
       self.assertIsNotNone(pixel_decoder_hidden_states.grad  )
       self.assertIsNotNone(transformer_decoder_hidden_states.grad  )
       self.assertIsNotNone(attentions.grad  )
lowercase_						=       1e-4



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




@require_vision
@slow
class 			_snake_case     (   unittest.TestCase):




    @cached_property
    def 							A__ (  self   :  Union[str, Any]  ):
       return "facebook/mask2former-swin-small-coco-instance"




    @cached_property
    def 							A__ (  self   :  str  ):
       return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints  ) if is_vision_available() else None




    def 							A__ (  self   :  List[Any]  ):
       lowercase__   					=			MaskaFormerModel.from_pretrained(self.model_checkpoints  ).to(__lowercase  )
       lowercase__   					=			self.default_image_processor
       lowercase__   					=			prepare_img()
       lowercase__   					=			image_processor(__lowercase,   return_tensors="pt"  ).to(__lowercase  )
       lowercase__   					=			inputs["pixel_values"].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0  )
       # check size
       self.assertEqual(__lowercase,   (1, 3, 384, 384)  )

       with torch.no_grad():
          lowercase__   					=			model(**__lowercase  )

       lowercase__   					=			torch.tensor(
           [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]]  ).to(__lowercase  )
       self.assertTrue(
           torch.allclose(
               outputs.encoder_last_hidden_state[0, 0, :3, :3],   __lowercase,   atol=__lowercase  )  )

       lowercase__   					=			torch.tensor(
           [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]]  ).to(__lowercase  )
       self.assertTrue(
           torch.allclose(
               outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3],   __lowercase,   atol=__lowercase  )  )

       lowercase__   					=			torch.tensor(
           [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]]  ).to(__lowercase  )
       self.assertTrue(
           torch.allclose(
               outputs.transformer_decoder_last_hidden_state[0, :3, :3],   __lowercase,   atol=__lowercase  )  )




    def 							A__ (  self   :  Optional[Any]  ):
       lowercase__   					=			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints  ).to(__lowercase  ).eval()
       lowercase__   					=			self.default_image_processor
       lowercase__   					=			prepare_img()
       lowercase__   					=			image_processor(__lowercase,   return_tensors="pt"  ).to(__lowercase  )
       lowercase__   					=			inputs["pixel_values"].shape
       # check size is divisible by 32
       self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0  )
       # check size
       self.assertEqual(__lowercase,   (1, 3, 384, 384)  )

       with torch.no_grad():
          lowercase__   					=			model(**__lowercase  )
       # masks_queries_logits
       lowercase__   					=			outputs.masks_queries_logits
       self.assertEqual(
           masks_queries_logits.shape,   (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)  )
       lowercase__   					=			[
           [-8.7839, -9.0056, -8.8121],
           [-7.4104, -7.0313, -6.5401],
           [-6.6105, -6.3427, -6.4675],
       ]
       lowercase__   					=			torch.tensor(__lowercase  ).to(__lowercase  )
       self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3],   __lowercase,   atol=__lowercase  )  )
       # class_queries_logits
       lowercase__   					=			outputs.class_queries_logits
       self.assertEqual(class_queries_logits.shape,   (1, model.config.num_queries, model.config.num_labels + 1)  )
       lowercase__   					=			torch.tensor(
           [
               [1.8324, -8.0835, -4.1922],
               [0.8450, -9.0050, -3.6053],
               [0.3045, -7.7293, -3.0275],
           ]  ).to(__lowercase  )
       self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3],   __lowercase,   atol=__lowercase  )  )




    def 							A__ (  self   :  str  ):
       lowercase__   					=			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints  ).to(__lowercase  ).eval()
       lowercase__   					=			self.default_image_processor

       lowercase__   					=			image_processor(
           [np.zeros((3, 800, 1333)  ), np.zeros((3, 800, 1333)  )],   segmentation_maps=[np.zeros((384, 384)  ).astype(np.floataa  ), np.zeros((384, 384)  ).astype(np.floataa  )],   return_tensors="pt",   )

       lowercase__   					=			inputs["pixel_values"].to(__lowercase  )
       lowercase__   					=			[el.to(__lowercase  ) for el in inputs["mask_labels"]]
       lowercase__   					=			[el.to(__lowercase  ) for el in inputs["class_labels"]]

       with torch.no_grad():
          lowercase__   					=			model(**__lowercase  )

       self.assertTrue(outputs.loss is not None  )









from collections import namedtuple

import requests
from lxml import html  # type: ignore

lowercase_						=       namedtuple("""covid_data""", """cases deaths recovered""")



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_ = "https://www.worldometers.info/coronavirus/"					):
			lowercase__   					=			"//div[@class = \"maincounter-number\"]/span/text()"
			return covid_data(*html.fromstring(requests.get(SCREAMING_SNAKE_CASE_					).content					).xpath(SCREAMING_SNAKE_CASE_					)					)


lowercase_						=       """Total COVID-19 cases in the world: {}
Total deaths due to COVID-19 in the world: {}
Total COVID-19 patients recovered in the world: {}"""




print(fmt.format(*covid_stats()))




