



'''simple docstring'''







import unittest

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

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 (
          LayoutLMForMaskedLM,
          LayoutLMForQuestionAnswering,
          LayoutLMForSequenceClassification,
          LayoutLMForTokenClassification,
          LayoutLMModel,
      )

class    lowerCamelCase_				:






   '''simple docstring'''

   def __init__(	self  ,    __UpperCamelCase  ,    __UpperCamelCase=13  ,    __UpperCamelCase=7  ,    __UpperCamelCase=True  ,    __UpperCamelCase=True  ,    __UpperCamelCase=True  ,    __UpperCamelCase=True  ,    __UpperCamelCase=99  ,    __UpperCamelCase=32  ,    __UpperCamelCase=5  ,    __UpperCamelCase=4  ,    __UpperCamelCase=37  ,    __UpperCamelCase="gelu"  ,    __UpperCamelCase=0.1  ,    __UpperCamelCase=0.1  ,    __UpperCamelCase=5_12  ,    __UpperCamelCase=16  ,    __UpperCamelCase=2  ,    __UpperCamelCase=0.02  ,    __UpperCamelCase=3  ,    __UpperCamelCase=4  ,    __UpperCamelCase=None  ,    __UpperCamelCase=10_00  ,    ):
       UpperCamelCase__	     =      parent
       UpperCamelCase__	     =      batch_size
       UpperCamelCase__	     =      seq_length
       UpperCamelCase__	     =      is_training
       UpperCamelCase__	     =      use_input_mask
       UpperCamelCase__	     =      use_token_type_ids
       UpperCamelCase__	     =      use_labels
       UpperCamelCase__	     =      vocab_size
       UpperCamelCase__	     =      hidden_size
       UpperCamelCase__	     =      num_hidden_layers
       UpperCamelCase__	     =      num_attention_heads
       UpperCamelCase__	     =      intermediate_size
       UpperCamelCase__	     =      hidden_act
       UpperCamelCase__	     =      hidden_dropout_prob
       UpperCamelCase__	     =      attention_probs_dropout_prob
       UpperCamelCase__	     =      max_position_embeddings
       UpperCamelCase__	     =      type_vocab_size
       UpperCamelCase__	     =      type_sequence_label_size
       UpperCamelCase__	     =      initializer_range
       UpperCamelCase__	     =      num_labels
       UpperCamelCase__	     =      num_choices
       UpperCamelCase__	     =      scope
       UpperCamelCase__	     =      range_bbox


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      ids_tensor([self.batch_size, self.seq_length]  ,    self.vocab_size			)

       UpperCamelCase__	     =      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]:
                   UpperCamelCase__	     =      bbox[i, j, 3]
                   UpperCamelCase__	     =      bbox[i, j, 1]
                   UpperCamelCase__	     =      t
               if bbox[i, j, 2] < bbox[i, j, 0]:
                   UpperCamelCase__	     =      bbox[i, j, 2]
                   UpperCamelCase__	     =      bbox[i, j, 0]
                   UpperCamelCase__	     =      t

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

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

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

       UpperCamelCase__	     =      self.get_config()

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


   def 						_UpperCamelCase							(	self			):
       return LayoutLMConfig(
           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 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
       UpperCamelCase__	     =      LayoutLMModel(config=lowerCAmelCase__			)
       model.to(lowerCAmelCase__			)
       model.eval()
       UpperCamelCase__	     =      model(lowerCAmelCase__  ,    lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__			)
       UpperCamelCase__	     =      model(lowerCAmelCase__  ,    lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__			)
       UpperCamelCase__	     =      model(lowerCAmelCase__  ,    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 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
       UpperCamelCase__	     =      LayoutLMForMaskedLM(config=lowerCAmelCase__			)
       model.to(lowerCAmelCase__			)
       model.eval()
       UpperCamelCase__	     =      model(lowerCAmelCase__  ,    lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__  ,    labels=lowerCAmelCase__			)
       self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.seq_length, self.vocab_size)			)


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
       UpperCamelCase__	     =      self.num_labels
       UpperCamelCase__	     =      LayoutLMForSequenceClassification(lowerCAmelCase__			)
       model.to(lowerCAmelCase__			)
       model.eval()
       UpperCamelCase__	     =      model(
           lowerCAmelCase__  ,    lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__  ,    labels=lowerCAmelCase__			)
       self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)			)


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
       UpperCamelCase__	     =      self.num_labels
       UpperCamelCase__	     =      LayoutLMForTokenClassification(config=lowerCAmelCase__			)
       model.to(lowerCAmelCase__			)
       model.eval()
       UpperCamelCase__	     =      model(lowerCAmelCase__  ,    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 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
       UpperCamelCase__	     =      LayoutLMForQuestionAnswering(config=lowerCAmelCase__			)
       model.to(lowerCAmelCase__			)
       model.eval()
       UpperCamelCase__	     =      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 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	(
           UpperCamelCase__      
       )     ,	      
       )	     =      config_and_inputs
       UpperCamelCase__	     =      {
           "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__       ,     unittest.TestCase	):






   '''simple docstring'''

   A			:  int					=						(
       (
           LayoutLMModel,
           LayoutLMForMaskedLM,
           LayoutLMForSequenceClassification,
           LayoutLMForTokenClassification,
           LayoutLMForQuestionAnswering,
       )
       if is_torch_available()
       else None
   )
   A			:  str					=						(
       {
           "document-question-answering": LayoutLMForQuestionAnswering,
           "feature-extraction": LayoutLMModel,
           "fill-mask": LayoutLMForMaskedLM,
           "text-classification": LayoutLMForSequenceClassification,
           "token-classification": LayoutLMForTokenClassification,
           "zero-shot": LayoutLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   A			:  int					=						True


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      LayoutLMModelTester(self			)
       UpperCamelCase__	     =      ConfigTester(self  ,    config_class=lowerCAmelCase__  ,    hidden_size=37			)


   def 						_UpperCamelCase							(	self			):
       self.config_tester.run_common_tests()


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowerCAmelCase__			)


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
           UpperCamelCase__	     =      type
           self.model_tester.create_and_check_model(*lowerCAmelCase__			)


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__			)


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__			)


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__			)


   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__			)







   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."			)
   def 						_UpperCamelCase							(	self			):
       pass





def     snake_case__			():
    # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
    # fmt: off
    UpperCamelCase__	     =      torch.tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]       ,	device=lowerCAmelCase_						)  # noqa: E231
    UpperCamelCase__	     =      torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]       ,	device=lowerCAmelCase_						)  # noqa: E231
    UpperCamelCase__	     =      torch.tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]       ,	device=lowerCAmelCase_						)  # noqa: E231
    UpperCamelCase__	     =      torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]       ,	device=lowerCAmelCase_						)  # noqa: E231
    # these are sequence labels (i.e. at the token level)
    UpperCamelCase__	     =      torch.tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]       ,	device=lowerCAmelCase_						)  # noqa: E231
    # fmt: on

    return input_ids, attention_mask, bbox, token_type_ids, labels





@require_torch
class    lowerCamelCase_				(						unittest.TestCase	):






   '''simple docstring'''

   @slow
   def 						_UpperCamelCase							(	self			):
       UpperCamelCase__	     =      LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"			).to(lowerCAmelCase__			)

       UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__	     =      prepare_layoutlm_batch_inputs()

       # forward pass
       UpperCamelCase__	     =      model(input_ids=lowerCAmelCase__  ,    bbox=lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__			)

       # test the sequence output on [0, :3, :3]
       UpperCamelCase__	     =      torch.tensor(
           [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]  ,    device=lowerCAmelCase__  ,    )

       self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]  ,    lowerCAmelCase__  ,    atol=1e-3			)			)

       # test the pooled output on [1, :3]
       UpperCamelCase__	     =      torch.tensor([-0.6_580, -0.0_214, 0.8_552]  ,    device=lowerCAmelCase__			)

       self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]  ,    lowerCAmelCase__  ,    atol=1e-3			)			)


   @slow
   def 						_UpperCamelCase							(	self			):
       # initialize model with randomly initialized sequence classification head
       UpperCamelCase__	     =      LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"  ,    num_labels=2			).to(
           lowerCAmelCase__			)

       UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__	     =      prepare_layoutlm_batch_inputs()

       # forward pass
       UpperCamelCase__	     =      model(
           input_ids=lowerCAmelCase__  ,    bbox=lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__  ,    labels=torch.tensor([1, 1]  ,    device=lowerCAmelCase__			)  ,    )

       # test whether we get a loss as a scalar
       UpperCamelCase__	     =      outputs.loss
       UpperCamelCase__	     =      torch.Size([]			)
       self.assertEqual(loss.shape  ,    lowerCAmelCase__			)

       # test the shape of the logits
       UpperCamelCase__	     =      outputs.logits
       UpperCamelCase__	     =      torch.Size((2, 2)			)
       self.assertEqual(logits.shape  ,    lowerCAmelCase__			)


   @slow
   def 						_UpperCamelCase							(	self			):
       # initialize model with randomly initialized token classification head
       UpperCamelCase__	     =      LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"  ,    num_labels=13			).to(
           lowerCAmelCase__			)

       UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__	     =      prepare_layoutlm_batch_inputs()

       # forward pass
       UpperCamelCase__	     =      model(
           input_ids=lowerCAmelCase__  ,    bbox=lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__  ,    labels=lowerCAmelCase__			)

       # test the loss calculation to be around 2.65
       # expected_loss = torch.tensor(2.65, device=torch_device)

       # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
       # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

       # test the shape of the logits
       UpperCamelCase__	     =      outputs.logits
       UpperCamelCase__	     =      torch.Size((2, 25, 13)			)
       self.assertEqual(logits.shape  ,    lowerCAmelCase__			)







   @slow
   def 						_UpperCamelCase							(	self			):
       # initialize model with randomly initialized token classification head
       UpperCamelCase__	     =      LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"			).to(lowerCAmelCase__			)

       UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__     ,	UpperCamelCase__	     =      prepare_layoutlm_batch_inputs()

       # forward pass
       UpperCamelCase__	     =      model(input_ids=lowerCAmelCase__  ,    bbox=lowerCAmelCase__  ,    attention_mask=lowerCAmelCase__  ,    token_type_ids=lowerCAmelCase__			)

       # test the shape of the logits
       UpperCamelCase__	     =      torch.Size((2, 25)			)
       self.assertEqual(outputs.start_logits.shape  ,    lowerCAmelCase__			)
       self.assertEqual(outputs.end_logits.shape  ,    lowerCAmelCase__			)





"""simple docstring"""


import bsa
import requests







def    UpperCAmelCase       (						UpperCAmelCase   )							-> dict[str, str]:
     return {
         "name": soup.ha.a.text,
         "genre": soup.find('span'		,   class_='genre'   ).text.strip(),
         "rating": soup.strong.text,
         "page_link": f'https://www.imdb.com{soup.a.get("href"   )}',
     }







def    UpperCAmelCase       (						UpperCAmelCase = 5   )							-> tuple:
     snake_case_   			=   int(float(UpperCAmelCase   )   )
     if num_movies < 1:
          return ()
     snake_case_   			=   (
         'https://www.imdb.com/search/title?title_type='
         f'feature&sort=num_votes,desc&count={num_movies}'
     )
     snake_case_   			=   bsa.BeautifulSoup(requests.get(UpperCAmelCase   ).content		,   'html.parser'   )
     return tuple(
         get_movie_data_from_soup(UpperCAmelCase   )
         for movie in source.find_all('div'		,   class_='lister-item mode-advanced'   )   )


if __name__ == "__main__":
    import json

    __UpperCamelCase										=     int(input('''How many movies would you like to see? '''))
    print(
        ''', '''.join(
            json.dumps(movie, indent=4) for movie in get_imdb_top_movies(num_movies)
        )
    )

