"""simple docstring"""



from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

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

def  _A(		lowerCAmelCase							):
							A__       :     List[Any]								=			script.contents[0]
							A__       :     Dict								=			json.loads(data[data.find("""{\"config\""""							) : -1]							)
							return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]
class 						__UpperCAmelCase    :







			'''simple docstring'''





			def __init__(			self   ,      snake_case_							):







										'''simple docstring'''


										A__       :     str								=			F'''https://www.instagram.com/{username}/'''
										A__       :     Optional[int]								=			self.get_json()





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			requests.get(self.url   ,      headers=snake_case_							).text
										A__       :     Optional[int]								=			BeautifulSoup(snake_case_   ,      """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							):







										'''simple docstring'''


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





			def __str__(			self							):







										'''simple docstring'''


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





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["username"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["full_name"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["biography"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["business_email"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["external_url"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


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





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


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





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


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





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["profile_pic_url_hd"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["is_verified"]





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self.user_data["is_private"]





def  _A(		lowerCAmelCase = "github"							):
							import os

							if os.environ.get("""CI"""							):
														return  # test failing on GitHub Actions
							A__       :     Dict								=			InstagramUser(lowerCAmelCase							)
							assert instagram_user.user_data
							assert isinstance(instagram_user.user_data			,  lowerCAmelCase							)
							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 = }')






"""simple docstring"""



import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 						__UpperCAmelCase    (unittest.TestCase     ):







			'''simple docstring'''





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Dict								=			Vector([1, 2, 3]							)
										self.assertEqual(x.component(0							)   ,      1							)
										self.assertEqual(x.component(2							)   ,      3							)
										A__       :     List[Any]								=			Vector()





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			Vector([0, 0, 0, 0, 0, 1]							)
										self.assertEqual(str(snake_case_							)   ,      """(0,0,0,0,0,1)"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			Vector([1, 2, 3, 4]							)
										self.assertEqual(len(snake_case_							)   ,      4							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			Vector([1, 2]							)
										A__       :     Optional[int]								=			Vector([1, 2, 3, 4, 5]							)
										A__       :     Tuple								=			Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]							)
										A__       :     Dict								=			Vector([1, -1, 1, -1, 2, -3, 4, -5]							)
										self.assertAlmostEqual(x.euclidean_length()   ,      2.2_36   ,      3							)
										self.assertAlmostEqual(y.euclidean_length()   ,      7.4_16   ,      3							)
										self.assertEqual(z.euclidean_length()   ,      0							)
										self.assertAlmostEqual(w.euclidean_length()   ,      7.6_16   ,      3							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			Vector([1, 2, 3]							)
										A__       :     Any								=			Vector([1, 1, 1]							)
										self.assertEqual((x + y).component(0							)   ,      2							)
										self.assertEqual((x + y).component(1							)   ,      3							)
										self.assertEqual((x + y).component(2							)   ,      4							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[int]								=			Vector([1, 2, 3]							)
										A__       :     int								=			Vector([1, 1, 1]							)
										self.assertEqual((x - y).component(0							)   ,      0							)
										self.assertEqual((x - y).component(1							)   ,      1							)
										self.assertEqual((x - y).component(2							)   ,      2							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Tuple								=			Vector([1, 2, 3]							)
										A__       :     Any								=			Vector([2, -1, 4]							)  # for test of dot product
										A__       :     Optional[Any]								=			Vector([1, -2, -1]							)
										self.assertEqual(str(x * 3.0							)   ,      """(3.0,6.0,9.0)"""							)
										self.assertEqual((a * b)   ,      0							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.assertEqual(str(zero_vector(10							)							).count("""0"""							)   ,      10							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.assertEqual(str(unit_basis_vector(3   ,      1							)							)   ,      """(0,1,0)"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			Vector([1, 2, 3]							)
										A__       :     Tuple								=			Vector([1, 0, 1]							)
										self.assertEqual(str(axpy(2   ,      snake_case_   ,      snake_case_							)							)   ,      """(3,4,7)"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     int								=			Vector([1, 0, 0, 0, 0, 0]							)
										A__       :     List[str]								=			x.copy()
										self.assertEqual(str(snake_case_							)   ,      str(snake_case_							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     str								=			Vector([1, 0, 0]							)
										x.change_component(0   ,      0							)
										x.change_component(1   ,      1							)
										self.assertEqual(str(snake_case_							)   ,      """(0,1,0)"""							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										self.assertEqual("""|1,2,3|\n|2,4,5|\n|6,7,8|\n"""   ,      str(snake_case_							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										A__       :     Dict								=			[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
										for x in range(a.height()							):
																	for y in range(a.width()							):
																								self.assertEqual(minors[x][y]   ,      a.minor(snake_case_   ,      snake_case_							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[int]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										A__       :     Union[str, Any]								=			[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
										for x in range(a.height()							):
																	for y in range(a.width()							):
																								self.assertEqual(cofactors[x][y]   ,      a.cofactor(snake_case_   ,      snake_case_							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										self.assertEqual(-5   ,      a.determinant()							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[int]								=			Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]   ,      3   ,      3							)
										A__       :     int								=			Vector([1, 2, 3]							)
										self.assertEqual("""(14,32,50)"""   ,      str(a * x							)							)
										self.assertEqual("""|2,4,6|\n|8,10,12|\n|14,16,18|\n"""   ,      str(a * 2							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										a.change_component(0   ,      2   ,      5							)
										self.assertEqual("""|1,2,5|\n|2,4,5|\n|6,7,8|\n"""   ,      str(snake_case_							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										self.assertEqual(7   ,      a.component(2   ,      1							)   ,      0.01							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										A__       :     List[str]								=			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]   ,      3   ,      3							)
										self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""   ,      str(a + b							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,      3   ,      3							)
										A__       :     Tuple								=			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]   ,      3   ,      3							)
										self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""   ,      str(a - b							)							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.assertEqual(
										    """|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"""   ,      str(square_zero_matrix(5							)							)   ,      )


if __name__ == "__main__":
				unittest.main()





