Adding new feature Skipped.txt Likedusers.txt

[lukasz00500]

Before submitting an issue, make sure you have:

• [x] Updated to the latest version
• [x] Read the README and docs
• [x] Searched the bugtracker for similar issues including closed ones

Purpose of your issue?

• [ ] Bug report (encountered problems/errors)
• [x] Feature request (request for a new functionality)
• [ ] Question
• [ ] Other

Hello

due to changes in the instagram regulations. You can now make 200 requests per hour. or something like that. From what I see, the bot does not work as it should to save sent requests.

First of all, I do not see in the code, scan whether the user is in skipped.txt. This should be done before downloading any information about the user

The bot should also add users who already have a liked photo to the list, for example likedUsers.txt This will prevent re-liking the photos of the same users.

I am sending my corrected version of the bot some parts are from user @bdebon from issue #484

bot_filter.py part with (+) is changed or aded

from . import delay

# Adding useless users_ids to the skipped_list file: skipped.txt , so
# InstaBot will not try to follow them again or InstaBot will not like
# their medias anymore

+ def skippedlist_adder(self, user_id):
+    # user_id = self.convert_to_user_id(user_id)
+    skipped = self.read_list_from_file("skipped.txt")
+   if user_id not in skipped:
+        with open('skipped.txt', "a") as file:
+            self.console_print('\n\033[93m Add user_id %s to skippedlist : skipped.txt ... \033[0m'
+                               % user_id)
+            # Append user_is to the end of skipped.txt
+            file.write(str(user_id) + "\n")
+           self.console_print('Done adding user_id to skipped.txt')
+    return
+   
+ def isInSkippedList(self, user_id):
+    skipped = self.read_list_from_file("skipped.txt")
+    return user_id in skipped   
+    
+
+ def likedUserslist_adder(self, user_id):
+    # user_id = self.convert_to_user_id(user_id)
+   skipped = self.read_list_from_file("liked_users.txt")
+   if user_id not in skipped:
+       with open('liked_users.txt', "a") as file:
+           self.console_print('\n\033[93m Add user_id %s to likedUsersList : liked_users.txt ... \033[0m'
+                             % user_id)
+           # Append user_is to the end of skipped.txt
+           file.write(str(user_id) + "\n")
+           self.console_print('Done adding user_id to liked_users.txt')
+   return
+
+ def isInLikedUsersList(self, user_id):
+   skipped = self.read_list_from_file("liked_users.txt")
+    return user_id in skipped

# filtering medias

def filter_medias(self, media_items, filtration=True, quiet=False, is_comment=False):
    if filtration:
        if not quiet:
            self.logger.info("Received %d medias." % len(media_items))
        if not is_comment:
            media_items = _filter_medias_not_liked(media_items)
            if self.max_likes_to_like:
                media_items = _filter_medias_nlikes(
                    media_items, self.max_likes_to_like)
        else:
            media_items = _filter_medias_not_commented(self, media_items)
        if not quiet:
            self.logger.info("After filtration %d medias left." %
                             len(media_items))
    return _get_media_ids(media_items)

def _filter_medias_not_liked(media_items):
    not_liked_medias = []
    for media in media_items:
        if 'has_liked' in media.keys():
            if not media['has_liked']:
                not_liked_medias.append(media)
    return not_liked_medias

def _filter_medias_not_commented(self, media_items):
    not_commented_medias = []
    for media in media_items:
        if media.get('comment_count', 0) > 0 and media.get('comments'):
            my_comments = [comment for comment in media['comments']
                           if comment['user_id'] == self.user_id]
            if my_comments:
                continue
        not_commented_medias.append(media)
    return not_commented_medias

def _filter_medias_nlikes(media_items, max_likes_to_like):
    filtered_medias = []
    for media in media_items:
        if 'like_count' in media.keys():
            if media['like_count'] < max_likes_to_like:
                filtered_medias.append(media)
    return filtered_medias

def _get_media_ids(media_items):
    result = []
    for media in media_items:
        if 'pk' in media.keys():
            result.append(media['pk'])
    return result

def check_media(self, media_id):
    self.mediaInfo(media_id)
    if self.filter_medias(self.LastJson["items"]):
        return check_user(self, self.get_media_owner(media_id))
    return False

# filter users

def search_stop_words_in_user(self, user_info):
    text = ''
    if 'biography' in user_info:
        text += user_info['biography'].lower()

    if 'username' in user_info:
        text += user_info['username'].lower()

    if 'full_name' in user_info:
        text += user_info['full_name'].lower()

    for stop_word in self.stop_words:
        if stop_word in text:
            return True

    return False

def filter_users(self, user_id_list):
    return [str(user["pk"]) for user in user_id_list]

def check_user(self, user_id, filter_closed_acc=False, unfollowing=False):
    if not self.filter_users and not unfollowing:
        return True

    delay.small_delay(self)
    user_id = self.convert_to_user_id(user_id)

    if not user_id:
        self.console_print('\n\033[91m not user_id , Skipping \033[0m')
        return False
    if self.whitelist and user_id in self.whitelist:
        self.console_print('\n\033[92m user_id in self.whitelist \033[0m')
        return True
    if self.blacklist and user_id in self.blacklist:
        self.console_print('\n\033[91m user_id in self.blacklist \033[0m')
        return False

    if user_id == str(self.user_id):
        self.console_print('\n\033[92m user_id equals bot user_id, Skipping \033[0m')
        return False

    if not self.following:
        self.console_print('\n\033[92m Own following list is empty , downloading ...\033[0m')
        self.following = self.get_user_following(self.user_id)
    if user_id in self.following:
        if not unfollowing:
            # Log to Console
            self.console_print('\n\033[91m Already following , Skipping \033[0m')
        return False

    user_info = self.get_user_info(user_id)
    if not user_info:
        self.console_print('\n\033[91m not user_info , Skipping \033[0m')
        return False

    self.console_print('\n\033[38;5;106m USER_NAME: %s , FOLLOWER: %s , FOLLOWING: %s \033[0m' % (user_info["username"], user_info["follower_count"],
                                           user_info["following_count"]))

+    if isInLikedUsersList(self, user_id):
+       self.logger.warning(
+           '\033[38;5;216m USER ALREADY LIKED! Skipping. \033[0m')
+       return False
+       
+   if isInSkippedList(self, user_id):
+        self.logger.warning(
+           '\033[38;5;216m USER IN SKIPPED LIST! Skipping. \033[0m')
+        return False                                       

    if filter_closed_acc and "is_private" in user_info:
        if user_info["is_private"]:
            self.console_print('\n info : \033[91m is PRIVATE , Skipping \033[0m')
+            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
    if "is_business" in user_info and self.filter_business_accounts:
        if user_info["is_business"]:
            self.console_print('\n info : \033[91m is BUSINESS , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
    if "is_verified" in user_info and self.filter_verified_accounts:
        if user_info["is_verified"]:
            self.console_print('\n info : \033[91m is VERIFIED , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
    if "follower_count" in user_info and "following_count" in user_info:
        if user_info["follower_count"] < self.min_followers_to_follow:
            self.console_print('\n\033[91m user_info["follower_count"] < self.min_followers_to_'
                               'follow , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
        if user_info["follower_count"] > self.max_followers_to_follow:
            self.console_print('\n\033[91m user_info["follower_count"] > '
                               'self.max_followers_to_follow , Skipping \033[0m')

            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
        if user_info["following_count"] < self.min_following_to_follow:
            self.console_print('\n\033[91m user_info["following_count"] < '
                               'self.min_following_to_follow , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
        if user_info["following_count"] > self.max_following_to_follow:
            self.console_print('\n\033[91m user_info["following_count"] > '
                               'self.max_following_to_follow , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False
        try:
            if user_info["follower_count"] / user_info["following_count"] \
                    > self.max_followers_to_following_ratio:
                self.console_print('\n\033[91m ["follower_count"] / ["following_count"] > '
                                   'self.max_followers_to_following_ratio , Skipping \033[0m')
                skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
                return False
            if user_info["following_count"] / user_info["follower_count"] \
                    > self.max_following_to_followers_ratio:

                self.console_print('\n\033[91m ["following_count"] / ["follower_count"] > '
                                   'self.max_following_to_followers_ratio , Skipping \033[0m')
                skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
                return False
        except ZeroDivisionError:
            print('!!! Exxxcept ZeroDivisionError !!! ')
            return False

    if 'media_count' in user_info:
        if user_info["media_count"] < self.min_media_count_to_follow:
            self.console_print('\n\033[91m user_info["media_count"] < self.min_media_count_to_'
                               'follow , BOT or InActive , Skipping \033[0m')

            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False  # bot or inactive user

    if search_stop_words_in_user(self, user_info):
        self.console_print(
            '\n\033[91m search_stop_words_in_user , Skipping \033[0m')
        skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
        return False

    return True

def check_not_bot(self, user_id):
    """ Filter bot from real users. """
    delay.small_delay(self)
    user_id = self.convert_to_user_id(user_id)
    if not user_id:
        return False
    if self.whitelist and user_id in self.whitelist:
        return True
    if self.blacklist and user_id in self.blacklist:
        return False

    user_info = self.get_user_info(user_id)
    if not user_info:
        return True  # closed acc

    if "following_count" in user_info:
        if user_info["following_count"] > self.max_following_to_block:
            self.console_print('\n\033[91m user_info["following_count"] > '
                               'self.max_following_to_block , Skipping \033[0m')
            skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
            return False  # massfollower

    if search_stop_words_in_user(self, user_info):
        self.console_print(
            '\n\033[91m search_stop_words_in_user , Skipping \033[0m')
        skippedlist_adder(self, user_id)  # Add user_id to skipped.txt
        return False

    return True

bot_like part with (+) is changed or aded

from tqdm import tqdm
from . import limits
from . import delay

def like(self, media_id):
    if limits.check_if_bot_can_like(self):
        delay.like_delay(self)
        if super(self.__class__, self).like(media_id):
            self.total_liked += 1
            return True
    else:
        self.logger.info("Out of likes for today.")
    return False

def like_medias(self, medias):
    broken_items = []
    if not medias:
        self.logger.info("Nothing to like.")
        return broken_items
    self.logger.info("Going to like %d medias." % (len(medias)))
    for media in tqdm(medias):
        if not self.like(media):
            delay.error_delay(self)
            broken_items = medias[medias.index(media):]
            break
    self.logger.info('\033[38;5;206m DONE: Total liked %d medias.\033[0m' % self.total_liked,)
    return broken_items

def like_timeline(self, amount=None):
    self.logger.info("Liking timeline feed:")
    medias = self.get_timeline_medias()[:amount]
    return self.like_medias(medias)

def like_user(self, user_id, amount=None, filtration=True):
    """ Likes last user_id's medias """
    if filtration:
        if not self.check_user(user_id, filter_closed_acc=True):
            return False
    self.logger.info("Liking user_%s's feed:" % user_id)
    user_id = self.convert_to_user_id(user_id)
    medias = self.get_user_medias(user_id, filtration=filtration)
    if not medias:
        self.logger.info(
            "None medias received: account is closed or medias have been filtered.")
        return False

+    if isInLikedUsersList(self, user_id):
+        self.logger.warning(
+            '\033[38;5;216m USER ALREADY LIKED! Skipping. \033[0m')
+        return False
+
+   self.logger.info(
+        "Adding user to list of liked_users.")
+    likedUserslist_adder(self, user_id)
+
+    return self.like_medias(medias[:amount])

def like_users(self, user_ids, nlikes=None, filtration=True):
    for user_id in user_ids:
        if not limits.check_if_bot_can_like(self):
            self.logger.info("Out of likes for today.")
            return
        self.like_user(user_id, amount=nlikes, filtration=filtration)

def like_hashtag(self, hashtag, amount=None):
    """ Likes last medias from hashtag """
    self.logger.info("Going to like media with hashtag #%s." % hashtag)
    medias = self.get_hashtag_medias(hashtag)
    return self.like_medias(medias[:amount])

def like_geotag(self, geotag, amount=None):
    # TODO: like medias by geotag
    pass

def like_followers(self, user_id, nlikes=None, nfollows=None):
    self.logger.info("Like followers of: %s." % user_id)
    if not limits.check_if_bot_can_like(self):
        self.logger.info("Out of likes for today.")
        return
    if not user_id:
        self.logger.info("User not found.")
        return
    follower_ids = self.get_user_followers(user_id, nfollows)
    if not follower_ids:
        self.logger.info("%s not found / closed / has no followers." % user_id)
    else:
        self.like_users(follower_ids[:nfollows], nlikes)

def like_following(self, user_id, nlikes=None):
    self.logger.info("Like following of: %s." % user_id)
    if not limits.check_if_bot_can_like(self):
        self.logger.info("Out of likes for today.")
        return
    if not user_id:
        self.logger.info("User not found.")
        return
    following_ids = self.get_user_following(user_id)
    if not following_ids:
        self.logger.info("%s not found / closed / has no following." % user_id)
    else:
        self.like_users(following_ids, nlikes)

+ def likedUserslist_adder(self, user_id):
+    # user_id = self.convert_to_user_id(user_id)
+    skipped = self.read_list_from_file("liked_users.txt")
+    if user_id not in skipped:
+        with open('liked_users.txt', "a") as file:
+            self.console_print('\n\033[93m Add user_id %s to likedUsersList : liked_users.txt ... \033[0m'
+                               % user_id)
+            # Append user_is to the end of liked_users.txt
+            file.write(str(user_id) + "\n")
+            self.console_print('Done adding user_id to liked_users.txt')
+    return
+
+ def isInLikedUsersList(self, user_id):
+    skipped = self.read_list_from_file("liked_users.txt")
+    return user_id in skipped

[basnijholt]

Thanks for taking the time to check this!

Check you perhaps make a "pull request" with your changes?

[lukasz00500]

I do not know too much how to do it I'm a beginner :)

[basnijholt]

It's not too difficult though, just edit it here https://github.com/instagrambot/instabot/edit/master/instabot/bot/bot_filter.py

Otherwise, I am afraid that no-one will implement those changes.

[bdebon]

@lukasz00500 it's true that the lists should be checked before fetching users. I did not code it because I did what was the easier for me as I am not very good with Python. I would like your changes to be merged. I could use an up-to-date version of the bot which behave like I wanted to so it would be amazing. Glad to see that my work served you a little and thank you very much for trying to share your improvements with everybody! I keep an eye on that issue!

[lukasz00500]

I will try tomorrow, anyone fell free to do it, if you have any experience

[lukasz00500]

ok I tried to implement this function to the latest version of bot and i have maybe a stupid problem.

i added function to add user to liked.txt but after that, bot is still liking photos of users who are on that list. can anyone help me ?

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.