

from __future__ import annotations

import random

# Maximum size of the population.  Bigger could be faster but is more memory expensive.
__A			:					str						=			2_0_0
# Number of elements selected in every generation of evolution. The selection takes
# place from best to worst of that generation and must be smaller than N_POPULATION.
__A			:					List[Any]						=			5_0
# Probability that an element of a generation can mutate, changing one of its genes.
# This will guarantee that all genes will be used during evolution.
__A			:					Union[str, Any]						=			0.4
# Just a seed to improve randomness required by the algorithm.
random.seed(random.randint(0, 1_0_0_0))





def 	__a     (      A__			:  str			,  A__			:  str       ):
    SCREAMING_SNAKE_CASE										=   len([g for position, g in enumerate(A__       ) if g == main_target[position]]       )
    return (item, float(A__       ))





def 	__a     (      A__			:  str			,  A__			:  str       ):
    SCREAMING_SNAKE_CASE										=   random.randint(0			,  len(A__       ) - 1       )
    SCREAMING_SNAKE_CASE										=   parent_a[:random_slice] + parent_a[random_slice:]
    SCREAMING_SNAKE_CASE										=   parent_a[:random_slice] + parent_a[random_slice:]
    return (child_a, child_a)





def 	__a     (      A__			:  str			,  A__			:  list[str]       ):
    SCREAMING_SNAKE_CASE										=   list(A__       )
    if random.uniform(0			,  1       ) < MUTATION_PROBABILITY:
        SCREAMING_SNAKE_CASE										=   random.choice(A__       )
    return "".join(A__       )





def 	__a     (      A__			:  tuple[str, float]			,  A__			:  list[tuple[str, float]]			,  A__			:  list[str]			,  ):
    SCREAMING_SNAKE_CASE										=   []
    # Generate more children proportionally to the fitness score.
    SCREAMING_SNAKE_CASE										=   int(parent_a[1] * 100       ) + 1
    SCREAMING_SNAKE_CASE										=   10 if child_n >= 10 else child_n
    for _ in range(A__       ):
        SCREAMING_SNAKE_CASE										=   population_score[random.randint(0			,  A__       )][0]

        SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   crossover(parent_a[0]			,  A__       )
        # Append new string to the population list.
        pop.append(mutate(A__			,  A__       )       )
        pop.append(mutate(A__			,  A__       )       )
    return pop





def 	__a     (      A__			:  str			,  A__			:  list[str]			,  A__			:  bool = True       ):

    # Verify if N_POPULATION is bigger than N_SELECTED
    if N_POPULATION < N_SELECTED:
        SCREAMING_SNAKE_CASE										=   F"{N_POPULATION} must be bigger than {N_SELECTED}"
        raise ValueError(A__       )
    # Verify that the target contains no genes besides the ones inside genes variable.
    SCREAMING_SNAKE_CASE										=   sorted({c for c in target if c not in genes}       )
    if not_in_genes_list:
        SCREAMING_SNAKE_CASE										=   F"{not_in_genes_list} is not in genes list, evolution cannot converge"
        raise ValueError(A__       )

    # Generate random starting population.
    SCREAMING_SNAKE_CASE										=   []
    for _ in range(A__       ):
        population.append("".join([random.choice(A__       ) for i in range(len(A__       )       )]       )       )

    # Just some logs to know what the algorithms is doing.
    SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   0, 0

    # This loop will end when we find a perfect match for our target.
    while True:
        generation += 1
        total_population += len(A__       )

        # Random population created. Now it's time to evaluate.

        # Adding a bit of concurrency can make everything faster,
        #
        # import concurrent.futures
        # population_score: list[tuple[str, float]] = []
        # with concurrent.futures.ThreadPoolExecutor(
        #                                   max_workers=NUM_WORKERS) as executor:
        #     futures = {executor.submit(evaluate, item) for item in population}
        #     concurrent.futures.wait(futures)
        #     population_score = [item.result() for item in futures]
        #
        # but with a simple algorithm like this, it will probably be slower.
        # We just need to call evaluate for every item inside the population.
        SCREAMING_SNAKE_CASE										=   [evaluate(A__			,  A__       ) for item in population]

        # Check if there is a matching evolution.
        SCREAMING_SNAKE_CASE										=   sorted(A__			,  key=lambda A__       : x[1]			,  reverse=A__       )
        if population_score[0][0] == target:
            return (generation, total_population, population_score[0][0])

        # Print the best result every 10 generation.
        # Just to know that the algorithm is working.
        if debug and generation % 10 == 0:
            print(
                F"\nGeneration: {generation}"
                F"\nTotal Population:{total_population}"
                F"\nBest score: {population_score[0][1]}"
                F"\nBest string: {population_score[0][0]}"       )

        # Flush the old population, keeping some of the best evolutions.
        # Keeping this avoid regression of evolution.
        SCREAMING_SNAKE_CASE										=   population[: int(N_POPULATION / 3       )]
        population.clear()
        population.extend(A__       )
        # Normalize population score to be between 0 and 1.
        SCREAMING_SNAKE_CASE										=   [
            (item, score / len(A__       )) for item, score in population_score
        ]

        # This is selection
        for i in range(A__       ):
            population.extend(select(population_score[int(A__       )]			,  A__			,  A__       )       )
            # Check if the population has already reached the maximum value and if so,
            # break the cycle.  If this check is disabled, the algorithm will take
            # forever to compute large strings, but will also calculate small strings in
            # a far fewer generations.
            if len(A__       ) > N_POPULATION:
                break


if __name__ == "__main__":
    __A			:					Optional[Any]						=			(
        'This is a genetic algorithm to evaluate, combine, evolve, and mutate a string!'
    )
    __A			:					int						=			list(
        ' ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm'
        'nopqrstuvwxyz.,;!?+-*#@^\'èéòà€ù=)(&%$£/\\'
    )
    __A			, __A			, __A			:					Dict						=			basic(target_str, genes_list)
    print(
        f'\nGeneration: {generation}\nTotal Population: {population}\nTarget: {target}'
    )


from __future__ import annotations

import json

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

__A			:					List[Any]						=			{'UserAgent': UserAgent().random}





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





class 			_SCREAMING_SNAKE_CASE :







   '''simple docstring'''




   def __init__(       self					:			List[str]     , __lowerCamelCase					:			Optional[Any]			):
       SCREAMING_SNAKE_CASE										=   f"https://www.instagram.com/{username}/"
       SCREAMING_SNAKE_CASE										=   self.get_json()





   def      _snake_case		(       self					:			Tuple			):
       SCREAMING_SNAKE_CASE										=   requests.get(self.url     , headers=__lowerCamelCase			).text
       SCREAMING_SNAKE_CASE										=   BeautifulSoup(__lowerCamelCase     , "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]			):
       return f"{self.__class__.__name__}('{self.username}')"





   def __str__(       self					:			str			):
       return f"{self.fullname} ({self.username}) is {self.biography}"





   @property
   def      _snake_case		(       self					:			Optional[int]			):
       return self.user_data["username"]





   @property
   def      _snake_case		(       self					:			List[Any]			):
       return self.user_data["full_name"]





   @property
   def      _snake_case		(       self					:			List[str]			):
       return self.user_data["biography"]





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





   @property
   def      _snake_case		(       self					:			Optional[Any]			):
       return self.user_data["external_url"]





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





   @property
   def      _snake_case		(       self					:			List[str]			):
       return self.user_data["edge_follow"]["count"]





   @property
   def      _snake_case		(       self					:			List[Any]			):
       return self.user_data["edge_owner_to_timeline_media"]["count"]





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





   @property
   def      _snake_case		(       self					:			Optional[int]			):
       return self.user_data["is_verified"]





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





def 	__a     (      A__			:  str = "github"       ):
    import os

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