'''simple docstring'''




import bsa
import requests






def     snake_case__							(      _A: bsa.element.ResultSet			)   ->     dict[str, str]:

		'''simple docstring'''


		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     snake_case__							(      _A: int = 5			)   ->     tuple:

		'''simple docstring'''


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


if __name__ == "__main__":
						import json

						__lowercase				   =  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)
						    )
						)





'''simple docstring'''




import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
						from tokenizers import Tokenizer
						from tokenizers.models import WordPiece






class     a__( unittest.TestCase     ):


			'''simple docstring'''






			def 							a_	(       self	,   __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase        =  list(tokenizer_class.max_model_input_sizes.keys())
					for model_name in sa_models[:1]:
							lowerCAmelCase        =  tokenizer_class.from_pretrained(__lowerCAmelCase)
							self.assertIsNotNone(__lowerCAmelCase)
							self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)
							self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)

							for special_tok in tokenizer.all_special_tokens:
									self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)
									lowerCAmelCase        =  tokenizer.convert_tokens_to_ids(__lowerCAmelCase)
									self.assertIsInstance(__lowerCAmelCase	,   __lowerCAmelCase)



			def 							a_	(       self	,   __lowerCAmelCase	,   __lowerCAmelCase = None):




					"""simple docstring"""


					lowerCAmelCase        =  pickle.dumps(__lowerCAmelCase)
					self.assertIsNotNone(__lowerCAmelCase)

					lowerCAmelCase        =  pickle.loads(__lowerCAmelCase)

					# Ensure is_fast is correctly restored
					self.assertEqual(be_restored.is_fast	,   be_original.is_fast)

					# Ensure encodings are potentially correctly restored
					if be_original.is_fast:
							self.assertIsNotNone(be_restored.encodings)
					else:
							self.assertIsNone(be_restored.encodings)

					# Ensure the keys are the same
					for original_v, restored_v in zip(be_original.values()	,   be_restored.values()):
							if equal_op:
									self.assertTrue(equal_op(__lowerCAmelCase	,   __lowerCAmelCase))
							else:
									self.assertEqual(__lowerCAmelCase	,   __lowerCAmelCase)



			@slow
			def 							a_	(       self):




					"""simple docstring"""


					self.check_tokenizer_from_pretrained(__lowerCAmelCase)



			def 							a_	(       self):




					"""simple docstring"""


					self.assertEqual(TensorType("""tf""")	,   TensorType.TENSORFLOW)
					self.assertEqual(TensorType("""pt""")	,   TensorType.PYTORCH)
					self.assertEqual(TensorType("""np""")	,   TensorType.NUMPY)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import numpy as np

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					# Python no tensor
					with self.subTest("""BatchEncoding (Python, return_tensors=None)"""):
							self.assert_dump_and_restore(tokenizer_p("""Small example to encode"""))

					with self.subTest("""BatchEncoding (Python, return_tensors=NUMPY)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.NUMPY)	,   np.array_equal)

					with self.subTest("""BatchEncoding (Rust, return_tensors=None)"""):
							self.assert_dump_and_restore(tokenizer_r("""Small example to encode"""))

					with self.subTest("""BatchEncoding (Rust, return_tensors=NUMPY)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.NUMPY)	,   np.array_equal)



			@require_tf
			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import tensorflow as tf

					def tf_array_equals(__lowerCAmelCase	,   __lowerCAmelCase):
							return tf.reduce_all(tf.equal(__lowerCAmelCase	,   __lowerCAmelCase))

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""BatchEncoding (Python, return_tensors=TENSORFLOW)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.TENSORFLOW)	,   __lowerCAmelCase)

					with self.subTest("""BatchEncoding (Rust, return_tensors=TENSORFLOW)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.TENSORFLOW)	,   __lowerCAmelCase)



			@require_torch
			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					import torch

					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""BatchEncoding (Python, return_tensors=PYTORCH)"""):
							self.assert_dump_and_restore(
							    tokenizer_p("""Small example to encode"""	,   return_tensors=TensorType.PYTORCH)	,   torch.equal)

					with self.subTest("""BatchEncoding (Rust, return_tensors=PYTORCH)"""):
							self.assert_dump_and_restore(
							    tokenizer_r("""Small example to encode"""	,   return_tensors=TensorType.PYTORCH)	,   torch.equal)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")

					with self.subTest("""Python Tokenizer"""):
							self.assertFalse(tokenizer_p("""Small example to_encode""").is_fast)

					with self.subTest("""Rust Tokenizer"""):
							self.assertTrue(tokenizer_r("""Small example to_encode""").is_fast)



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BertTokenizerFast.from_pretrained("""bert-base-cased""")
					lowerCAmelCase        =  tokenizer_r(["""Test""", """\xad""", """test"""]	,   is_split_into_words=__lowerCAmelCase)

					self.assertEqual(encoded.word_to_tokens(0)	,   TokenSpan(start=1	,   end=2))
					self.assertEqual(encoded.word_to_tokens(1)	,   __lowerCAmelCase)
					self.assertEqual(encoded.word_to_tokens(2)	,   TokenSpan(start=2	,   end=3))



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""np"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_torch
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""pt"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_tf
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""tf"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			@require_flax
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  BatchEncoding({"""inputs""": [[1, 2, 3], [4, 5, 6]], """labels""": [0, 1]})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax""")
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (2, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (2,))
					# test converting the converted
					with CaptureStderr() as cs:
							lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax""")
					self.assertFalse(len(cs.err)	,   msg=f"should have no warning, but got {cs.err}")

					lowerCAmelCase        =  BatchEncoding({"""inputs""": [1, 2, 3], """labels""": 0})
					lowerCAmelCase        =  batch.convert_to_tensors(tensor_type="""jax"""	,   prepend_batch_axis=__lowerCAmelCase)
					self.assertEqual(tensor_batch["""inputs"""].shape	,   (1, 3))
					self.assertEqual(tensor_batch["""labels"""].shape	,   (1,))



			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  [{"""input_ids""": np.array([0, 1, 2])}, {"""input_ids""": np.array([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   np.ndarray))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""np""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   np.ndarray))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_torch
			def 							a_	(       self):




					"""simple docstring"""


					import torch

					lowerCAmelCase        =  [{"""input_ids""": torch.tensor([0, 1, 2])}, {"""input_ids""": torch.tensor([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   torch.Tensor))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""pt""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   torch.Tensor))
					self.assertEqual(batch["""input_ids"""].tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_tf
			def 							a_	(       self):




					"""simple docstring"""


					import tensorflow as tf

					lowerCAmelCase        =  [{"""input_ids""": tf.constant([0, 1, 2])}, {"""input_ids""": tf.constant([0, 1, 2, 3])}]
					lowerCAmelCase        =  BertTokenizer.from_pretrained("""bert-base-cased""")

					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase)
					self.assertTrue(isinstance(batch["""input_ids"""]	,   tf.Tensor))
					self.assertEqual(batch["""input_ids"""].numpy().tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
					lowerCAmelCase        =  tokenizer.pad(__lowerCAmelCase	,   padding=__lowerCAmelCase	,   return_tensors="""tf""")
					self.assertTrue(isinstance(batch["""input_ids"""]	,   tf.Tensor))
					self.assertEqual(batch["""input_ids"""].numpy().tolist()	,   [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])



			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  Tokenizer(WordPiece(unk_token="""[UNK]"""))
					PreTrainedTokenizerFast(tokenizer_object=__lowerCAmelCase)







			@require_tokenizers
			def 							a_	(       self):




					"""simple docstring"""


					lowerCAmelCase        =  Tokenizer(WordPiece(unk_token="""[UNK]"""))
					with tempfile.TemporaryDirectory() as tmpdirname:
							bert_tokenizer.save(os.path.join(__lowerCAmelCase	,   """tokenizer.json"""))
							PreTrainedTokenizerFast(tokenizer_file=os.path.join(__lowerCAmelCase	,   """tokenizer.json"""))




