Example #1
0
def interact_with_user(device,
                       user_source,
                       username,
                       my_username,
                       interaction_strategy: InteractionStrategy,
                       on_action) -> (bool, bool):
    """
    :return: (whether some photos was liked, whether @username was followed during the interaction)
    """
    global liked_count, is_followed
    liked_count = 0
    is_followed = False
    is_watched = False

    if username == my_username:
        print("It's you, skip.")
        return liked_count == interaction_strategy.likes_count, is_followed, is_watched

    sleeper.random_sleep()

    if interaction_strategy.do_story_watch:
        is_watched = _watch_stories(device, username, interaction_strategy.stories_count, on_action)

    coordinator_layout = device.find(resourceId=f'{device.app_id}:id/coordinator_root_layout')
    if coordinator_layout.exists():
        print("Scroll down to see more photos.")
        coordinator_layout.scroll(DeviceFacade.Direction.BOTTOM)

    if interaction_strategy.do_like:
        number_of_rows_to_use = min((interaction_strategy.likes_count * 2) // 3 + 1, 4)
        photos_indices = list(range(0, number_of_rows_to_use * 3))
        shuffle(photos_indices)
        photos_indices = photos_indices[:interaction_strategy.likes_count]
        photos_indices = sorted(photos_indices)

        def on_like():
            global liked_count
            liked_count += 1
            print(COLOR_OKGREEN + "@{} - photo been liked.".format(username) + COLOR_ENDC)
            on_action(LikeAction(source=user_source, user=username))

        for i in range(0, interaction_strategy.likes_count):
            photo_index = photos_indices[i]
            row = photo_index // 3
            column = photo_index - row * 3

            sleeper.random_sleep()
            print("Open and like photo #" + str(i + 1) + " (" + str(row + 1) + " row, " + str(column + 1) + " column)")
            if not _open_photo_and_like(device, row, column, interaction_strategy.like_percentage, on_like):
                print(COLOR_OKGREEN + "Less than " + str(number_of_rows_to_use * 3) + " photos." + COLOR_ENDC)
                break

    if interaction_strategy.do_follow:
        is_followed = _follow(device, username, interaction_strategy.follow_percentage)
        if is_followed:
            print(COLOR_OKGREEN + "Following @{}.".format(username) + COLOR_ENDC)
            on_action(FollowAction(source=user_source, user=username))

    return liked_count > 0, is_followed, is_watched
Example #2
0
 def do_follow_action():
     global is_followed
     if interaction_strategy.do_follow:
         is_followed = _follow(device, username,
                               interaction_strategy.follow_percentage,
                               is_scrolled_down)
         if is_followed:
             on_action(FollowAction(source=user_source, user=username))
    def interact_with_profile(liker_username, liker_username_view):
        """
        :return: whether we should continue interaction with other users after this one
        """
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source_name=place, source_type=source_type, user=liker_username, succeed=True), session_state)

        if not process_limits(
                is_interact_limit_reached, interact_reached_session_limit,
                interact_reached_source_limit, action_status, "Interaction"):
            return False

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=liker_username), session_state)

        if not process_limits(is_get_profile_limit_reached,
                              get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status,
                              "Get-Profile"):
            return False

        is_all_filters_satisfied = False
        if is_passed_filters is not None:
            print_debug(f"Running filter-ahead on @{liker_username}")
            should_continue, is_all_filters_satisfied = is_passed_filters(
                device,
                liker_username,
                reset=True,
                filters_tags=['BEFORE_PROFILE_CLICK'])
            if not should_continue:
                on_action(FilterAction(liker_username))
                return True

            if not is_all_filters_satisfied:
                print_debug(
                    "Not all filters are satisfied with filter-ahead, continue filtering inside the profile-page"
                )

        print("@" + liker_username + ": interact")
        liker_username_view.click()
        on_action(GetProfileAction(user=liker_username))

        sleeper.random_sleep()
        is_profile_empty = softban_indicator.detect_empty_profile(device)

        if is_profile_empty:
            print("Back to likers list")
            device.back()
            return True

        if is_passed_filters is not None:
            if not is_all_filters_satisfied:
                should_continue, _ = is_passed_filters(device,
                                                       liker_username,
                                                       reset=False)
                if not should_continue:
                    on_action(FilterAction(liker_username))
                    # Continue to next follower
                    print("Back to likers list")
                    device.back()
                    return True

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source_name=place, source_type=source_type, user=liker_username), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source_name=place, source_type=source_type, user=liker_username), session_state)

        is_watch_limit_reached, watch_reached_source_limit, watch_reached_session_limit = \
            is_limit_reached(StoryWatchAction(source_name=place, source_type=source_type, user=liker_username), session_state)

        is_comment_limit_reached, comment_reached_source_limit, comment_reached_session_limit = \
            is_limit_reached(CommentAction(source_name=place, source_type=source_type, user=liker_username, comment=""), session_state)

        is_private = is_private_account(device)
        if is_private:
            if is_passed_filters is None:
                print(COLOR_OKGREEN + "@" + liker_username +
                      " has private account, won't interact." + COLOR_ENDC)
                on_action(FilterAction(liker_username))
                on_action(
                    InteractAction(source_name=place,
                                   source_type=source_type,
                                   user=liker_username,
                                   succeed=False))
                print("Back to likers list")
                device.back()
                return True
            print("@" + liker_username +
                  ": Private account - images wont be liked.")

        do_have_stories = do_have_story(device)
        if not do_have_stories:
            print("@" + liker_username +
                  ": seems there are no stories to be watched.")

        is_likes_enabled = likes_count != '0'
        is_stories_enabled = stories_count != '0'
        is_follow_enabled = follow_percentage != 0
        is_comment_enabled = comment_percentage != 0

        likes_value = get_value(likes_count,
                                "Likes count: {}",
                                2,
                                max_count=12)
        stories_value = get_value(stories_count, "Stories to watch: {}", 1)

        can_like = not is_like_limit_reached and not is_private and likes_value > 0
        can_follow = (
            not is_follow_limit_reached
        ) and storage.get_following_status(
            liker_username) == FollowingStatus.NONE and follow_percentage > 0
        can_watch = (not is_watch_limit_reached
                     ) and do_have_stories and stories_value > 0
        can_comment = (not is_comment_limit_reached
                       ) and not is_private and comment_percentage > 0
        can_interact = can_like or can_follow or can_watch or can_comment

        if not can_interact:
            print(
                "@" + liker_username +
                ": Cant be interacted (due to limits / already followed). Skip."
            )
            on_action(
                InteractAction(source_name=place,
                               source_type=source_type,
                               user=liker_username,
                               succeed=False))
        else:
            print_interaction_types(liker_username, can_like, can_follow,
                                    can_watch, can_comment)
            interaction_strategy = InteractionStrategy(
                do_like=can_like,
                do_follow=can_follow,
                do_story_watch=can_watch,
                do_comment=can_comment,
                likes_count=likes_value,
                follow_percentage=follow_percentage,
                like_percentage=like_percentage,
                stories_count=stories_value,
                comment_percentage=comment_percentage,
                comments_list=comments_list)

            is_liked, is_followed, is_watch, is_commented = interaction(
                username=liker_username,
                interaction_strategy=interaction_strategy)
            if is_liked or is_followed or is_watch or is_commented:
                on_action(
                    InteractAction(source_name=place,
                                   source_type=source_type,
                                   user=liker_username,
                                   succeed=True))
                print_short_report(f"P-{place}", session_state)
            else:
                on_action(
                    InteractAction(source_name=place,
                                   source_type=source_type,
                                   user=liker_username,
                                   succeed=False))

        can_continue = True

        if ((is_like_limit_reached and is_likes_enabled) or not is_likes_enabled) and \
           ((is_follow_limit_reached and is_follow_enabled) or not is_follow_enabled) and \
           ((is_comment_limit_reached and is_comment_enabled) or not is_comment_enabled) and \
           ((is_watch_limit_reached and is_stories_enabled) or not is_stories_enabled):
            # If one of the limits reached for source-limit, move to next source
            if (like_reached_source_limit is not None and like_reached_session_limit is None) or \
                    (follow_reached_source_limit is not None and follow_reached_session_limit is None):
                can_continue = False
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If all of the limits reached for session-limit, finish the session
            if ((like_reached_session_limit is not None and is_likes_enabled) or not is_likes_enabled) and \
                    ((follow_reached_session_limit is not None and is_follow_enabled) or not is_follow_enabled):
                can_continue = False
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Back to followers list")
        device.back()

        return can_continue
Example #4
0
    def interact_with_follower(follower_name, follower_name_view):
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source=username, user=follower_name, succeed=True), session_state)

        if not process_limits(is_interact_limit_reached, interact_reached_session_limit,
                              interact_reached_source_limit, action_status, "Interaction"):
            return False

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=follower_name), session_state)

        if not process_limits(is_get_profile_limit_reached, get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status, "Get-Profile"):
            return False

        print("@" + follower_name + ": interact")
        follower_name_view.click()
        on_action(GetProfileAction(user=follower_name))

        sleeper.random_sleep()
        is_profile_empty = softban_indicator.detect_empty_profile(device)

        if is_profile_empty:
            print("Back to followers list")
            device.back()
            return True

        follower_profile_view = ProfileView(device, follower_name == session_state.my_username)

        if is_passed_filters is not None:
            if not is_passed_filters(device, follower_name, reset=False):
                storage.add_filtered_user(follower_name)
                # Continue to next follower
                print("Back to profiles list")
                device.back()
                return True

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source=username, user=follower_name), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source=username, user=follower_name), session_state)

        is_watch_limit_reached, watch_reached_source_limit, watch_reached_session_limit = \
            is_limit_reached(StoryWatchAction(user=follower_name), session_state)

        is_private = follower_profile_view.is_private_account()
        if is_private:
            print("@" + follower_name + ": Private account - images wont be liked.")

        do_have_stories = follower_profile_view.is_story_available()
        if not do_have_stories:
            print("@" + follower_name + ": seems there are no stories to be watched.")

        is_likes_enabled = likes_count != '0'
        is_stories_enabled = stories_count != '0'
        is_follow_enabled = follow_percentage != 0

        likes_value = get_value(likes_count, "Likes count: {}", 2, max_count=12)
        stories_value = get_value(stories_count, "Stories to watch: {}", 1)

        can_like = not is_like_limit_reached and not is_private and likes_value > 0
        can_follow = (not is_follow_limit_reached) and storage.get_following_status(follower_name) == FollowingStatus.NONE and follow_percentage > 0
        can_watch = (not is_watch_limit_reached) and do_have_stories and stories_value > 0
        can_interact = can_like or can_follow or can_watch

        if not can_interact:
            print("@" + follower_name + ": Cant be interacted (due to limits / already followed). Skip.")
            storage.add_interacted_user(follower_name,
                                        followed=False,
                                        source=f"@{username}",
                                        interaction_type=instructions.value,
                                        provider=Provider.INTERACTION)
            on_action(InteractAction(source=username, user=follower_name, succeed=False))
        else:
            print_interaction_types(follower_name, can_like, can_follow, can_watch)
            interaction_strategy = InteractionStrategy(do_like=can_like,
                                                       do_follow=can_follow,
                                                       do_story_watch=can_watch,
                                                       likes_count=likes_value,
                                                       follow_percentage=follow_percentage,
                                                       like_percentage=like_percentage,
                                                       stories_count=stories_value)

            is_liked, is_followed, is_watch = interaction(username=follower_name, interaction_strategy=interaction_strategy)
            if is_liked or is_followed or is_watch:
                storage.add_interacted_user(follower_name,
                                            followed=is_followed,
                                            source=f"@{username}",
                                            interaction_type=instructions.value,
                                            provider=Provider.INTERACTION)
                on_action(InteractAction(source=username, user=follower_name, succeed=True))
                print_short_report(username, session_state)
            else:
                storage.add_interacted_user(follower_name,
                                            followed=False,
                                            source=f"@{username}",
                                            interaction_type=instructions.value,
                                            provider=Provider.INTERACTION)
                on_action(InteractAction(source=username, user=follower_name, succeed=False))

        can_continue = True

        if ((is_like_limit_reached and is_likes_enabled) or not is_likes_enabled) and \
           ((is_follow_limit_reached and is_follow_enabled) or not is_follow_enabled) and \
           ((is_watch_limit_reached and is_stories_enabled) or not is_stories_enabled):
            # If one of the limits reached for source-limit, move to next source
            if (like_reached_source_limit is not None and like_reached_session_limit is None) or \
               (follow_reached_source_limit is not None and follow_reached_session_limit is None):
                can_continue = False
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If all of the limits reached for session-limit, finish the session
            if ((like_reached_session_limit is not None and is_likes_enabled) or not is_likes_enabled) and \
               ((follow_reached_session_limit is not None and is_follow_enabled) or not is_follow_enabled):
                can_continue = False
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Back to profiles list")
        device.back()

        return can_continue
Example #5
0
    def interact_with_target(target_name, target_name_view):
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source=target_name, user=target_name, succeed=True), session_state)

        if not process_limits(
                is_interact_limit_reached, interact_reached_session_limit,
                interact_reached_source_limit, action_status, "Interaction"):
            return

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=target_name), session_state)

        if not process_limits(is_get_profile_limit_reached,
                              get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status,
                              "Get-Profile"):
            return

        print("@" + target_name + ": interact")

        if is_passed_filters is not None:
            if not is_all_filters_satisfied:
                should_continue, _ = is_passed_filters(device,
                                                       target_name,
                                                       reset=False)
                if not should_continue:
                    storage.add_filtered_user(target_name)
                    print("Moving to next target")
                    return

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source=target_name, user=target_name), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source=target_name, user=target_name), session_state)

        is_watch_limit_reached, watch_reached_source_limit, watch_reached_session_limit = \
            is_limit_reached(StoryWatchAction(user=target_name), session_state)

        is_comment_limit_reached, comment_reached_source_limit, comment_reached_session_limit = \
            is_limit_reached(CommentAction(source=target_name, user=target_name, comment=""), session_state)

        is_private = is_private_account(device)
        if is_private:
            print("@" + target_name +
                  ": Private account - images wont be liked.")

        do_have_stories = do_have_story(device)
        if not do_have_stories:
            print("@" + target_name +
                  ": seems there are no stories to be watched.")

        is_likes_enabled = likes_count != '0'
        is_stories_enabled = stories_count != '0'
        is_follow_enabled = follow_percentage != 0
        is_comment_enabled = comment_percentage != 0

        likes_value = get_value(likes_count,
                                "Likes count: {}",
                                2,
                                max_count=12)
        stories_value = get_value(stories_count, "Stories to watch: {}", 1)

        can_like = not is_like_limit_reached and not is_private and likes_value > 0
        can_follow = (
            not is_follow_limit_reached) and storage.get_following_status(
                target_name) == FollowingStatus.NONE and follow_percentage > 0
        can_watch = (not is_watch_limit_reached
                     ) and do_have_stories and stories_value > 0
        can_comment = (not is_comment_limit_reached
                       ) and not is_private and comment_percentage > 0
        can_interact = can_like or can_follow or can_watch or can_comment

        if not can_interact:
            print(
                "@" + target_name +
                ": Cant be interacted (due to limits / already followed). Skip."
            )
            storage.add_interacted_user(target_name,
                                        followed=False,
                                        provider=provider)
            on_action(
                InteractAction(source=target_name,
                               user=target_name,
                               succeed=False))
        else:
            print_interaction_types(target_name, can_like, can_follow,
                                    can_watch, can_comment)
            interaction_strategy = InteractionStrategy(
                do_like=can_like,
                do_follow=can_follow,
                do_story_watch=can_watch,
                do_comment=can_comment,
                likes_count=likes_value,
                follow_percentage=follow_percentage,
                like_percentage=like_percentage,
                stories_count=stories_value,
                comment_percentage=comment_percentage,
                comments_list=comments_list)

            is_liked, is_followed, is_watch, is_commented = interaction(
                username=target_name,
                interaction_strategy=interaction_strategy)
            if is_liked or is_followed or is_watch or is_commented:
                storage.add_interacted_user(target_name,
                                            followed=is_followed,
                                            provider=provider)
                on_action(
                    InteractAction(source=target_name,
                                   user=target_name,
                                   succeed=True))
                print_short_report(target_name, session_state)
            else:
                storage.add_interacted_user(target_name,
                                            followed=False,
                                            provider=provider)
                on_action(
                    InteractAction(source=target_name,
                                   user=target_name,
                                   succeed=False))

        if ((is_like_limit_reached and is_likes_enabled) or not is_likes_enabled) and \
           ((is_follow_limit_reached and is_follow_enabled) or not is_follow_enabled) and \
           ((is_comment_limit_reached and is_comment_enabled) or not is_comment_enabled) and \
           ((is_watch_limit_reached and is_stories_enabled) or not is_stories_enabled):
            # If one of the limits reached for source-limit, move to next source
            if (like_reached_source_limit is not None and like_reached_session_limit is None) or \
                    (follow_reached_source_limit is not None and follow_reached_session_limit is None):
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If all of the limits reached for session-limit, finish the session
            if ((like_reached_session_limit is not None and is_likes_enabled) or not is_likes_enabled) and \
                    ((follow_reached_session_limit is not None and is_follow_enabled) or not is_follow_enabled):
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Moving to next target")
        return
    def interact_with_liker(liker_username, liker_username_view):
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source=interaction_source, user=liker_username, succeed=True), session_state)

        if not process_limits(
                is_interact_limit_reached, interact_reached_session_limit,
                interact_reached_source_limit, action_status, "Interaction"):
            return False

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=liker_username), session_state)

        if not process_limits(is_get_profile_limit_reached,
                              get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status,
                              "Get-Profile"):
            return False

        print("@" + liker_username + ": interact")
        liker_username_view.click()
        on_action(GetProfileAction(user=liker_username))

        if is_passed_filters is not None:
            if not is_passed_filters(device, liker_username):
                # Continue to next follower
                print("Back to followers list")
                device.back()
                return True

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source=interaction_source, user=liker_username), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source=interaction_source, user=liker_username), session_state)

        is_watch_limit_reached, watch_reached_source_limit, watch_reached_session_limit = \
            is_limit_reached(StoryWatchAction(user=liker_username), session_state)

        is_private = is_private_account(device)
        if is_private:
            print("@" + liker_username +
                  ": Private account - images wont be liked.")

        do_have_stories = do_have_story(device)
        if not do_have_stories:
            print("@" + liker_username +
                  ": seems there are no stories to be watched.")

        likes_value = get_value(likes_count,
                                "Likes count: {}",
                                2,
                                max_count=12)
        stories_value = get_value(stories_count, "Stories to watch: {}", 1)

        can_like = not is_like_limit_reached and not is_private and likes_value > 0
        can_follow = (
            not is_follow_limit_reached
        ) and storage.get_following_status(
            liker_username) == FollowingStatus.NONE and follow_percentage > 0
        can_watch = (not is_watch_limit_reached
                     ) and do_have_stories and stories_value > 0
        can_interact = can_like or can_follow

        if not can_interact:
            print(
                "@" + liker_username +
                ": Cant be interacted (due to limits / already followed). Skip."
            )
            storage.add_interacted_user(liker_username, followed=False)
            on_action(
                InteractAction(source=interaction_source,
                               user=liker_username,
                               succeed=False))
        else:
            print_interaction_types(liker_username, can_like, can_follow,
                                    can_watch)
            interaction_strategy = InteractionStrategy(
                do_like=can_like,
                do_follow=can_follow,
                do_story_watch=can_watch,
                likes_count=likes_value,
                follow_percentage=follow_percentage,
                stories_count=stories_value)

            is_liked, is_followed, is_watch = interaction(
                username=liker_username,
                interaction_strategy=interaction_strategy)
            if is_liked or is_followed or is_watch:
                storage.add_interacted_user(liker_username,
                                            followed=is_followed)
                on_action(
                    InteractAction(source=interaction_source,
                                   user=liker_username,
                                   succeed=True))
                print_short_report(interaction_source, session_state)
            else:
                storage.add_interacted_user(liker_username, followed=False)
                on_action(
                    InteractAction(source=interaction_source,
                                   user=liker_username,
                                   succeed=False))

        can_continue = True

        if is_like_limit_reached and is_follow_limit_reached and is_watch_limit_reached:
            # If one of the limits reached for source-limit, move to next source
            if like_reached_source_limit is not None or \
                    follow_reached_source_limit is not None or \
                    watch_reached_source_limit is not None:
                can_continue = False
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If all of the limits reached for session-limit, finish the session
            if like_reached_session_limit is not None and \
                    follow_reached_session_limit is not None and \
                    watch_reached_session_limit is not None:
                can_continue = False
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Back to followers list")
        device.back()

        return can_continue
    def interact_with_liker(liker_username, liker_username_view):
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source=interaction_source, user=liker_username, succeed=True), session_state)

        if not process_limits(
                is_interact_limit_reached, interact_reached_session_limit,
                interact_reached_source_limit, action_status, "Interaction"):
            return False

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=liker_username), session_state)

        if not process_limits(is_get_profile_limit_reached,
                              get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status,
                              "Get-Profile"):
            return False

        print("@" + liker_username + ": interact")
        liker_username_view.click()
        on_action(GetProfileAction(user=liker_username))

        if is_passed_filters is not None:
            if not is_passed_filters(device, liker_username):
                # Continue to next follower
                print("Back to followers list")
                device.back()
                return True

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source=interaction_source, user=liker_username), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source=interaction_source, user=liker_username), session_state)

        is_private = is_private_account(device)
        if is_private:
            print("@" + liker_username +
                  ": Private account - images wont be liked.")

        can_like = not is_like_limit_reached and not is_private
        can_follow = (
            not is_follow_limit_reached) and storage.get_following_status(
                liker_username) == FollowingStatus.NONE
        can_interact = can_like or can_follow

        if not can_interact:
            print(
                "@" + liker_username +
                ": Cant be interacted (due to limits / already followed). Skip."
            )
        else:
            print("@" + liker_username +
                  "interaction: going to {}{}{}.".format(
                      "like" if can_like else "", " and " if can_like
                      and can_follow else "", "follow" if can_follow else ""))

            interaction_strategy = InteractionStrategy(
                do_like=can_like,
                do_follow=can_follow,
                likes_count=likes_count,
                follow_percentage=follow_percentage)

            is_liked, is_followed = interaction(
                username=liker_username,
                interaction_strategy=interaction_strategy)
            if is_liked or is_followed:
                storage.add_interacted_user(liker_username,
                                            followed=is_followed)
                on_action(
                    InteractAction(source=interaction_source,
                                   user=liker_username,
                                   succeed=True))
            else:
                on_action(
                    InteractAction(source=interaction_source,
                                   user=liker_username,
                                   succeed=False))

        can_continue = True

        if is_like_limit_reached and is_follow_limit_reached:
            # If ont of the limits reached for source-limit, move to next source
            if like_reached_source_limit is not None or follow_reached_source_limit is not None:
                can_continue = False
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If both of the limits reached for session-limit, finish the session
            if like_reached_session_limit is not None and follow_reached_session_limit is not None:
                can_continue = False
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Back to followers list")
        device.back()

        return can_continue
Example #8
0
    def interact_with_follower(follower_name, follower_name_view):
        """
        :return: whether we should continue interaction with other users after this one
        """
        is_interact_limit_reached, interact_reached_source_limit, interact_reached_session_limit = \
            is_limit_reached(InteractAction(source_name=username, source_type=source_type, user=follower_name, succeed=True), session_state)

        if not process_limits(
                is_interact_limit_reached, interact_reached_session_limit,
                interact_reached_source_limit, action_status, "Interaction"):
            return False

        is_get_profile_limit_reached, get_profile_reached_source_limit, get_profile_reached_session_limit = \
            is_limit_reached(GetProfileAction(user=follower_name), session_state)

        if not process_limits(is_get_profile_limit_reached,
                              get_profile_reached_session_limit,
                              get_profile_reached_source_limit, action_status,
                              "Get-Profile"):
            return False

        is_all_filters_satisfied = False
        if is_passed_filters is not None:
            print_debug(f"Running filter-ahead on @{follower_name}")
            should_continue, is_all_filters_satisfied = is_passed_filters(
                device,
                follower_name,
                reset=True,
                filters_tags=['BEFORE_PROFILE_CLICK'])
            if not should_continue:
                on_action(FilterAction(user=follower_name))
                return True

            if not is_all_filters_satisfied:
                print_debug(
                    "Not all filters are satisfied with filter-ahead, continue filtering inside the profile-page"
                )

        print("@" + follower_name + ": interact")
        follower_name_view.click()
        on_action(GetProfileAction(user=follower_name))

        post_count = None
        followers_count = None
        following_count = None

        post_count_el = device.find(
            resourceId=
            'com.instagram.android:id/row_profile_header_textview_post_count',
            className='android.widget.TextView')
        if post_count_el.exists():
            post_count = to_int(post_count_el.get_text())

        followers_count_el = device.find(
            resourceId=
            'com.instagram.android:id/row_profile_header_textview_followers_count',
            className='android.widget.TextView')
        if followers_count_el.exists():
            followers_count = to_int(followers_count_el.get_text())

        following_count_el = device.find(
            resourceId=
            'com.instagram.android:id/row_profile_header_textview_following_count',
            className='android.widget.TextView')
        if following_count_el.exists():
            following_count = to_int(following_count_el.get_text())

        print("@%s (PC=%s ERS=%s ING=%s): interact" %
              (follower_name, post_count, followers_count, following_count))

        with open('filters.json') as json_file:
            filterz = json.load(json_file)
        json_file.close()

        skip = False
        if post_count and post_count < filterz['min_posts']:
            skip = True
            print('Skip because of %s < min_posts' % post_count)
        if not skip and followers_count and followers_count < filterz[
                'min_followers']:
            skip = True
            print('Skip because of %s < min_followers' % followers_count)
        if not skip and followers_count and followers_count > filterz[
                'max_followers']:
            skip = True
            print('Skip because of %s > max_followers' % followers_count)
        if not skip and followers_count and following_count and followers_count / (
                following_count + 1) < filterz['min_potency_ratio']:
            skip = True
            print('Skip because of %s < min_potency_ratio' %
                  (followers_count / (following_count + 1)))
        if not skip and followers_count and following_count and followers_count / (
                following_count + 1) > filterz['max_potency_ratio']:
            skip = True
            print('Skip because of %s > max_potency_ratio' %
                  (followers_count / (following_count + 1)))
        if not skip and not filterz[
                'follow_private_or_empty'] and is_private_account(device):
            skip = True
            print('Skipping private account')

        if skip:
            on_action(FilterAction(user=follower_name))
            # Continue to next follower
            device.back()
            return True

        sleeper.random_sleep()
        is_profile_empty = softban_indicator.detect_empty_profile(device)

        if is_profile_empty:
            print("Back to followers list")
            device.back()
            return True

        follower_profile_view = ProfileView(
            device, follower_name == session_state.my_username)

        if is_passed_filters is not None:
            if not is_all_filters_satisfied:
                should_continue, _ = is_passed_filters(device,
                                                       follower_name,
                                                       reset=False)
                if not should_continue:
                    on_action(FilterAction(user=follower_name))
                    # Continue to next follower
                    print("Back to profiles list")
                    device.back()
                    return True

        is_like_limit_reached, like_reached_source_limit, like_reached_session_limit = \
            is_limit_reached(LikeAction(source_name=username, source_type=source_type, user=follower_name), session_state)

        is_follow_limit_reached, follow_reached_source_limit, follow_reached_session_limit = \
            is_limit_reached(FollowAction(source_name=username, source_type=source_type, user=follower_name), session_state)

        is_watch_limit_reached, watch_reached_source_limit, watch_reached_session_limit = \
            is_limit_reached(StoryWatchAction(source_name=username, source_type=source_type,user=follower_name), session_state)

        is_comment_limit_reached, comment_reached_source_limit, comment_reached_session_limit = \
            is_limit_reached(CommentAction(source_name=username, source_type=source_type, user=follower_name, comment=""), session_state)

        is_private = follower_profile_view.is_private_account()
        if is_private:
            if is_passed_filters is None:
                print(COLOR_OKGREEN + "@" + follower_name +
                      " has private account, won't interact." + COLOR_ENDC)
                on_action(FilterAction(user=follower_name))
                on_action(
                    InteractAction(source_name=username,
                                   source_type=source_type,
                                   user=follower_name,
                                   succeed=False))
                print("Back to profiles list")
                device.back()
                return True
            print("@" + follower_name +
                  ": Private account - images wont be liked.")

        do_have_stories = follower_profile_view.is_story_available()
        if not do_have_stories:
            print("@" + follower_name +
                  ": seems there are no stories to be watched.")

        is_likes_enabled = likes_count != '0'
        is_stories_enabled = stories_count != '0'
        is_follow_enabled = follow_percentage != 0
        is_comment_enabled = comment_percentage != 0

        likes_value = get_value(likes_count,
                                "Likes count: {}",
                                2,
                                max_count=12)
        stories_value = get_value(stories_count, "Stories to watch: {}", 1)

        can_like = not is_like_limit_reached and not is_private and likes_value > 0
        can_follow = (
            not is_follow_limit_reached
        ) and storage.get_following_status(
            follower_name) == FollowingStatus.NONE and follow_percentage > 0
        can_watch = (not is_watch_limit_reached
                     ) and do_have_stories and stories_value > 0
        can_comment = (not is_comment_limit_reached
                       ) and not is_private and comment_percentage > 0
        can_interact = can_like or can_follow or can_watch or can_comment

        if not can_interact:
            print(
                "@" + follower_name +
                ": Cant be interacted (due to limits / already followed). Skip."
            )
            on_action(
                InteractAction(source_name=username,
                               source_type=source_type,
                               user=follower_name,
                               succeed=False))
        else:
            print_interaction_types(follower_name, can_like, can_follow,
                                    can_watch, can_comment)
            interaction_strategy = InteractionStrategy(
                do_like=can_like,
                do_follow=can_follow,
                do_story_watch=can_watch,
                do_comment=can_comment,
                likes_count=likes_value,
                follow_percentage=follow_percentage,
                like_percentage=like_percentage,
                stories_count=stories_value,
                comment_percentage=comment_percentage,
                comments_list=comments_list)

            is_liked, is_followed, is_watch, is_commented = interaction(
                username=follower_name,
                interaction_strategy=interaction_strategy)
            if is_liked or is_followed or is_watch or is_commented:
                on_action(
                    InteractAction(source_name=username,
                                   source_type=source_type,
                                   user=follower_name,
                                   succeed=True))
                print_short_report(f"@{username}", session_state)
            else:
                on_action(
                    InteractAction(source_name=username,
                                   source_type=source_type,
                                   user=follower_name,
                                   succeed=False))

        can_continue = True

        if ((is_like_limit_reached and is_likes_enabled) or not is_likes_enabled) and \
           ((is_follow_limit_reached and is_follow_enabled) or not is_follow_enabled) and \
           ((is_comment_limit_reached and is_comment_enabled) or not is_comment_enabled) and \
           ((is_watch_limit_reached and is_stories_enabled) or not is_stories_enabled):
            # If one of the limits reached for source-limit, move to next source
            if (like_reached_source_limit is not None and like_reached_session_limit is None) or \
               (follow_reached_source_limit is not None and follow_reached_session_limit is None):
                can_continue = False
                action_status.set_limit(ActionState.SOURCE_LIMIT_REACHED)

            # If all of the limits reached for session-limit, finish the session
            if ((like_reached_session_limit is not None and is_likes_enabled) or not is_likes_enabled) and \
               ((follow_reached_session_limit is not None and is_follow_enabled) or not is_follow_enabled):
                can_continue = False
                action_status.set_limit(ActionState.SESSION_LIMIT_REACHED)

        print("Back to profiles list")
        device.back()

        return can_continue