




"""simple docstring"""




import argparse
import datetime



def 					a__				(       snake_case__       )		->      str:
			lowerCamelCase       =      {
			    """0""": """Sunday""",
			    """1""": """Monday""",
			    """2""": """Tuesday""",
			    """3""": """Wednesday""",
			    """4""": """Thursday""",
			    """5""": """Friday""",
			    """6""": """Saturday""",
			}

			lowerCamelCase       =      {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

			# Validate
			if not 0 < len(snake_case__       ) < 11:
						raise ValueError("""Must be 10 characters long"""       )

			# Get month
			lowerCamelCase       =      int(date_input[0] + date_input[1]       )
			# Validate
			if not 0 < m < 13:
						raise ValueError("""Month must be between 1 - 12"""       )

			lowerCamelCase       =      date_input[2]
			# Validate
			if sep_a not in ["-", "/"]:
						raise ValueError("""Date separator must be '-' or '/'"""       )

			# Get day
			lowerCamelCase       =      int(date_input[3] + date_input[4]       )
			# Validate
			if not 0 < d < 32:
						raise ValueError("""Date must be between 1 - 31"""       )

			# Get second separator
			lowerCamelCase       =      date_input[5]
			# Validate
			if sep_a not in ["-", "/"]:
						raise ValueError("""Date separator must be '-' or '/'"""       )

			# Get year
			lowerCamelCase       =      int(date_input[6] + date_input[7] + date_input[8] + date_input[9]       )
			# Arbitrary year range
			if not 45 < y < 85_00:
						raise ValueError(
						    """Year out of range. There has to be some sort of limit...right?"""       )

			# Get datetime obj for validation
			lowerCamelCase       =      datetime.date(int(snake_case__       ) ,				int(snake_case__       ) ,				int(snake_case__       )       )

			# Start math
			if m <= 2:
						lowerCamelCase       =      y - 1
						lowerCamelCase       =      m + 12
			# maths var
			lowerCamelCase       =      int(str(snake_case__       )[:2]       )
			lowerCamelCase       =      int(str(snake_case__       )[2:]       )
			lowerCamelCase       =      int(2.6 * m - 5.39       )
			lowerCamelCase       =      int(c / 4       )
			lowerCamelCase       =      int(k / 4       )
			lowerCamelCase       =      int(d + k       )
			lowerCamelCase       =      int(t + u + v + x       )
			lowerCamelCase       =      int(z - (2 * c)       )
			lowerCamelCase       =      round(w % 7       )
			# End math

			# Validate math
			if f != convert_datetime_days[dt_ck.weekday()]:
						raise AssertionError("""The date was evaluated incorrectly. Contact developer."""       )

			# Response
			lowerCamelCase       =      F'Your date {date_input}, is a {days[str(snake_case__       )]}!'
			return response


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					lowerCAmelCase							:    str  							=							argparse.ArgumentParser(
					    description=(
					        """Find out what day of the week nearly any date is or was. Enter """
					        """date as a string in the mm-dd-yyyy or mm/dd/yyyy format"""
					    )
					)
					parser.add_argument(
					    """date_input""", type=str, help="""Date as a string (mm-dd-yyyy or mm/dd/yyyy)"""
					)
					lowerCAmelCase							:    Dict  							=							parser.parse_args()
					zeller(args.date_input)









"""simple docstring"""




from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

lowerCAmelCase							:    List[Any]  							=							{"""UserAgent""": UserAgent().random}



def 					a__				(       snake_case__       )		->      dict:
			lowerCamelCase       =      script.contents[0]
			lowerCamelCase       =      json.loads(data[data.find("""{\"config\""""       ) : -1]       )
			return info["entry_data"]["ProfilePage"][0]["graphql"]["user"]






class 					__magic_name__							:






				'''simple docstring'''





				def __init__( self	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      f'https://www.instagram.com/{username}/'
							lowerCamelCase       =      self.get_json()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      requests.get(self.url	,				headers=_a				).text
							lowerCamelCase       =      BeautifulSoup(_a	,				"""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__				(       snake_case__ = "github"       )		->      None:
			import os

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



