


from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import numpy as np
    import tensorflow as tf

    from transformers import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertConfig,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertWithLMHeadModel,
    )



class      __lowerCamelCase       :







       def __init__(       self:      List[str],A_:      Tuple,):






            '''simple docstring'''




            __UpperCamelCase      =       parent
            __UpperCamelCase      =       13
            __UpperCamelCase      =       7
            __UpperCamelCase      =       True
            __UpperCamelCase      =       True
            __UpperCamelCase      =       True
            __UpperCamelCase      =       True
            __UpperCamelCase      =       True
            __UpperCamelCase      =       False
            __UpperCamelCase      =       False
            __UpperCamelCase      =       False
            __UpperCamelCase      =       2
            __UpperCamelCase      =       99
            __UpperCamelCase      =       0
            __UpperCamelCase      =       32
            __UpperCamelCase      =       2
            __UpperCamelCase      =       4
            __UpperCamelCase      =       0.1
            __UpperCamelCase      =       0.1
            __UpperCamelCase      =       512
            __UpperCamelCase      =       16
            __UpperCamelCase      =       2
            __UpperCamelCase      =       0.0_2
            __UpperCamelCase      =       3
            __UpperCamelCase      =       4
            __UpperCamelCase      =       'last'
            __UpperCamelCase      =       True
            __UpperCamelCase      =       None
            __UpperCamelCase      =       0







       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            __UpperCamelCase      =       ids_tensor([self.batch_size, self.seq_length],self.vocab_size )
            __UpperCamelCase      =       random_attention_mask([self.batch_size, self.seq_length],dtype=tf.floataa )

            __UpperCamelCase      =       None
            if self.use_input_lengths:
                 __UpperCamelCase      =       (
                     ids_tensor([self.batch_size],vocab_size=2 ) + self.seq_length - 2
                 )  # small variation of seq_length

            __UpperCamelCase      =       None
            if self.use_token_type_ids:
                 __UpperCamelCase      =       ids_tensor([self.batch_size, self.seq_length],self.n_langs )

            __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],2,dtype=tf.floataa )
                 __UpperCamelCase      =       ids_tensor([self.batch_size],self.num_choices )

            __UpperCamelCase      =       FlaubertConfig(
                vocab_size=self.vocab_size,n_special=self.n_special,emb_dim=self.hidden_size,n_layers=self.num_hidden_layers,n_heads=self.num_attention_heads,dropout=self.hidden_dropout_prob,attention_dropout=self.attention_probs_dropout_prob,gelu_activation=self.gelu_activation,sinusoidal_embeddings=self.sinusoidal_embeddings,asm=self.asm,causal=self.causal,n_langs=self.n_langs,max_position_embeddings=self.max_position_embeddings,initializer_range=self.initializer_range,summary_type=self.summary_type,use_proj=self.use_proj,bos_token_id=self.bos_token_id,)

            return (
                config,
                input_ids,
                token_type_ids,
                input_lengths,
                sequence_labels,
                token_labels,
                is_impossible_labels,
                choice_labels,
                input_mask,
            )







       def 						snake_case_     (       self:      Tuple,A_:      int,A_:      Tuple,A_:      Optional[Any],A_:      Union[str, Any],A_:      Optional[Any],A_:      Any,A_:      List[Any],A_:      Any,A_:      Tuple,):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertModel(config=_snake_case )
            __UpperCamelCase      =       {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
            __UpperCamelCase      =       model(_snake_case )

            __UpperCamelCase      =       [input_ids, input_mask]
            __UpperCamelCase      =       model(_snake_case )
            self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size) )







       def 						snake_case_     (       self:      Union[str, Any],A_:      List[Any],A_:      Optional[int],A_:      str,A_:      Optional[int],A_:      int,A_:      Optional[Any],A_:      Tuple,A_:      Optional[int],A_:      Union[str, Any],):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertWithLMHeadModel(_snake_case )

            __UpperCamelCase      =       {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
            __UpperCamelCase      =       model(_snake_case )

            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size) )







       def 						snake_case_     (       self:      str,A_:      Optional[int],A_:      Optional[int],A_:      Optional[int],A_:      Dict,A_:      str,A_:      Any,A_:      List[str],A_:      str,A_:      Optional[int],):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertForQuestionAnsweringSimple(_snake_case )

            __UpperCamelCase      =       {'input_ids': input_ids, 'lengths': input_lengths}

            __UpperCamelCase      =       model(_snake_case )

            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:      List[str],A_:      List[Any],A_:      List[str],A_:      Optional[Any],A_:      List[Any],A_:      int,A_:      Any,A_:      Optional[Any],A_:      Dict,A_:      int,):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertForSequenceClassification(_snake_case )

            __UpperCamelCase      =       {'input_ids': input_ids, 'lengths': input_lengths}

            __UpperCamelCase      =       model(_snake_case )

            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.type_sequence_label_size) )







       def 						snake_case_     (       self:      int,A_:      Any,A_:      List[str],A_:      Optional[int],A_:      Any,A_:      Dict,A_:      List[Any],A_:      Any,A_:      Union[str, Any],A_:      Union[str, Any],):






            '''simple docstring'''




            __UpperCamelCase      =       self.num_labels
            __UpperCamelCase      =       TFFlaubertForTokenClassification(config=_snake_case )
            __UpperCamelCase      =       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
            __UpperCamelCase      =       model(_snake_case )
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.num_labels) )







       def 						snake_case_     (       self:      List[str],A_:      Any,A_:      Union[str, Any],A_:      Tuple,A_:      Optional[int],A_:      Dict,A_:      Tuple,A_:      int,A_:      List[str],A_:      Tuple,):






            '''simple docstring'''




            __UpperCamelCase      =       self.num_choices
            __UpperCamelCase      =       TFFlaubertForMultipleChoice(config=_snake_case )
            __UpperCamelCase      =       tf.tile(tf.expand_dims(_snake_case,1 ),(1, self.num_choices, 1) )
            __UpperCamelCase      =       tf.tile(tf.expand_dims(_snake_case,1 ),(1, self.num_choices, 1) )
            __UpperCamelCase      =       tf.tile(tf.expand_dims(_snake_case,1 ),(1, self.num_choices, 1) )
            __UpperCamelCase      =       {
                'input_ids': multiple_choice_inputs_ids,
                'attention_mask': multiple_choice_input_mask,
                'token_type_ids': multiple_choice_token_type_ids,
            }
            __UpperCamelCase      =       model(_snake_case )
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_choices) )







       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            __UpperCamelCase      =       self.prepare_config_and_inputs()
            (
                (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),  (
                __UpperCamelCase       
            ),         
            )      =       config_and_inputs
            __UpperCamelCase      =       {
                'input_ids': input_ids,
                'token_type_ids': token_type_ids,
                'langs': token_type_ids,
                'lengths': input_lengths,
            }
            return config, inputs_dict



@require_tf
class      __lowerCamelCase       (_a							,	_a							,	unittest.TestCase		):
       _lowercase											=			(
           (
               TFFlaubertModel,
               TFFlaubertWithLMHeadModel,
               TFFlaubertForSequenceClassification,
               TFFlaubertForQuestionAnsweringSimple,
               TFFlaubertForTokenClassification,
               TFFlaubertForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       _lowercase											=			(
           (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       _lowercase											=			(
           {
               '''feature-extraction''': TFFlaubertModel,
               '''fill-mask''': TFFlaubertWithLMHeadModel,
               '''question-answering''': TFFlaubertForQuestionAnsweringSimple,
               '''text-classification''': TFFlaubertForSequenceClassification,
               '''token-classification''': TFFlaubertForTokenClassification,
               '''zero-shot''': TFFlaubertForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       _lowercase											=			False
       _lowercase											=			False







       def 						snake_case_     (       self:      Union[str, Any],A_:      Optional[Any],A_:      int,A_:      Tuple,A_:      Dict,A_:      List[Any] ):






            '''simple docstring'''




            if (
                pipeline_test_casse_name == "QAPipelineTests"
                and tokenizer_name is not None
                and not tokenizer_name.endswith('Fast' )
            ):
                 # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                 # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                 # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                 return True

            return False







       def 						snake_case_     (       self:      Dict ):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertModelTester(self )
            __UpperCamelCase      =       ConfigTester(self,config_class=_snake_case,emb_dim=37 )







       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            self.config_tester.run_common_tests()







       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_model(*_snake_case )







       def 						snake_case_     (       self:      List[str] ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_lm_head(*_snake_case )







       def 						snake_case_     (       self:      Optional[Any] ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_qa(*_snake_case )







       def 						snake_case_     (       self:      Any ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_sequence_classif(*_snake_case )







       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_for_token_classification(*_snake_case )







       def 						snake_case_     (       self:      Optional[Any] ):






            '''simple docstring'''




            __UpperCamelCase      =       self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_for_multiple_choice(*_snake_case )







       @slow
       def 						snake_case_     (       self:      Optional[Any] ):






            '''simple docstring'''




            for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase      =       TFFlaubertModel.from_pretrained(_snake_case )
                 self.assertIsNotNone(_snake_case )



@require_tf
@require_sentencepiece
@require_tokenizers
class      __lowerCamelCase       (unittest.TestCase		):







       @slow
       def 						snake_case_     (       self:      int ):






            '''simple docstring'''




            __UpperCamelCase      =       TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased' )

            __UpperCamelCase      =       tf.convert_to_tensor(
                [[0, 158, 735, 2592, 1424, 6727, 82, 1]],dtype=tf.intaa,)  # "J'aime flaubert !"

            __UpperCamelCase      =       model(_snake_case )[0]
            __UpperCamelCase      =       tf.TensorShape((1, 8, 512) )
            self.assertEqual(output.shape,_snake_case )
            # compare the actual values for a slice.
            __UpperCamelCase      =       tf.convert_to_tensor(
                [
                    [
                        [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
                        [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
                        [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
                    ]
                ],dtype=tf.floataa,)

            self.assertTrue(np.allclose(output[:, :3, :3].numpy(),expected_slice.numpy(),atol=1E-4 ) )








from datetime import datetime

import requests


def    A						(__A   :    str       )   ->      bytes:







     """simple docstring"""


     UpperCAmelCase_          =							'''https://downloadgram.net/wp-json/wppress/video-downloader/video?url='''
     UpperCAmelCase_          =							requests.get(base_url + url       ).json()[0]['''urls'''][0]['''src''']
     return requests.get(__A       ).content


if __name__ == "__main__":
    snake_case_ : Optional[Any]    		=       input("Enter Video/IGTV url: ").strip()
    snake_case_ : Any    		=       f"{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4"
    with open(file_name, "wb") as fp:
        fp.write(download_video(url))
    print(f"Done. Video saved to disk as {file_name}.")






