






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      UpperCamelCase :







  """simple docstring"""



  def __init__(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Any						,)    ->   List[Any]:


      '''simple docstring'''
      A	 =      parent
      A	 =      1_3
      A	 =      7
      A	 =      True
      A	 =      True
      A	 =      True
      A	 =      True
      A	 =      True
      A	 =      False
      A	 =      False
      A	 =      False
      A	 =      2
      A	 =      9_9
      A	 =      0
      A	 =      3_2
      A	 =      2
      A	 =      4
      A	 =      0.1
      A	 =      0.1
      A	 =      5_1_2
      A	 =      1_6
      A	 =      2
      A	 =      0.02
      A	 =      3
      A	 =      4
      A	 =      'last'
      A	 =      True
      A	 =      None
      A	 =      0
  def       A(  self		:       int		)    ->   Tuple:


      '''simple docstring'''
      A	 =      ids_tensor([self.batch_size, self.seq_length]						,self.vocab_size		)
      A	 =      random_attention_mask([self.batch_size, self.seq_length]						,dtype=tf.floataa		)

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

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

      A	 =      None
      A	 =      None
      A	 =      None
      if self.use_labels:
          A	 =      ids_tensor([self.batch_size]						,self.type_sequence_label_size		)
          A	 =      ids_tensor([self.batch_size, self.seq_length]						,self.num_labels		)
          A	 =      ids_tensor([self.batch_size]						,2						,dtype=tf.floataa		)
          A	 =      ids_tensor([self.batch_size]						,self.num_choices		)

      A	 =      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       A(  self		:       Tuple						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,)    ->   Optional[Any]:


      '''simple docstring'''
      A	 =      TFFlaubertModel(config=_SCREAMING_SNAKE_CASE		)
      A	 =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
      A	 =      model(_SCREAMING_SNAKE_CASE		)

      A	 =      [input_ids, input_mask]
      A	 =      model(_SCREAMING_SNAKE_CASE		)
      self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)		)
  def       A(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Any						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       int						,)    ->   Tuple:


      '''simple docstring'''
      A	 =      TFFlaubertWithLMHeadModel(_SCREAMING_SNAKE_CASE		)

      A	 =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
      A	 =      model(_SCREAMING_SNAKE_CASE		)

      self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.vocab_size)		)
  def       A(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       Dict						,_SCREAMING_SNAKE_CASE		:       str						,)    ->   Tuple:


      '''simple docstring'''
      A	 =      TFFlaubertForQuestionAnsweringSimple(_SCREAMING_SNAKE_CASE		)

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

      A	 =      model(_SCREAMING_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       A(  self		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,)    ->   Union[str, Any]:


      '''simple docstring'''
      A	 =      TFFlaubertForSequenceClassification(_SCREAMING_SNAKE_CASE		)

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

      A	 =      model(_SCREAMING_SNAKE_CASE		)

      self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.type_sequence_label_size)		)
  def       A(  self		:       Any						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       str						,)    ->   Tuple:


      '''simple docstring'''
      A	 =      self.num_labels
      A	 =      TFFlaubertForTokenClassification(config=_SCREAMING_SNAKE_CASE		)
      A	 =      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
      A	 =      model(_SCREAMING_SNAKE_CASE		)
      self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.num_labels)		)
  def       A(  self		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Any						,_SCREAMING_SNAKE_CASE		:       List[Any]						,_SCREAMING_SNAKE_CASE		:       str						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Dict						,)    ->   Any:


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







  def       A(  self		:       int		)    ->   int:


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


@require_tf
class      UpperCamelCase (				snake_case__			,       snake_case__			,       unittest.TestCase ):







  """simple docstring"""



  snake_case    =   (
      (
          TFFlaubertModel,
          TFFlaubertWithLMHeadModel,
          TFFlaubertForSequenceClassification,
          TFFlaubertForQuestionAnsweringSimple,
          TFFlaubertForTokenClassification,
          TFFlaubertForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  snake_case    =   (
      (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  snake_case    =   (
      {
          "feature-extraction": TFFlaubertModel,
          "fill-mask": TFFlaubertWithLMHeadModel,
          "question-answering": TFFlaubertForQuestionAnsweringSimple,
          "text-classification": TFFlaubertForSequenceClassification,
          "token-classification": TFFlaubertForTokenClassification,
          "zero-shot": TFFlaubertForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  snake_case    =   False
  snake_case    =   False
  def       A(  self		:       str						,_SCREAMING_SNAKE_CASE		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   Optional[int]:


      '''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       A(  self		:       List[Any]		)    ->   Dict:


      '''simple docstring'''
      A	 =      TFFlaubertModelTester(self		)
      A	 =      ConfigTester(self						,config_class=_SCREAMING_SNAKE_CASE						,emb_dim=3_7		)
  def       A(  self		:       Union[str, Any]		)    ->   Union[str, Any]:


      '''simple docstring'''
      self.config_tester.run_common_tests()
  def       A(  self		:       Optional[int]		)    ->   Optional[int]:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_model(*_SCREAMING_SNAKE_CASE		)
  def       A(  self		:       List[Any]		)    ->   List[str]:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_lm_head(*_SCREAMING_SNAKE_CASE		)
  def       A(  self		:       Tuple		)    ->   Optional[Any]:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_qa(*_SCREAMING_SNAKE_CASE		)
  def       A(  self		:       Any		)    ->   Any:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_sequence_classif(*_SCREAMING_SNAKE_CASE		)
  def       A(  self		:       List[Any]		)    ->   int:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_token_classification(*_SCREAMING_SNAKE_CASE		)
  def       A(  self		:       List[str]		)    ->   str:


      '''simple docstring'''
      A	 =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_flaubert_for_multiple_choice(*_SCREAMING_SNAKE_CASE		)







  @slow
  def       A(  self		:       List[Any]		)    ->   Optional[int]:


      '''simple docstring'''
      for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          A	 =      TFFlaubertModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
          self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)


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







  """simple docstring"""



  @slow
  def       A(  self		:       Union[str, Any]		)    ->   Any:


      '''simple docstring'''
      A	 =      TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'		)

      A	 =      tf.convert_to_tensor(
          [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]]						,dtype=tf.intaa						,)  # "J'aime flaubert !"

      A	 =      model(_SCREAMING_SNAKE_CASE		)[0]
      A	 =      tf.TensorShape((1, 8, 5_1_2)		)
      self.assertEqual(output.shape						,_SCREAMING_SNAKE_CASE		)
      # compare the actual values for a slice.
      A	 =      tf.convert_to_tensor(
          [
              [
                  [-1.8768773, -1.566555, 0.27072418],
                  [-1.6920038, -0.5873505, 1.9329599],
                  [-2.9563985, -1.6993835, 1.7972052],
              ]
          ]						,dtype=tf.floataa						,)

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













from __future__ import annotations

from collections.abc import Generator

import requests
from bsa import BeautifulSoup

lowerCAmelCase_           = 'https://www.indeed.co.in/jobs?q=mobile+app+development&l='







def      snake_case		(							UpperCAmelCase	:       str = "mumbai"   ):
				A	 =      BeautifulSoup(requests.get(url + location   ).content,						'html.parser'   )
				# This attribute finds out all the specifics listed in a job
				for job in soup.find_all('div',						attrs={'data-tn-component': 'organicJob'}   ):
								A	 =      job.find('a',						attrs={'data-tn-element': 'jobTitle'}   ).text.strip()
								A	 =      job.find('span',						{'class': 'company'}   ).text.strip()
								yield job_title, company_name


if __name__ == "__main__":
					for i, job in enumerate(fetch_jobs('Bangalore'), 1):
										print(f'''Job {i:>2} is {job[0]} at {job[1]}''')





