


from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

lowerCAmelCase       =							{'UserAgent': UserAgent().random}
def 			_a (      SCREAMING_SNAKE_CASE     ):


		"""simple docstring"""




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


class        _a							:

							def __init__(							self:	List[str]    ,						UpperCamelCase_:	Optional[Any]							)			->   Tuple:





									"""simple docstring"""







									lowercase__            =      f'https://www.instagram.com/{username}/'
									lowercase__            =      self.get_json()

							def       lowerCamelCase_ (							self:	Any							)			->   dict:





									"""simple docstring"""







									lowercase__            =      requests.get(self.url    ,						headers=UpperCamelCase_							).text
									lowercase__            =      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:	Union[str, Any]							)			->   str:





									"""simple docstring"""







									return f'{self.__class__.__name__}(\'{self.username}\')'

							def __str__(							self:	Tuple							)			->   str:





									"""simple docstring"""







									return f'{self.fullname} ({self.username}) is {self.biography}'

							@property
							def       lowerCamelCase_ (							self:	List[Any]							)			->   str:





									"""simple docstring"""







									return self.user_data["username"]

							@property
							def       lowerCamelCase_ (							self:	int							)			->   str:





									"""simple docstring"""







									return self.user_data["full_name"]

							@property
							def       lowerCamelCase_ (							self:	str							)			->   str:





									"""simple docstring"""







									return self.user_data["biography"]

							@property
							def       lowerCamelCase_ (							self:	str							)			->   str:





									"""simple docstring"""







									return self.user_data["business_email"]

							@property
							def       lowerCamelCase_ (							self:	int							)			->   str:





									"""simple docstring"""







									return self.user_data["external_url"]

							@property
							def       lowerCamelCase_ (							self:	Dict							)			->   int:





									"""simple docstring"""







									return self.user_data["edge_followed_by"]["count"]

							@property
							def       lowerCamelCase_ (							self:	Optional[Any]							)			->   int:





									"""simple docstring"""







									return self.user_data["edge_follow"]["count"]

							@property
							def       lowerCamelCase_ (							self:	Union[str, Any]							)			->   int:





									"""simple docstring"""







									return self.user_data["edge_owner_to_timeline_media"]["count"]

							@property
							def       lowerCamelCase_ (							self:	int							)			->   str:





									"""simple docstring"""







									return self.user_data["profile_pic_url_hd"]

							@property
							def       lowerCamelCase_ (							self:	Optional[int]							)			->   bool:





									"""simple docstring"""







									return self.user_data["is_verified"]


							@property
							def       lowerCamelCase_ (							self:	str							)			->   bool:





									"""simple docstring"""







									return self.user_data["is_private"]
def 			_a (      SCREAMING_SNAKE_CASE = "github"     ):


		"""simple docstring"""




		import os

		if os.environ.get('''CI'''     ):
				return  # test failing on GitHub Actions
		lowercase__            =      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 > 1_50
		assert instagram_user.number_of_followers > 12_00_00
		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()
			lowerCAmelCase       =							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 = }""")





from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase_       		=  logging.get_logger(__name__)

lowercase_       		=  {
    "s-JoL/Open-Llama-V1": "https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json",
}


class  A						(							_UpperCAmelCase ):







    """simple docstring"""





    lowerCamelCase			=							'open-llama'


    def __init__(      self :       Any,lowercase_ :       Optional[int]=1_0_0_0_0_0,lowercase_ :       Union[str, Any]=4_0_9_6,lowercase_ :       Dict=1_1_0_0_8,lowercase_ :       Dict=3_2,lowercase_ :       Optional[int]=3_2,lowercase_ :       Dict="silu",lowercase_ :       Union[str, Any]=2_0_4_8,lowercase_ :       Optional[int]=0.02,lowercase_ :       Dict=1E-6,lowercase_ :       Dict=True,lowercase_ :       List[Any]=0,lowercase_ :       Optional[int]=1,lowercase_ :       str=2,lowercase_ :       str=False,lowercase_ :       str=True,lowercase_ :       int=0.1,lowercase_ :       List[Any]=0.1,lowercase_ :       List[Any]=True,lowercase_ :       Union[str, Any]=True,lowercase_ :       Any=None,**lowercase_ :       List[Any],)->    Tuple:





        '''simple docstring'''







        A__          =   vocab_size
        A__          =   max_position_embeddings
        A__          =   hidden_size
        A__          =   intermediate_size
        A__          =   num_hidden_layers
        A__          =   num_attention_heads
        A__          =   hidden_act
        A__          =   initializer_range
        A__          =   rms_norm_eps
        A__          =   use_cache
        A__          =   kwargs.pop(
            'use_memorry_efficient_attention',lowercase_		)
        A__          =   hidden_dropout_prob
        A__          =   attention_dropout_prob
        A__          =   use_stable_embedding
        A__          =   shared_input_output_embedding
        A__          =   rope_scaling
        self._rope_scaling_validation()

        super().__init__(
            pad_token_id=lowercase_,bos_token_id=lowercase_,eos_token_id=lowercase_,tie_word_embeddings=lowercase_,**lowercase_,)


    def 						snake_case__     (      self :       str		)->    str:





        '''simple docstring'''







        if self.rope_scaling is None:
            return

        if not isinstance(self.rope_scaling,lowercase_		) or len(self.rope_scaling		) != 2:
            raise ValueError(
                '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, '
                F'got {self.rope_scaling}'		)
        A__          =   self.rope_scaling.get('type',lowercase_		)
        A__          =   self.rope_scaling.get('factor',lowercase_		)
        if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
            raise ValueError(
                F'`rope_scaling`\'s name field must be one of [\'linear\', \'dynamic\'], got {rope_scaling_type}'		)
        if rope_scaling_factor is None or not isinstance(lowercase_,lowercase_		) or rope_scaling_factor <= 1.0:
            raise ValueError(F'`rope_scaling`\'s factor field must be an float > 1, got {rope_scaling_factor}'		)

