"""simple docstring"""
import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         LiltForQuestionAnswering,
         LiltForSequenceClassification,
         LiltForTokenClassification,
         LiltModel,
     )
     from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST



class 					lowerCAmelCase_      :



    """simple docstring"""

    def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=13						,      lowerCAmelCase=7						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=True						,      lowerCAmelCase=99						,      lowerCAmelCase=24						,      lowerCAmelCase=2						,      lowerCAmelCase=6						,      lowerCAmelCase=37						,      lowerCAmelCase="gelu"						,      lowerCAmelCase=0.1						,      lowerCAmelCase=0.1						,      lowerCAmelCase=5_12						,      lowerCAmelCase=16						,      lowerCAmelCase=2						,      lowerCAmelCase=0.02						,      lowerCAmelCase=3						,      lowerCAmelCase=None						,      lowerCAmelCase=10_00						,      ):






          """simple docstring"""

          snake_case        =     parent
          snake_case        =     batch_size
          snake_case        =     seq_length
          snake_case        =     is_training
          snake_case        =     use_input_mask
          snake_case        =     use_token_type_ids
          snake_case        =     use_labels
          snake_case        =     vocab_size
          snake_case        =     hidden_size
          snake_case        =     num_hidden_layers
          snake_case        =     num_attention_heads
          snake_case        =     intermediate_size
          snake_case        =     hidden_act
          snake_case        =     hidden_dropout_prob
          snake_case        =     attention_probs_dropout_prob
          snake_case        =     max_position_embeddings
          snake_case        =     type_vocab_size
          snake_case        =     type_sequence_label_size
          snake_case        =     initializer_range
          snake_case        =     num_labels
          snake_case        =     scope
          snake_case        =     range_bbox

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.vocab_size      )

          snake_case        =     ids_tensor([self.batch_size, self.seq_length, 4]						,      self.range_bbox      )
          # Ensure that bbox is legal
          for i in range(bbox.shape[0]      ):
                for j in range(bbox.shape[1]      ):
                      if bbox[i, j, 3] < bbox[i, j, 1]:
                            snake_case        =     bbox[i, j, 3]
                            snake_case        =     bbox[i, j, 1]
                            snake_case        =     t
                      if bbox[i, j, 2] < bbox[i, j, 0]:
                            snake_case        =     bbox[i, j, 2]
                            snake_case        =     bbox[i, j, 0]
                            snake_case        =     t

          snake_case        =     None
          if self.use_input_mask:
                snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      vocab_size=2      )

          snake_case        =     None
          if self.use_token_type_ids:
                snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.type_vocab_size      )

          snake_case        =     None
          snake_case        =     None
          if self.use_labels:
                snake_case        =     ids_tensor([self.batch_size]						,      self.type_sequence_label_size      )
                snake_case        =     ids_tensor([self.batch_size, self.seq_length]						,      self.num_labels      )

          snake_case        =     self.get_config()

          return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels

    def 						snake_case	(			self      ):






          """simple docstring"""

          return LiltConfig(
              vocab_size=self.vocab_size						,      hidden_size=self.hidden_size						,      num_hidden_layers=self.num_hidden_layers						,      num_attention_heads=self.num_attention_heads						,      intermediate_size=self.intermediate_size						,      hidden_act=self.hidden_act						,      hidden_dropout_prob=self.hidden_dropout_prob						,      attention_probs_dropout_prob=self.attention_probs_dropout_prob						,      max_position_embeddings=self.max_position_embeddings						,      type_vocab_size=self.type_vocab_size						,      initializer_range=self.initializer_range						,      )

    def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      ):






          """simple docstring"""

          snake_case        =     LiltModel(config=lowerCAmelCase_      )
          model.to(lowerCAmelCase_      )
          model.eval()
          snake_case        =     model(lowerCAmelCase_						,      bbox=lowerCAmelCase_						,      attention_mask=lowerCAmelCase_						,      token_type_ids=lowerCAmelCase_      )
          snake_case        =     model(lowerCAmelCase_						,      bbox=lowerCAmelCase_						,      token_type_ids=lowerCAmelCase_      )
          snake_case        =     model(lowerCAmelCase_						,      bbox=lowerCAmelCase_      )

          self.parent.assertEqual(result.last_hidden_state.shape						,      (self.batch_size, self.seq_length, self.hidden_size)      )
          self.parent.assertEqual(result.pooler_output.shape						,      (self.batch_size, self.hidden_size)      )

    def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      ):






          """simple docstring"""

          snake_case        =     self.num_labels
          snake_case        =     LiltForTokenClassification(config=lowerCAmelCase_      )
          model.to(lowerCAmelCase_      )
          model.eval()
          snake_case        =     model(
              lowerCAmelCase_						,      bbox=lowerCAmelCase_						,      attention_mask=lowerCAmelCase_						,      token_type_ids=lowerCAmelCase_						,      labels=lowerCAmelCase_      )
          self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.seq_length, self.num_labels)      )

    def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      ):






          """simple docstring"""

          snake_case        =     LiltForQuestionAnswering(config=lowerCAmelCase_      )
          model.to(lowerCAmelCase_      )
          model.eval()
          snake_case        =     model(
              lowerCAmelCase_						,      bbox=lowerCAmelCase_						,      attention_mask=lowerCAmelCase_						,      token_type_ids=lowerCAmelCase_						,      start_positions=lowerCAmelCase_						,      end_positions=lowerCAmelCase_						,      )
          self.parent.assertEqual(result.start_logits.shape						,      (self.batch_size, self.seq_length)      )
          self.parent.assertEqual(result.end_logits.shape						,      (self.batch_size, self.seq_length)      )

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     self.prepare_config_and_inputs()
          (
              (
              snake_case  
          )   ,(
              snake_case  
          )   ,(
              snake_case  
          )   ,(
              snake_case  
          )   ,(
              snake_case  
          )   ,(
              snake_case  
          )   ,(
              snake_case  
          )   ,  
          )        =     config_and_inputs
          snake_case        =     {
              'input_ids': input_ids,
              'bbox': bbox,
              'token_type_ids': token_type_ids,
              'attention_mask': input_mask,
          }
          return config, inputs_dict





@require_torch
class 					lowerCAmelCase_      (     __lowerCAmelCase       ,      __lowerCAmelCase       ,      __lowerCAmelCase       ,      unittest.TestCase   ):



    """simple docstring"""
    _lowerCAmelCase       :      Union[str, Any]     					=  (
        (
            LiltModel,
            LiltForSequenceClassification,
            LiltForTokenClassification,
            LiltForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    _lowerCAmelCase       :      Dict     					=  (
        {
            '''feature-extraction''': LiltModel,
            '''question-answering''': LiltForQuestionAnswering,
            '''text-classification''': LiltForSequenceClassification,
            '''token-classification''': LiltForTokenClassification,
            '''zero-shot''': LiltForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    _lowerCAmelCase       :      Tuple     					=  False
    _lowerCAmelCase       :      Optional[Any]     					=  False

    def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






          """simple docstring"""

          return True

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     LiltModelTester(self      )
          snake_case        =     ConfigTester(self						,      config_class=lowerCAmelCase_						,      hidden_size=37      )

    def 						snake_case	(			self      ):






          """simple docstring"""

          self.config_tester.run_common_tests()

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCAmelCase_      )

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                snake_case        =     type
                self.model_tester.create_and_check_model(*lowerCAmelCase_      )

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_      )

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_      )

    @slow
    def 						snake_case	(			self      ):






          """simple docstring"""

          for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                snake_case        =     LiltModel.from_pretrained(lowerCAmelCase_      )
                self.assertIsNotNone(lowerCAmelCase_      )





@require_torch
@slow
class 					lowerCAmelCase_      (     unittest.TestCase   ):



    """simple docstring"""

    def 						snake_case	(			self      ):






          """simple docstring"""

          snake_case        =     LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base'      ).to(lowerCAmelCase_      )

          snake_case        =     torch.tensor([[1, 2]]						,      device=lowerCAmelCase_      )
          snake_case        =     torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]						,      device=lowerCAmelCase_      )

          # forward pass
          with torch.no_grad():
                snake_case        =     model(input_ids=lowerCAmelCase_						,      bbox=lowerCAmelCase_      )

          snake_case        =     torch.Size([1, 2, 7_68]      )
          snake_case        =     torch.tensor(
              [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]						,      device=lowerCAmelCase_						,      )

          self.assertTrue(outputs.last_hidden_state.shape						,      lowerCAmelCase_      )
          self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]						,      lowerCAmelCase_						,      atol=1E-3      )      )



"""simple docstring"""
import requests
from bsa import BeautifulSoup





def 				lowerCAmelCase__      (     _UpperCamelCase    :			str = "https://www.worldometers.info/coronavirus"   )   ->			dict:





						"""simple docstring"""






						snake_case        =     BeautifulSoup(requests.get(_UpperCamelCase   ).text	,     'html.parser'   )
						snake_case        =     soup.findAll('h1'   )
						snake_case        =     soup.findAll('div'	,     {'class': 'maincounter-number'}   )
						keys += soup.findAll('span'	,     {'class': 'panel-title'}   )
						values += soup.findAll('div'	,     {'class': 'number-table-main'}   )
						return {key.text.strip(): value.text.strip() for key, value in zip(_UpperCamelCase	,     _UpperCamelCase   )}


if __name__ == "__main__":
					print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
					for key, value in world_covidaa_stats().items():
										print(f"""{key}\n{value}\n""")


