Пример #1
0
    def test_login(self):
        self.bot = Bot()

        def mockreturn(*args, **kwargs):
            r = Mock()
            r.status_code = 200
            r.text = '{"status": "ok"}'
            return r

        def mockreturn_login(*args, **kwargs):
            r = Mock()
            r.status_code = 200
            r.text = json.dumps({
                "logged_in_user": {
                    "pk": self.USER_ID,
                    "username": self.USERNAME,
                    "full_name": self.FULLNAME
                },
                "status": "ok"
            })
            return r

        with patch('requests.Session') as Session:
            instance = Session.return_value
            instance.get.return_value = mockreturn()
            instance.post.return_value = mockreturn_login()
            instance.cookies = requests.cookies.RequestsCookieJar()
            instance.cookies.update(
                {'csrftoken': self.TOKEN, 'ds_user_id': self.USER_ID})

            assert self.bot.api.login(username=self.USERNAME,
                                      password=self.PASSWORD)

        assert self.bot.api.username == self.USERNAME
        assert self.bot.user_id == self.USER_ID
        assert self.bot.api.is_logged_in
        assert self.bot.api.uuid
        assert self.bot.api.token
Пример #2
0
    Workflow:
        Block bots. That makes them unfollow you -> You have clear account.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()


stop_words = ['shop', 'store', 'free']
bot = Bot(stop_words=stop_words)
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

bot.logger.info("This script will block bots. "
                "So they will no longer be your follower. "
                "Bots are those users who:\n"
                " * follow more than (sample value - change in file) 2000 users\n"
                " * have stopwords in user's info: "
                " %s " % str(stop_words))
bot.block_bots()
"""
    instabot example

    Workflow:
        Follow user's followers by username.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

for username in args.users:
    bot.follow_followers(username)
"""
    instabot example

    Workflow:
        Download the specified user's medias

"""
import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('username', type=str, help='@username')
args = parser.parse_args()

if args.username[0] != "@":  # if first character isn't "@"
    args.username = "******" + args.username

bot = Bot()
bot.login()
medias = bot.get_total_user_medias(args.username)
bot.download_photos(medias)
Пример #5
0
from io import open

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

posted_pic_list = []
try:
    with open('pics.txt', 'r', encoding='utf8') as f:
        posted_pic_list = f.read().splitlines()
except Exception:
    posted_pic_list = []

timeout = 24 * 60 * 60  # pics will be posted every 24 hours

bot = Bot()
bot.login()

while True:
    pics = glob.glob("./pics/*.jpg")
    pics = sorted(pics)
    try:
        for pic in pics:
            if pic in posted_pic_list:
                continue

            caption = pic[:-4].split(" ")
            caption = " ".join(caption[1:])

            print("upload: " + caption)
            bot.upload_photo(pic, caption=caption)
Пример #6
0
    This script take my likers who don't follow me and like them. 
"""

import os
import time
import random
from instabot import Bot


def like_media_likers(bot, media, nlikes=2):
    for user in bot.get_media_likers(media):
        bot.like_user(user, nlikes)
    return True


bot = Bot()
bot.login(
    username=os.getenv("INSTAGRAM_USERNAME"),
    password=os.getenv("INSTAGRAM_PASSWORD"),
)

my_last_medias = bot.get_your_medias()

my_likers = set([
    liker for media in my_last_medias for liker in bot.get_media_likers(media)
])
print("Found %d likers" % len(my_likers))

my_followers = set(bot.followers)

likers_that_dont_follow = my_likers - my_followers
Пример #7
0
"""
    instabot example

    Collects the information about your account
    every hour in username.tsv file.
"""

import os
import sys
import time

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

if len(sys.argv) != 2:
    print("USAGE: Pass username to collect stats of - saved in username.tsv (same dir).")
    print("Example: python %s account1" % sys.argv[0])
    exit()

delay = 60 * 60  # in seconds

bot = Bot()
bot.login()
while True:
    bot.save_user_stats(sys.argv[1])
    time.sleep(delay)
Пример #8
0
import argparse
import os
import sys
import time
from random import shuffle

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p, proxy=args.proxy)

like_hashtags_list = bot.read_list_from_file("like_hashtags.txt")

all_users = []

for hashtag in like_hashtags_list:
    users = bot.get_hashtag_users(hashtag)
    all_users += users

#randomization routine
shuffle(all_users)

bot.follow_users(users)
time.sleep(10)
"""
    instabot example

    Workflow:
        1) unfollows every from your account.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot


parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)
bot.unfollow_everyone()
"""
    instabot example

    Workflow:
        Like user's, follower's media by user_id.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

for username in args.users:
    bot.like_followers(username, nlikes=3)
Пример #11
0
    Workflow:
    1) likes your timeline feed
    2) likes user's feed

    Notes:
    1) You should pass user_id, not username
"""

import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

bot = Bot()
bot.login()

# like media by a single user_id
bot.like_user("352300017")

# likes all media from timeline
bot.like_timeline()

# likes all media from timeline
bot.like_medias(bot.get_timeline_medias())

# likes media by hashtag(s)
tags = ["l4l", "selfie"]

for t in tags:
"""
    instabot example

    Workflow:
        1) unfollows users that don't follow you.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot


parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)
bot.unfollow_non_followers()
Пример #13
0
    It uses data written in files:
        * follow_followers.txt
        * follow_following.txt
        * like_hashtags.txt
        * like_users.txt
    and do the job. This bot can be run 24/7.
"""

import os
import sys

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

bot = Bot()
bot.login()

print("Current script's schedule:")
follow_followers_list = bot.read_list_from_file("follow_followers.txt")
print("Going to follow followers of:", follow_followers_list)
follow_following_list = bot.read_list_from_file("follow_following.txt")
print("Going to follow following of:", follow_following_list)
like_hashtags_list = bot.read_list_from_file("like_hashtags.txt")
print("Going to like hashtags:", like_hashtags_list)
like_users_list = bot.read_list_from_file("like_users.txt")
print("Going to like users:", like_users_list)

tasks_list = []
for item in follow_followers_list:
    tasks_list.append((bot.follow_followers, {'user_id': item, 'nfollows': None}))
        The file should have one comment per line.

    Workflow:
        1) Get your timeline medias
        2) Comment them with random comments from file.

    Notes:
        You can change file and add there your comments.
"""

import sys
import os

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

if len(sys.argv) != 2:
    print("USAGE: Pass a path to the file with comments")
    print("Example: %s comments_emoji.txt" % sys.argv[0])
    exit()

comments_file_name = sys.argv[1]
if not os.path.exists(comments_file_name):
    print("Can't find '%s' file." % comments_file_name)
    exit()

bot = Bot(comments_file=comments_file_name)
bot.login()
bot.comment_medias(bot.get_timeline_medias())
bot.logout()
    Workflow:
        Follow users who post medias with hashtag.
"""

import argparse
import os
import sys
import time

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('hashtags', type=str, nargs='+', help='hashtags')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

wait = 5 * 60  # in seconds

while True:
    for hashtag in args.hashtags:
        users = bot.get_hashtag_users(hashtag)
        bot.follow_users(users)
    time.sleep(wait)
Пример #16
0
class TestBotAPI(TestBot):
    def test_login(self):
        self.bot = Bot()

        def mockreturn(*args, **kwargs):
            r = Mock()
            r.status_code = 200
            r.text = '{"status": "ok"}'
            return r

        def mockreturn_login(*args, **kwargs):
            r = Mock()
            r.status_code = 200
            r.text = json.dumps({
                "logged_in_user": {
                    "pk": self.USER_ID,
                    "username": self.USERNAME,
                    "full_name": self.FULLNAME
                },
                "status": "ok"
            })
            return r

        with patch('requests.Session') as Session:
            instance = Session.return_value
            instance.get.return_value = mockreturn()
            instance.post.return_value = mockreturn_login()
            instance.cookies = requests.cookies.RequestsCookieJar()
            instance.cookies.update(
                {'csrftoken': self.TOKEN, 'ds_user_id': self.USER_ID})

            assert self.bot.api.login(username=self.USERNAME,
                                      password=self.PASSWORD)

        assert self.bot.api.username == self.USERNAME
        assert self.bot.user_id == self.USER_ID
        assert self.bot.api.is_logged_in
        assert self.bot.api.uuid
        assert self.bot.api.token

    def test_generate_uuid(self):
        from uuid import UUID
        generated_uuid = self.bot.api.generate_UUID(True)

        assert isinstance(UUID(generated_uuid), UUID)
        assert UUID(generated_uuid).hex == generated_uuid.replace('-', '')

    def test_set_user(self):
        test_username = "******"
        test_password = "******"
        self.bot.api.set_user(test_username, test_password)

        assert self.bot.api.username == test_username
        assert self.bot.api.password == test_password
        assert hasattr(self.bot.api, "uuid")

    def test_reset_counters(self):
        keys = ['liked', 'unliked', 'followed', 'messages',
                'unfollowed', 'commented', 'blocked', 'unblocked']
        for key in keys:
            self.bot.total[key] = 1
            assert self.bot.total[key] == 1
        self.bot.reset_counters()
        for key in keys:
            assert self.bot.total[key] == 0
Пример #17
0
from instabot import Bot

bot = Bot()

bot.login(username="******", password="******")
bot.upload_photo("img.jpg", caption="uploaded by bot")
"""
    instabot example

    Workflow:
        Save users' followers into a file.
"""
import os
import sys
import argparse

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot, utils

parser = argparse.ArgumentParser(add_help=False)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('filename', type=str, help="filename")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

f = utils.file(args.filename)
for username in args.users:
    followers = bot.get_user_followers(username)
    f.save_list(followers)
Пример #19
0
from instabot import Bot

bot = Bot()
bot.login(username="******", password="******")
    Workflow:
        Take users from input file and follow them.
        The file should contain one username per line!
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('filepath', type=str, help='filepath')
args = parser.parse_args()

bot = Bot(filter_users=False)
users_to_follow = bot.read_list_from_file(args.filepath)
if not users_to_follow:
    exit()
else:
    print("Found %d users in file." % len(users_to_follow))

bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

bot.follow_users(users_to_follow)
Пример #21
0
"""
    instabot example

    Workflow:
        1) unfollows users that have followers < following.
"""

import argparse
import os
import sys


sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot


parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)
bot.unfollow_usersWithLessFollowers()
"""
    instabot example

    Workflow:
    1) Downloads your medias

"""

import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

bot = Bot()
bot.login()
medias = bot.get_total_user_medias(bot.user_id)
bot.download_photos(medias)
    Workflow:
        Follow users who liked the last media of input users.
"""

import argparse
import os
import sys

from tqdm import tqdm

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot(max_follows_per_day=25, follow_delay=30)
bot.login(username=args.u, password=args.p, proxy=args.proxy)

for username in args.users:
    medias = bot.get_user_medias(username, filtration=False)
    if medias:
        likers = bot.get_media_likers(medias[0])
        for liker in tqdm(likers):
            bot.follow(liker)
        blacklist and whitelist files should contain user_ids - each one on the
        separate line.
        Example:
            1234125
            1234124512
"""

import sys
import os
from tqdm import tqdm
import argparse

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot(whitelist_file="whitelist.txt",
          blacklist_file="blacklist.txt")

bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

timeline_medias = bot.get_timeline_medias()
for media in tqdm(timeline_medias, desc="timeline"):
    bot.like_user(bot.get_media_owner(media))
def like_and_follow(bot, user_id, nlikes=3):
    bot.like_user(user_id, amount=nlikes)
    bot.follow(user_id)
    return True


def like_and_follow_media_likers(bot, media, nlikes=3):
    for user in tqdm(bot.get_media_likers(media), desc="Media likers"):
        like_and_follow(bot, user, nlikes)
        time.sleep(10 + 20 * random.random())
    return True


def like_and_follow_your_feed_likers(bot, nlikes=3):
    last_media = bot.get_your_medias()[0]
    return like_and_follow_media_likers(bot, last_media, nlikes=nlikes)


parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

like_and_follow_your_feed_likers(bot)
sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot, utils

NOTIFIED_USERS_PATH = 'notified_users.txt'

MESSAGE = 'Thank you for a script, sudoguy!'

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('-users', type=str, nargs='?', help='a path to already notified users')
parser.add_argument('-message', type=str, nargs='?', help='message text')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

# Use custom message from args if exist
if args.message:
    MESSAGE = args.message

# Check on existed file with notified users
notified_users = utils.file(NOTIFIED_USERS_PATH)
if not notified_users.list:
    notified_users.save_list(bot.followers)
    print(
        'All followers saved in file {users_path}.\n'
        'In a next time, for all new followers script will send messages.'.format(
            users_path=NOTIFIED_USERS_PATH
"""
    instabot example

    Workflow:
    1) Unarchives your last medias

"""

import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

bot = Bot()
bot.login()
medias = bot.get_archived_medias()
bot.unarchive_medias(medias)
Пример #28
0
"""
    instabot example

    Workflow:
        Like last medias by users.
"""

import sys
import os
import time
import random
from tqdm import tqdm
import argparse

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p, proxy=args.proxy)

for username in args.users:
    bot.like_user(username)
bot = Bot(
    max_likes_per_day=setting_0,
    max_unlikes_per_day=setting_1,
    max_follows_per_day=setting_2,
    max_unfollows_per_day=setting_3,
    max_comments_per_day=setting_4,
    max_likes_to_like=setting_5,
    max_followers_to_follow=setting_6,
    min_followers_to_follow=setting_7,
    max_following_to_follow=setting_8,
    min_following_to_follow=setting_9,
    max_followers_to_following_ratio=setting_10,
    max_following_to_followers_ratio=setting_11,
    min_media_count_to_follow=setting_12,
    like_delay=setting_13,
    unlike_delay=setting_14,
    follow_delay=setting_15,
    unfollow_delay=setting_16,
    comment_delay=setting_17,
    whitelist_file=whitelist,
    blacklist_file=blacklist,
    comments_file=comment,
    stop_words=[
        'order',
        'shop',
        'store',
        'free',
        'doodleartindonesia',
        'doodle art indonesia',
        'fullofdoodleart',
        'commission',
        'vector',
        'karikatur',
        'jasa',
        'open'])
Пример #30
0
import os
import sys
import time
import datetime
import json

from random import shuffle

# ------------------------------------------------------------------------------------

# ------------------------------------------------------------------------------------

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

bot = Bot()

#TXT File Path ///
filePath = os.path.dirname(os.path.abspath(__file__)) + "/"

bot.login(username="******", password="******")

MAX_RETRIES = 100
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(max_retries=MAX_RETRIES)
session.mount('https://', adapter)
session.mount('http://', adapter)


def check_if_folder_exists(directory_name):
Пример #31
0
from instabot import Bot
from time import sleep
from random import randint
import authentication

bot = Bot()

bot.login(username=authentication.USERNAME, password=authentication.PASSWORD)

following = (bot.following)
followers = (bot.followers)

for i in following:
    if i in followers:
        continue
    else:
        print((bot.get_user_info(i))['username'])
        # If you want to unfollow them too, uncomment the bellow two lines as well.
        #bot.unfollow(i)
        #sleep(randint(6,12))
Пример #32
0
"""
import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot


parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)



print("Current script's schedule:")
follow_followers_list = bot.read_list_from_file("follow_followers.txt")
print("Going to follow followers of:", follow_followers_list)
follow_following_list = bot.read_list_from_file("follow_following.txt")
print("Going to follow following of:", follow_following_list)
like_hashtags_list = bot.read_list_from_file("like_hashtags.txt")
print("Going to like hashtags:", like_hashtags_list)
like_users_list = bot.read_list_from_file("like_users.txt")
print("Going to like users:", like_users_list)
args = parser.parse_args()

try:
    print(u'Like medias by location')
except TypeError:
    sys.stdout = stdout

bot = Bot(max_likes_per_day=800,
          max_unlikes_per_day=0,
          max_follows_per_day=200,
          filter_users=True,
          max_followers_to_follow=5000,
          min_followers_to_follow=200,
          max_following_to_follow=99999999,
          min_following_to_follow=600,
          max_followers_to_following_ratio=0.4,
          max_following_to_followers_ratio=100000,
          max_following_to_block=99999999,
          min_media_count_to_follow=1,
          follow_delay=60,
          like_delay=25,
          whitelist=False,
          blacklist=False,
          comments_file=False)
bot.login(username=args.u, password=args.p, proxy=args.proxy)

if args.locations:
    for location in args.locations:
        print(u"Location: {}".format(location))
        bot.searchLocation(location)
        finded_location = bot.LastJson['items'][0]
Пример #34
0
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()


def choice(message):
    get_choice = input(message)
    if get_choice == 'y':
        return True
    elif get_choice == 'n':
        return False
    else:
        print("Invalid Input")
        return choice(message)


bot = Bot()
bot.login(username=args.u, password=args.p, proxy=args.proxy)

if bot.api.getv2Inbox():
    data = bot.last_json['inbox']['threads']
    for item in data:
        bot.console_print(item['inviter']['username'], 'lightgreen')
        user_id = str(item['inviter']['pk'])
        last_item = item['last_permanent_item']
        item_type = last_item['item_type']
        if item_type == 'text':
            print(last_item['text'])
            if choice('Do you want to reply to this message?(y/n)'):
                text = input('write you message: ')
                if choice('send message?(y/n)'):
                    bot.send_message(text,
def create_bot():
    login = os.getenv('INST_LOGIN')
    password = os.getenv('INST_PSWRD')
    bot = Bot()
    bot.login(username=login, password=password)
    return bot
Пример #36
0
"""
    instabot example

    Workflow:
        Like last medias by user.
"""

import sys
import os
import time
import random
from tqdm import tqdm

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

if len(sys.argv) < 2:
    print("USAGE: Pass username / usernames to like.")
    print("Example: python %s ohld lenakolenka" % sys.argv[0])
    exit()

bot = Bot()
bot.login()
for username in sys.argv[1:]:
    bot.like_user(username)
Пример #37
0
import os, time, random
from dotenv import load_dotenv
from instabot import Bot

if __name__ == "__main__":
    load_dotenv()

    bot = Bot()
    bot.login(username=os.getenv('INSTAGRAM_LOGIN'), password=os.getenv('INSTAGRAM_PASSWORD'))
    folder = 'images'

    for filename in os.listdir(folder):
        bot.upload_photo(os.path.join(folder, filename))
        time.sleep(random.randrange(15, 35))
Пример #38
0
from instabot import Bot

bot = Bot()
bot.login()
bot.like_timeline()
bot.like_user("352300017")
bot.follow_users(["352300017"])
Пример #39
0
sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

bot = Bot(comments_file="comments.txt",
          blacklist="blacklist.txt",
          proxy=None,
          max_likes_per_day=300,
          max_unlikes_per_day=1000,
          max_follows_per_day=75,
          max_unfollows_per_day=80,
          max_comments_per_day=100,
          max_likes_to_like=100,
          filter_users=True,
          max_followers_to_follow=2000,
          min_followers_to_follow=40,
          max_following_to_follow=7500,
          min_following_to_follow=150,
          max_followers_to_following_ratio=0.9,
          max_following_to_followers_ratio=99999999,
          max_following_to_block=99999999,
          min_media_count_to_follow=3,
          like_delay=30,
          unlike_delay=30,
          follow_delay=60,
          unfollow_delay=150,
          comment_delay=120,
          whitelist=False,
          stop_words=['shop', 'store', 'free'])
bot.login()
bot.logger.info("ULTIMATE script. 24hours save")
Пример #40
0
def load_img_insta(user_name, pass_word):
    imgs = os.listdir('image2')
    bot = Bot()
    bot.login(username=user_name, password=pass_word)
    for img in imgs:
        bot.upload_photo(f'image2/{img}')
Пример #41
0
bot = Bot(
    max_likes_per_day=setting_0,
    max_unlikes_per_day=setting_1,
    max_follows_per_day=setting_2,
    max_unfollows_per_day=setting_3,
    max_comments_per_day=setting_4,
    max_likes_to_like=setting_5,
    max_followers_to_follow=setting_6,
    min_followers_to_follow=setting_7,
    max_following_to_follow=setting_8,
    min_following_to_follow=setting_9,
    max_followers_to_following_ratio=setting_10,
    max_following_to_followers_ratio=setting_11,
    min_media_count_to_follow=setting_12,
    like_delay=setting_13,
    unlike_delay=setting_14,
    follow_delay=setting_15,
    unfollow_delay=setting_16,
    comment_delay=setting_17,
    whitelist=whitelist,
    blacklist=blacklist,
    comments_file=comment,
    stop_words=[
        'order',
        'shop',
        'store',
        'free',
        'doodleartindonesia',
        'doodle art indonesia',
        'fullofdoodleart',
        'commission',
        'vector',
        'karikatur',
        'jasa',
        'open'])
Пример #42
0
import captions_for_medias

sys.path.append(os.path.join(sys.path[0], "../../"))
from instabot import Bot  # noqa: E402

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument("-u", type=str, help="username")
parser.add_argument("-p", type=str, help="password")
parser.add_argument("-proxy", type=str, help="proxy")
parser.add_argument("-photo", type=str, help="photo name")
parser.add_argument("-caption", type=str, help="caption for photo")
parser.add_argument('-tag', action='append', help='taged user id')

args = parser.parse_args()

bot = Bot()
bot.login()

posted_pic_file = "pics.txt"

posted_pic_list = []
caption = ""

if not os.path.isfile(posted_pic_file):
    with open(posted_pic_file, "w"):
        pass
else:
    with open(posted_pic_file, "r") as f:
        posted_pic_list = f.read().splitlines()

# Get the filenames of the photos in the path ->
Пример #43
0
"""
    instabot example

    Workflow:
        1) unfollows every from your account.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

# parser = argparse.ArgumentParser(add_help=True)
# parser.add_argument('-u', type=str, help="username")
# parser.add_argument('-p', type=str, help="password")
# parser.add_argument('-proxy', type=str, help="proxy")
# args = parser.parse_args()
#
# bot = Bot()
# bot.login(username=args.u, password=args.p,
#           proxy=args.proxy)
bot = Bot()
bot.login(username="******", password="******")
bot.unfollow_everyone()
Пример #44
0
def start():

    print("Bot starting Beep Boop")

    current_hot = []

    post_history = []

    reddit = praw.Reddit(client_id='REDDIT-BOT-ID',
                         client_secret='REDDIT-BOT-SECRET',
                         user_agent='INSTAGRAM-BOT-NAME',
                         username='******',
                         password='******')

    subreddit = list(reddit.subreddit('blackpeopletwitter').hot(limit=12))

    for submissions in subreddit[2:]:

        current_hot.append(
            (submissions.url, submissions.title, submissions.shortlink))

    bot = Bot()

    bot.login(username="******", password="******")

    while True:

        print("trying to find new content beep boop")

        compare_List = []

        subreddit = list(reddit.subreddit('blackpeopletwitter').hot(limit=12))

        for submissions in subreddit[2:]:

            compare_List.append(
                (submissions.url, submissions.title, submissions.shortlink))

        print([i for i in compare_List if i not in current_hot])

        if set(compare_List) != set(current_hot):

            print("New post detected")

            temp = ([i for i in compare_List if i not in current_hot])

            print(temp)

            current_hot = compare_List

            for tuples in temp:

                if tuples[0] not in post_history:

                    urllib.request.urlretrieve(tuples[0], "temp.jpg")
                    print("Picture is being posted -- beep boop")
                    tweet_string = tweet_analysis.tweet_text("temp.jpg")

                    try:
                        if tweet_string != 'imgur format':
                            bot.upload_photo("temp.jpg",
                                             caption=tuples[1] +
                                             "  #reddit #blackpeopletwitter " +
                                             tweet_string)
                        else:
                            print("imgur format not uploadable yet")
                            continue

                    except RuntimeError:

                        print("error caught!")
                        continue

                    post_history.append(tuples[0])
                    print("sucess!")

        now = datetime.now()
        current_time = now.strftime("%H:%M:%S")
        print("Trying again in 10 Min, current Time =", current_time)
        print(post_history)

        time.sleep(600)
Пример #45
0
            log.info("Wait 2200 - 2600 sec for next repost")
            time.sleep(randint(2200, 2800))
        except:
            log.info("image set to private " + scraped_user)
            x += 1
            time.sleep(randint(5, 20))
            instascraper(bot, new_media_id, path=POSTED_MEDIAS)
        x += 1
    x = 0
    time.sleep(randint(10, 30))
    instascraper(bot, new_media_id, path=POSTED_MEDIAS)


# All main stuff gets executed
open_profiles()
time.sleep(randint(5, 30))
bot = Bot()
#bot.login(username=InstaUsername)
bot.login(username=args.u, password=args.p)
time.sleep(randint(10, 30))
user_id = bot.get_user_id_from_username(args.u)
username = bot.get_username_from_user_id(user_id)
#print(f"Welcome {username} your userid is {user_id}")
saveStats = bot.save_user_stats(username)
users = None
if args.users:
    users = args.users
elif args.file:
    users = utils.file(args.file).list
instascraper(bot, users, args.amount)
Пример #46
0
import os
import sys
from instabot import Bot

bot = Bot(filter_users=True)
users_to_follow = bot.read_list_from_file('followers.txt')
if not users_to_follow:
    exit()
else:
    print("Found %d users in file." % len(users_to_follow))

bot.login(username=str(sys.argv[1]), password=str(sys.argv[2]))

bot.follow_users(users_to_follow)
    Workflow:
        Like last images with hashtag.
"""

import argparse
import os
import sys
import time

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('hashtags', type=str, nargs='+', help='hashtags')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

wait = 5 * 60  # in seconds

while True:
    for hashtag in args.hashtags:
        bot.like_hashtag(hashtag)
    time.sleep(wait)
Пример #48
0
@author: Kianoush 

GitHUb:https://github.com/Kianoush-h
YouTube: https://www.youtube.com/channel/UCvf9_53f6n3YjNEA4NxAkJA?view_as=subscriber
LinkedIn: https://www.linkedin.com/in/kianoush-haratiannejadi/

Email: [email protected]

"""

from instabot import Bot

username_ = 'kia_python'
password_ = 'KIA_python@'

bot = Bot()
bot.login(username=username_, password=password_)

tag_list = ['python', 'programmer', 'Kinaoush'],

for i in tag_list:
    bot.like_hashtag(i)

users = ['python', 'python.learning', 'codder', 'kinaoush']

bot.follow_users(user_ids='python.learning')

locs = ['Montreal', 'Canada', 'US', 'Iran']

for i in locs:
    bot.like_location_feed(i, amount=10)
"""
    instabot example

    Workflow:
        delete all posts in profile.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)
medias = bot.get_total_user_medias(bot.user_id)
bot.delete_medias(medias)
Пример #50
0
"""
    instabot example

    Workflow:
        Follow user's followers by username.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="aurimblys")
parser.add_argument('-p', type=str, help="adrenalinasjiega1")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='maybach420')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p, proxy=args.proxy)

for username in args.users:
    bot.follow_followers(username)
"""
    instabot example

    Workflow:
        Like rescent medias from your timeline feed.
"""

import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot


bot = Bot()
bot.login()
bot.like_timeline()
Пример #52
0
def bot_instantiate(user_name, user_password):
    # Initialize
    bot = Bot()
    bot.login(username=user_name, password=user_password)
    return bot
"""
    instabot example

    Workflow:
        Like rescent medias from your timeline feed.
"""

import argparse
import os
import sys
import time

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

wait = 5 * 60  # in seconds

while True:
    bot.like_timeline()
    time.sleep(wait)
Пример #54
0
def post_image(username, password, image_file):
    bot = Bot()
    bot.login(username=username, password=password)
    bot.upload_photo(f"images/{image_file}")
Пример #55
0
    Collects the information about your account
    every hour in username.tsv file.
"""

import argparse
import os
import sys
import time

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('user', type=str, nargs='*', help="user")
parser.add_argument('-path', type=str, default='', help="path")
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

delay = 60 * 60

while True:
    bot.save_user_stats(args.user, path=args.path)
    time.sleep(delay)
Пример #56
0
post_link = "https://www.instagram.com/p/"
result_filename = 'result.txt'
vip_filename = 'vip.txt'

# Creating folders
dir = "{}/accs/{}/a".format(path_, login)
dir0 = "{}/accs/{}".format(path_, login)
if not os.path.exists(dir):
    os.makedirs(dir)
if not os.path.exists(dir0 + '/tags'):
    os.makedirs(dir0 + '/tags')

# Changing directory to instabot/accs/bot_id
os.chdir(dir)

bot = Bot()
bot.login(username=login, password=password, proxy=proxy)

# Creating dict of bad users
bad_users = {}

# Loading id -> username dict
followers_id_name = {}
try:
    f = open('usernames.txt', 'r')
    for line in f:
        split = line.split(':')
        id = split[0]
        # обрезаем \n
        split2 = split[1].split('\n')
        username = split2[0]
"""
    instabot example

    Workflow:
        Download media photos with hashtag.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('hashtags', type=str, nargs='+', help='hashtags')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

for hashtag in args.hashtags:
    medias = bot.get_hashtag_medias(hashtag)
    bot.download_photos(medias)
Пример #58
0
        file.writelines('\n'.join(medias))
    return True


def repost_photo(bot, new_media_id, path='posted_medias.txt'):
    if exists_in_posted_medias(new_media_id, path):
        bot.logger.warning(
            "Media {0} was uploaded earlier".format(new_media_id))
        return False
    photo_path = bot.download_photo(new_media_id, save_description=True)
    if not photo_path:
        return False
    with open(photo_path[:-3] + 'txt', 'r') as f:
        text = ''.join(f.readlines())
    if bot.upload_photo(photo_path, text):
        update_posted_medias(new_media_id, path)
        bot.logger.info('Media_id {0} is saved in {1}'.format(
            new_media_id, path))


media_id = ''

if not media_id:
    print('Media id is empty!')
    exit(1)

bot = Bot()
bot.login()

repost_photo(bot, media_id)
Пример #59
0
"""
    instabot example

    Workflow:
        Like last medias by users.
"""

import argparse
import os
import sys

sys.path.append(os.path.join(sys.path[0], '../'))
from instabot import Bot

parser = argparse.ArgumentParser(add_help=True)
parser.add_argument('-u', type=str, help="username")
parser.add_argument('-p', type=str, help="password")
parser.add_argument('-proxy', type=str, help="proxy")
parser.add_argument('users', type=str, nargs='+', help='users')
args = parser.parse_args()

bot = Bot()
bot.login(username=args.u, password=args.p,
          proxy=args.proxy)

for username in args.users:
    bot.like_user(username, filtration=False)
    Dependencies:
        You must have a file with comments to post.
        The file should have one comment per line.

    Notes:
        You can change file and add there your comments.
"""

import sys
import os

sys.path.append(os.path.join(sys.path[0], '../../'))
from instabot import Bot

if len(sys.argv) < 3:
    print("USAGE: Pass a path to the file with comments and an hastag to comment")
    print("Example: %s comments_emoji.txt dog cat" % sys.argv[0])
    exit()

comments_file_name = sys.argv[1]
hashtags = sys.argv[2:]
if not os.path.exists(comments_file_name):
    print("Can't find '%s' file." % comments_file_name)
    exit()

bot = Bot(comments_file=comments_file_name)
bot.login()
for hashtag in hashtags:
    bot.comment_hashtag(hashtag)
bot.logout()