


import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
UpperCAmelCase    =					{"""LayoutLMv2Config""", """LayoutLMv3Config"""}







@is_pipeline_test
class lowerCAmelCase_		(				unittest.TestCase ):

	'''simple docstring'''

	__snake_case				=						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
	__snake_case				=						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

	if model_mapping is not None:
		__snake_case				=						{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
	if tf_model_mapping is not None:
		__snake_case				=						{
		    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
		}



	@require_torch
	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   pipeline(
							    task='''text-classification'''	,   model='''hf-internal-testing/tiny-random-distilbert'''	,   framework='''pt'''      )

							snake_case_ =   text_classifier('''This is great !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]      )

							snake_case_ =   text_classifier('''This is great !'''	,   top_k=2      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]      )

							snake_case_ =   text_classifier(['''This is great !''', '''This is bad''']	,   top_k=2      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							    ]	,   )

							snake_case_ =   text_classifier('''This is great !'''	,   top_k=1      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]      )

							# Legacy behavior
							snake_case_ =   text_classifier('''This is great !'''	,   return_all_scores=_UpperCAmelCase      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]      )

							snake_case_ =   text_classifier('''This is great !'''	,   return_all_scores=_UpperCAmelCase      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [[{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}]]      )

							snake_case_ =   text_classifier(['''This is great !''', '''Something else''']	,   return_all_scores=_UpperCAmelCase      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							        [{'''label''': '''LABEL_0''', '''score''': 0.504}, {'''label''': '''LABEL_1''', '''score''': 0.496}],
							    ]	,   )

							snake_case_ =   text_classifier(['''This is great !''', '''Something else''']	,   return_all_scores=_UpperCAmelCase      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [
							        {'''label''': '''LABEL_0''', '''score''': 0.504},
							        {'''label''': '''LABEL_0''', '''score''': 0.504},
							    ]	,   )



	@require_torch
	def 		UpperCamelCase__  (			self      ):
							import torch

							snake_case_ =   pipeline(
							    task='''text-classification'''	,   model='''hf-internal-testing/tiny-random-distilbert'''	,   framework='''pt'''	,   device=torch.device('''cpu'''      )	,   )

							snake_case_ =   text_classifier('''This is great !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]      )



	@require_tf
	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   pipeline(
							    task='''text-classification'''	,   model='''hf-internal-testing/tiny-random-distilbert'''	,   framework='''tf'''      )

							snake_case_ =   text_classifier('''This is great !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''LABEL_0''', '''score''': 0.504}]      )



	@slow
	@require_torch
	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   pipeline('''text-classification'''      )

							snake_case_ =   text_classifier('''This is great !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''POSITIVE''', '''score''': 1.0}]      )
							snake_case_ =   text_classifier('''This is bad !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''NEGATIVE''', '''score''': 1.0}]      )
							snake_case_ =   text_classifier('''Birds are a type of animal'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''POSITIVE''', '''score''': 0.988}]      )



	@slow
	@require_tf
	def 		UpperCamelCase__  (			self      ):
							snake_case_ =   pipeline('''text-classification'''	,   framework='''tf'''      )

							snake_case_ =   text_classifier('''This is great !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''POSITIVE''', '''score''': 1.0}]      )
							snake_case_ =   text_classifier('''This is bad !'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''NEGATIVE''', '''score''': 1.0}]      )
							snake_case_ =   text_classifier('''Birds are a type of animal'''      )
							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': '''POSITIVE''', '''score''': 0.988}]      )



	def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
							snake_case_ =   TextClassificationPipeline(model=_UpperCAmelCase	,   tokenizer=_UpperCAmelCase      )
							return text_classifier, ["HuggingFace is in", "This is another test"]





	def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase      ):
							snake_case_ =   text_classifier.model
							# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
							snake_case_ =   '''HuggingFace is in'''
							snake_case_ =   text_classifier(_UpperCAmelCase      )

							self.assertEqual(nested_simplify(_UpperCAmelCase      )	,   [{'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}]      )
							self.assertTrue(outputs[0]['''label'''] in model.config.idalabel.values()      )

							snake_case_ =   ['''HuggingFace is in ''', '''Paris is in France''']
							snake_case_ =   text_classifier(_UpperCAmelCase      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [{'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}, {'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}]	,   )
							self.assertTrue(outputs[0]['''label'''] in model.config.idalabel.values()      )
							self.assertTrue(outputs[1]['''label'''] in model.config.idalabel.values()      )

							# Forcing to get all results with `top_k=None`
							# This is NOT the legacy format
							snake_case_ =   text_classifier(_UpperCAmelCase	,   top_k=_UpperCAmelCase      )
							snake_case_ =   len(model.config.idalabel.values()      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [[{'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}] * N, [{'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}] * N]	,   )

							snake_case_ =   {'''text''': '''HuggingFace is in ''', '''text_pair''': '''Paris is in France'''}
							snake_case_ =   text_classifier(_UpperCAmelCase      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   {'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}	,   )
							self.assertTrue(outputs['''label'''] in model.config.idalabel.values()      )

							# This might be used a text pair, but tokenizer + pipe interaction
							# makes it hard to understand that it's not using the pair properly
							# https://github.com/huggingface/transformers/issues/17305
							# We disabled this usage instead as it was outputting wrong outputs.
							snake_case_ =   [['''HuggingFace is in ''', '''Paris is in France''']]
							with self.assertRaises(_UpperCAmelCase      ):
													text_classifier(_UpperCAmelCase      )

							# This used to be valid for doing text pairs
							# We're keeping it working because of backward compatibility
							snake_case_ =   text_classifier([[['''HuggingFace is in ''', '''Paris is in France''']]]      )
							self.assertEqual(
							    nested_simplify(_UpperCAmelCase      )	,   [{'''label''': ANY(_UpperCAmelCase      ), '''score''': ANY(_UpperCAmelCase      )}]	,   )
							self.assertTrue(outputs[0]['''label'''] in model.config.idalabel.values()      )



from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

UpperCAmelCase    =					{"""UserAgent""": UserAgent().random}






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      )->						dict:




      """simple docstring"""

      snake_case_ =   script.contents[0]
      snake_case_ =   json.loads(data[data.find('''{"config"'''      ) : -1]      )
      return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]







class lowerCAmelCase_		:

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase      ):
       snake_case_ =   F'''https://www.instagram.com/{username}/'''
       snake_case_ =   self.get_json()



 def 		UpperCamelCase__  (			self      ):
       snake_case_ =   requests.get(self.url	,   headers=_UpperCAmelCase      ).text
       snake_case_ =   BeautifulSoup(_UpperCAmelCase	,   '''html.parser'''      ).find_all('''script'''      )
       try:
             return extract_user_profile(scripts[4]      )
       except (json.decoder.JSONDecodeError, KeyError):
             return extract_user_profile(scripts[3]      )



 def __repr__(			self      ):
       return F'''{self.__class__.__name__}(\'{self.username}\')'''



 def __str__(			self      ):
       return F'''{self.fullname} ({self.username}) is {self.biography}'''



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["username"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["full_name"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["biography"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["business_email"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["external_url"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_followed_by"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_follow"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["edge_owner_to_timeline_media"]["count"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["profile_pic_url_hd"]



 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["is_verified"]





 @property
 def 		UpperCamelCase__  (			self      ):
       return self.user_data["is_private"]






def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE = "github"      )->						None:




      """simple docstring"""

      import os

      if os.environ.get('''CI'''      ):
            return  # test failing on GitHub Actions
      snake_case_ =   InstagramUser(SCREAMING_SNAKE_CASE      )
      assert instagram_user.user_data
      assert isinstance(instagram_user.user_data      ,      SCREAMING_SNAKE_CASE      )
      assert instagram_user.username == username
      if username != "github":
            return
      assert instagram_user.fullname == "GitHub"
      assert instagram_user.biography == "Built for developers."
      assert instagram_user.number_of_posts > 150
      assert instagram_user.number_of_followers > 12_0000
      assert instagram_user.number_of_followings > 15
      assert instagram_user.email == "support@github.com"
      assert instagram_user.website == "https://github.com/readme"
      assert instagram_user.profile_picture_url.startswith('''https://instagram.'''      )
      assert instagram_user.is_verified is True
      assert instagram_user.is_private is False


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   UpperCAmelCase    =					InstagramUser("""github""")
   print(instagram_user)
   print(f'''{instagram_user.number_of_posts = }''')
   print(f'''{instagram_user.number_of_followers = }''')
   print(f'''{instagram_user.number_of_followings = }''')
   print(f'''{instagram_user.email = }''')
   print(f'''{instagram_user.website = }''')
   print(f'''{instagram_user.profile_picture_url = }''')
   print(f'''{instagram_user.is_verified = }''')
   print(f'''{instagram_user.is_private = }''')