API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 11th, 2019
544
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 63.37 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from __future__ import print_function
  5. import os
  6. import sys
  7. import pickle
  8.  
  9. if (sys.version_info < (3, 0)):
  10. # Python < 3 code in this block
  11. print('Python v3.5 or above required for Instaloader module at the moment. Exiting...')
  12. quit()
  13.  
  14. import importlib
  15. try:
  16. from pip._internal import main
  17. except:
  18. print('>>> Please install the latest version of pip')
  19.  
  20.  
  21. #Required Dependencies and Modules, offer to install them automatically
  22. required_modules = ['requests', 'instaloader', 'fake_useragent', 'threading']
  23.  
  24. for modname in required_modules:
  25. try:
  26. # try to import the module normally and put it in globals
  27. globals()[modname] = importlib.import_module(modname)
  28. except ImportError as e:
  29. module_install_question = str(input("\nOne or more required modules are missing.\n Would you like to try install them automatically? (yes/no): "))
  30. if(module_install_question == "yes" or module_install_question == "y"):
  31. try:
  32. result = main(['install', '-r', 'requirements.txt', '--quiet'])
  33.  
  34. if result != 0: # if pip could not install it reraise the error
  35. print('Error installing modules. Please install manually using requirements.txt')
  36. raise
  37. else:
  38. # if the install was sucessful, put modname in globals
  39. print("Modules in requirements.txt installed successfuly. Loading...\n\n")
  40. globals()[modname] = importlib.import_module(modname)
  41. except:
  42. print('Error installing modules. Please make sure you have installed the latest version of pip.\n You can install manually using requirements.txt')
  43. raise
  44. else:
  45. print('Cannot continue without module ' + modname + '. Please install dependencies in requirements.txt. Exiting.')
  46. quit()
  47.  
  48. from .unfollow_protocol import unfollow_protocol
  49. from .userinfo import UserInfo
  50. import atexit
  51. import datetime
  52. import itertools
  53. import json
  54. import logging
  55. import random
  56. import signal
  57. import sqlite3
  58. import time
  59. import os
  60. import re
  61. from .sql_updates import check_and_update, check_already_liked
  62. from .sql_updates import check_already_followed, check_already_unfollowed
  63. from .sql_updates import insert_media, insert_username, insert_unfollow_count
  64. from .sql_updates import get_usernames_first, get_usernames, get_username_row_count, check_if_userid_exists
  65. from .sql_updates import get_username_random, get_username_to_unfollow_random
  66. from .sql_updates import check_and_insert_user_agent
  67. from fake_useragent import UserAgent
  68.  
  69.  
  70. class InstaBot:
  71. """
  72. Instagram bot v 1.2.1
  73. like_per_day=1000 - How many likes set bot in one day.
  74.  
  75. media_max_like=0 - Don't like media (photo or video) if it have more than
  76. media_max_like likes.
  77.  
  78. media_min_like=0 - Don't like media (photo or video) if it have less than
  79. media_min_like likes.
  80.  
  81. tag_list = ['cat', 'car', 'dog'] - Tag list to like.
  82.  
  83. max_like_for_one_tag=5 - Like 1 to max_like_for_one_tag times by row.
  84.  
  85. log_mod = 0 - Log mod: log_mod = 0 log to console, log_mod = 1 log to file,
  86. log_mod = 2 no log.
  87.  
  88. https://github.com/LevPasha/instabot.py
  89. """
  90. database_name = "follows_db.db"
  91. config_location = 'config.ini'
  92. session_file = None
  93. follows_db = None
  94. follows_db_c = None
  95.  
  96. url = 'https://www.instagram.com/'
  97. url_tag = 'https://www.instagram.com/explore/tags/%s/?__a=1'
  98. url_location = 'https://www.instagram.com/explore/locations/%s/?__a=1'
  99. url_likes = 'https://www.instagram.com/web/likes/%s/like/'
  100. url_unlike = 'https://www.instagram.com/web/likes/%s/unlike/'
  101. url_comment = 'https://www.instagram.com/web/comments/%s/add/'
  102. url_follow = 'https://www.instagram.com/web/friendships/%s/follow/'
  103. url_unfollow = 'https://www.instagram.com/web/friendships/%s/unfollow/'
  104. url_login = 'https://www.instagram.com/accounts/login/ajax/'
  105. url_logout = 'https://www.instagram.com/accounts/logout/'
  106. url_media_detail = 'https://www.instagram.com/p/%s/?__a=1'
  107. url_media = 'https://www.instagram.com/p/%s/'
  108. url_user_detail = 'https://www.instagram.com/%s/'
  109. api_user_detail = 'https://i.instagram.com/api/v1/users/%s/info/'
  110. instabot_repo_update = 'https://github.com/instabot-py/instabot.py/raw/master/version.txt'
  111.  
  112. user_agent = "" ""
  113. accept_language = 'en-US,en;q=0.5'
  114.  
  115. # If instagram ban you - query return 400 error.
  116. error_400 = 0
  117. # If you have 3 400 error in row - looks like you banned.
  118. error_400_to_ban = 3
  119. # If InstaBot think you are banned - going to sleep.
  120. ban_sleep_time = 2 * 60 * 60
  121.  
  122. # All counter.
  123. bot_mode = 0
  124. like_counter = 0
  125. follow_counter = 0
  126. unfollow_counter = 0
  127. comments_counter = 0
  128. current_user = 'hajka'
  129. current_index = 0
  130. current_id = 'abcds'
  131. # List of user_id, that bot follow
  132. bot_follow_list = []
  133. user_info_list = []
  134. user_list = []
  135. ex_user_list = []
  136. unwanted_username_list = []
  137. is_checked = False
  138. is_selebgram = False
  139. is_fake_account = False
  140. is_active_user = False
  141. is_following = False
  142. is_follower = False
  143. is_rejected = False
  144. is_self_checking = False
  145. is_by_tag = False
  146. is_follower_number = 0
  147.  
  148. self_following = 0
  149. self_follower = 0
  150.  
  151. # Log setting.
  152. logging.basicConfig(filename='errors.log', level=logging.INFO)
  153. log_file_path = ''
  154. log_file = 0
  155.  
  156. # Other.
  157. user_id = 0
  158. media_by_tag = 0
  159. media_on_feed = []
  160. media_by_user = []
  161. login_status = False
  162. by_location = False
  163.  
  164. # Running Times
  165. start_at_h = 0,
  166. start_at_m = 0,
  167. end_at_h = 23,
  168. end_at_m = 59,
  169.  
  170. # For new_auto_mod
  171. next_iteration = {"Like": 0, "Follow": 0, "Unfollow": 0, "Comments": 0, "Populate": 0}
  172. prog_run = True
  173.  
  174. def __init__(self,
  175. login,
  176. password,
  177. like_per_day=1000,
  178. media_max_like=150,
  179. media_min_like=0,
  180. follow_per_day=0,
  181. follow_time=5 * 60 * 60, #Cannot be zero
  182. unfollow_per_day=0,
  183. start_at_h=0,
  184. start_at_m=0,
  185. end_at_h=23,
  186. end_at_m=59,
  187. database_name='follows_db.db',
  188. config_location = 'config.ini',
  189. session_file=None,
  190. comment_list=[["this", "the", "your"],
  191. ["photo", "picture", "pic", "shot", "snapshot"],
  192. ["is", "looks", "feels", "is really"],
  193. ["great", "super", "good", "very good", "good",
  194. "wow", "WOW", "cool", "GREAT", "magnificent",
  195. "magical", "very cool", "stylish", "beautiful",
  196. "so beautiful", "so stylish", "so professional",
  197. "lovely", "so lovely", "very lovely", "glorious",
  198. "so glorious", "very glorious", "adorable",
  199. "excellent", "amazing"],
  200. [".", "..", "...", "!", "!!", "!!!"]],
  201. comments_per_day=0,
  202. tag_list=['cat', 'car', 'dog'],
  203. max_like_for_one_tag=5,
  204. unfollow_break_min=15,
  205. unfollow_break_max=30,
  206. log_mod=0,
  207. proxy="",
  208. user_blacklist={},
  209. tag_blacklist=[],
  210. unwanted_username_list=[],
  211. unfollow_whitelist=[]):
  212.  
  213. self.session_file = session_file
  214. self.database_name = database_name
  215. self.config_location = config_location
  216. self.follows_db = sqlite3.connect(database_name, timeout=0, isolation_level=None)
  217. self.follows_db_c = self.follows_db.cursor()
  218. check_and_update(self)
  219. fake_ua = UserAgent()
  220. self.user_agent = check_and_insert_user_agent(self, str(fake_ua.random))
  221. self.bot_start = datetime.datetime.now()
  222. self.bot_start_ts = time.time()
  223. self.start_at_h = start_at_h
  224. self.start_at_m = start_at_m
  225. self.end_at_h = end_at_h
  226. self.end_at_m = end_at_m
  227. self.unfollow_break_min = unfollow_break_min
  228. self.unfollow_break_max = unfollow_break_max
  229. self.user_blacklist = user_blacklist
  230. self.tag_blacklist = tag_blacklist
  231. self.unfollow_whitelist = unfollow_whitelist
  232. self.comment_list = comment_list
  233. self.instaloader = instaloader.Instaloader()
  234.  
  235. self.time_in_day = 24 * 60 * 60
  236. # Like
  237. self.like_per_day = like_per_day
  238. if self.like_per_day != 0:
  239. self.like_delay = self.time_in_day / self.like_per_day
  240.  
  241. # Follow
  242. self.follow_time = follow_time #Cannot be zero
  243. self.follow_per_day = follow_per_day
  244. if self.follow_per_day != 0:
  245. self.follow_delay = self.time_in_day / self.follow_per_day
  246.  
  247. # Unfollow
  248. self.unfollow_per_day = unfollow_per_day
  249. if self.unfollow_per_day != 0:
  250. self.unfollow_delay = self.time_in_day / self.unfollow_per_day
  251.  
  252. # Comment
  253. self.comments_per_day = comments_per_day
  254. if self.comments_per_day != 0:
  255. self.comments_delay = self.time_in_day / self.comments_per_day
  256.  
  257. # Don't like if media have more than n likes.
  258. self.media_max_like = media_max_like
  259. # Don't like if media have less than n likes.
  260. self.media_min_like = media_min_like
  261. # Auto mod seting:
  262. # Default list of tag.
  263. self.tag_list = tag_list
  264. # Get random tag, from tag_list, and like (1 to n) times.
  265. self.max_like_for_one_tag = max_like_for_one_tag
  266. # log_mod 0 to console, 1 to file
  267. self.log_mod = log_mod
  268. self.s = requests.Session()
  269. self.c = requests.Session()
  270. # if you need proxy make something like this:
  271. # self.s.proxies = {"https" : "http://proxyip:proxyport"}
  272. # by @ageorgios
  273. if proxy != "":
  274. proxies = {
  275. 'http': 'http://' + proxy,
  276. 'https': 'http://' + proxy,
  277. }
  278. self.s.proxies.update(proxies)
  279. self.c.proxies.update(proxies)
  280. # convert login to lower
  281. self.user_login = login.lower()
  282. self.user_password = password
  283. self.bot_mode = 0
  284. self.media_by_tag = []
  285. self.media_on_feed = []
  286. self.media_by_user = []
  287. self.current_user_info = ''
  288. self.unwanted_username_list = unwanted_username_list
  289. now_time = datetime.datetime.now()
  290. self.check_for_bot_update()
  291. log_string = 'Instabot v1.2.1/0 started at %s:' % \
  292. (now_time.strftime("%d.%m.%Y %H:%M"))
  293. self.write_log(log_string)
  294. self.login()
  295. self.populate_user_blacklist()
  296. signal.signal(signal.SIGINT, self.cleanup)
  297. signal.signal(signal.SIGTERM, self.cleanup)
  298. atexit.register(self.cleanup)
  299. self.instaload = instaloader.Instaloader()
  300.  
  301. def check_for_bot_update(self):
  302. self.write_log('Checking for updates...')
  303.  
  304. try:
  305. updated_timestamp = self.c.get(self.instabot_repo_update) #CHANGE THIS TO OFFICIAL REPO IF KEPT
  306. current_version_timestamp = open('version.txt','r')
  307. if(int(updated_timestamp.text) > int(current_version_timestamp.read()) ):
  308. self.write_log('>>> UPDATE AVAILABLE <<< Please update Instabot. You are running an older version.')
  309. else:
  310. self.write_log('You are running the latest stable version')
  311. except:
  312. self.write_log('Could not check for updates')
  313.  
  314. def populate_user_blacklist(self):
  315. for user in self.user_blacklist:
  316. user_id_url = self.url_user_detail % (user)
  317. info = self.s.get(user_id_url)
  318.  
  319. # prevent error if 'Account of user was deleted or link is invalid
  320. from json import JSONDecodeError
  321. try:
  322. all_data = json.loads(info.text)
  323. except JSONDecodeError as e:
  324. self.write_log('Account of user %s was deleted or link is '
  325. 'invalid' % (user))
  326. else:
  327. # prevent exception if user have no media
  328. id_user = all_data['user']['id']
  329. # Update the user_name with the user_id
  330. self.user_blacklist[user] = id_user
  331. log_string = "Blacklisted user %s added with ID: %s" % (user,
  332. id_user)
  333. self.write_log(log_string)
  334. time.sleep(5 * random.random())
  335.  
  336. def login(self):
  337. log_string = 'Trying to login as %s...' % (self.user_login)
  338.  
  339. successfulLogin = False
  340.  
  341. self.s.headers.update({
  342. 'Accept': '*/*',
  343. 'Accept-Language': self.accept_language,
  344. 'Accept-Encoding': 'gzip, deflate, br',
  345. 'Connection': 'keep-alive',
  346. 'Host': 'www.instagram.com',
  347. 'Origin': 'https://www.instagram.com',
  348. 'Referer': 'https://www.instagram.com/',
  349. 'User-Agent': self.user_agent,
  350. 'X-Instagram-AJAX': '1',
  351. 'Content-Type': 'application/x-www-form-urlencoded',
  352. 'X-Requested-With': 'XMLHttpRequest'
  353. })
  354.  
  355. if self.session_file != None and os.path.isfile(self.session_file):
  356. self.write_log("Found session file %s" % self.session_file)
  357. successfulLogin = True
  358. with open(self.session_file, 'rb') as i:
  359. cookies = pickle.load(i)
  360. self.s.cookies.update(cookies)
  361. else:
  362. self.write_log(log_string)
  363. self.login_post = {
  364. 'username': self.user_login,
  365. 'password': self.user_password
  366. }
  367.  
  368. r = self.s.get(self.url)
  369. csrf_token = re.search('(?<=\"csrf_token\":\")\w+', r.text).group(0)
  370. self.s.headers.update({'X-CSRFToken': csrf_token})
  371. time.sleep(5 * random.random())
  372. login = self.s.post(
  373. self.url_login, data=self.login_post, allow_redirects=True)
  374. loginResponse = login.json()
  375. successfulLogin = login.status_code == 200
  376. try:
  377. if successfulLogin:
  378. self.csrftoken = login.cookies['csrftoken']
  379. self.s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
  380. except:
  381. self.write_log('Something wrong with login')
  382. self.write_log(login.text)
  383. if loginResponse.get('errors'):
  384. self.write_log('Something is wrong with Instagram! Please try again later...')
  385. for error in loginResponse['errors']['error']:
  386. self.write_log('Error => ' + error)
  387. return
  388. if loginResponse.get('message') == 'checkpoint_required':
  389. try:
  390. if 'instagram.com' in loginResponse['checkpoint_url']:
  391. challenge_url = loginResponse['checkpoint_url']
  392. else:
  393. challenge_url = 'https://instagram.com' + loginResponse['checkpoint_url']
  394. self.write_log('Challenge required at ' + challenge_url)
  395. with self.s as clg:
  396. clg.headers.update({
  397. 'Accept': '*/*',
  398. 'Accept-Language': self.accept_language,
  399. 'Accept-Encoding': 'gzip, deflate, br',
  400. 'Connection': 'keep-alive',
  401. 'Host': 'www.instagram.com',
  402. 'Origin': 'https://www.instagram.com',
  403. 'User-Agent': self.user_agent,
  404. 'X-Instagram-AJAX': '1',
  405. 'Content-Type': 'application/x-www-form-urlencoded',
  406. 'x-requested-with': "XMLHttpRequest",
  407. })
  408. #Get challenge page
  409. challenge_request_explore = clg.get(challenge_url)
  410.  
  411. #Get CSRF Token from challenge page
  412. challenge_csrf_token = re.search('(?<=\"csrf_token\":\")\w+', challenge_request_explore.text).group(0)
  413. #Get Rollout Hash from challenge page
  414. rollout_hash = re.search('(?<=\"rollout_hash\":\")\w+', challenge_request_explore.text).group(0)
  415.  
  416. #Ask for option 1 from challenge, which is usually Email or Phone
  417. challenge_post = {
  418. 'choice': 1
  419. }
  420.  
  421.  
  422. #Update headers for challenge submit page
  423. clg.headers.update({'X-CSRFToken': challenge_csrf_token})
  424. clg.headers.update({'Referer': challenge_url})
  425.  
  426. #Request instagram to send a code
  427. challenge_request_code = clg.post(challenge_url, data=challenge_post, allow_redirects=True)
  428.  
  429. #User should receive a code soon, ask for it
  430. challenge_userinput_code = input("Challenge Required.\n\nEnter the code sent to your mail/phone: ")
  431. challenge_security_post = {
  432. 'security_code': challenge_userinput_code
  433. }
  434. clg.headers.update({'Content-Type': 'application/x-www-form-urlencoded'})
  435.  
  436. complete_challenge = clg.post(challenge_url, data=challenge_security_post, allow_redirects=True)
  437. if complete_challenge.status_code != 200:
  438. self.write_log('Entered code is wrong, Try again later!')
  439. return
  440. self.csrftoken = complete_challenge.cookies['csrftoken']
  441. self.s.headers.update({'X-CSRFToken': self.csrftoken, 'X-Instagram-AJAX': '1'})
  442. successfulLogin = complete_challenge.status_code == 200
  443.  
  444. except Exception as err:
  445. print("Login failed, response: \n\n" + login.text, err)
  446. quit()
  447.  
  448. else:
  449. rollout_hash = re.search('(?<=\"rollout_hash\":\")\w+', r.text).group(0)
  450. self.s.headers.update({'X-Instagram-AJAX': rollout_hash})
  451. #ig_vw=1536; ig_pr=1.25; ig_vh=772; ig_or=landscape-primary;
  452. self.s.cookies['csrftoken'] = self.csrftoken
  453. self.s.cookies['ig_vw'] = '1536'
  454. self.s.cookies['ig_pr'] = '1.25'
  455. self.s.cookies['ig_vh'] = '772'
  456. self.s.cookies['ig_or'] = 'landscape-primary'
  457. time.sleep(5 * random.random())
  458.  
  459.  
  460. if successfulLogin:
  461. r = self.s.get('https://www.instagram.com/')
  462. self.csrftoken = re.search('(?<=\"csrf_token\":\")\w+', r.text).group(0)
  463. self.s.cookies['csrftoken'] = self.csrftoken
  464. self.s.headers.update({'X-CSRFToken': self.csrftoken})
  465. finder = r.text.find(self.user_login)
  466. if finder != -1:
  467. ui = UserInfo()
  468. self.user_id = ui.get_user_id_by_login(self.user_login)
  469. self.login_status = True
  470. log_string = "%s login success!\n" % (self.user_login)
  471. self.write_log(log_string)
  472. if self.session_file != None:
  473. self.write_log("Saving cookies to session file %s" % self.session_file)
  474. with open(self.session_file, 'wb') as output:
  475. pickle.dump(self.s.cookies, output, pickle.HIGHEST_PROTOCOL)
  476. else:
  477. self.login_status = False
  478. self.write_log('Login error! Check your login data!')
  479. if self.session_file != None and os.path.isfile(self.session_file):
  480. try:
  481. os.remove(self.session_file)
  482. except:
  483. self.write_log("Could not delete session file. Please delete manually")
  484.  
  485. self.prog_run = False;
  486. else:
  487. self.write_log('Login error! Connection error!')
  488.  
  489. def logout(self):
  490. now_time = datetime.datetime.now()
  491. log_string = 'Logout: likes - %i, follow - %i, unfollow - %i, comments - %i.' % \
  492. (self.like_counter, self.follow_counter,
  493. self.unfollow_counter, self.comments_counter)
  494. self.write_log(log_string)
  495. work_time = datetime.datetime.now() - self.bot_start
  496. log_string = 'Bot work time: %s' % (work_time)
  497. self.write_log(log_string)
  498.  
  499. try:
  500. logout_post = {'csrfmiddlewaretoken': self.csrftoken}
  501. logout = self.s.post(self.url_logout, data=logout_post)
  502. self.write_log("Logout success!")
  503. self.login_status = False
  504. except:
  505. logging.exception("Logout error!")
  506.  
  507. def cleanup(self, *_):
  508. # Unfollow all bot follow
  509. if self.follow_counter >= self.unfollow_counter:
  510. for i in range(len(self.bot_follow_list)):
  511. f = self.bot_follow_list[0]
  512. if check_already_unfollowed(self, f[0]):
  513. log_string = "Already unfollowed before, skipping: %s" % (f[0])
  514. self.write_log(log_string)
  515. else:
  516. log_string = "Trying to unfollow: %s" % (f[0])
  517. self.write_log(log_string)
  518. self.unfollow_on_cleanup(f[0])
  519. sleeptime = random.randint(self.unfollow_break_min,
  520. self.unfollow_break_max)
  521. log_string = "Pausing for %i seconds... %i of %i" % (
  522. sleeptime, self.unfollow_counter, self.follow_counter)
  523. self.write_log(log_string)
  524. time.sleep(sleeptime)
  525. self.bot_follow_list.remove(f)
  526.  
  527. # Logout
  528. if self.login_status and self.session_file == None:
  529. self.logout()
  530. self.prog_run = False
  531.  
  532. # Start again CUSTOM
  533. print (self.config_location)
  534. if (self.config_location == "config_2.ini"):
  535. os.system('python "instabot.py" ' + self.user_login)
  536. else:
  537. os.system('python "instabot.py" ' + self.user_login + ' 2')
  538.  
  539. def get_media_id_by_tag(self, tag):
  540. """ Get media ID set, by your hashtag or location """
  541.  
  542. if self.login_status:
  543. if tag.startswith('l:'):
  544. tag = tag.replace('l:', '')
  545. self.by_location = True
  546. log_string = "Get Media by location: %s" % (tag)
  547. self.write_log(log_string)
  548. if self.login_status == 1:
  549. url_location = self.url_location % (tag)
  550. try:
  551. r = self.s.get(url_location)
  552. all_data = json.loads(r.text)
  553. self.media_by_tag = list(all_data['graphql']['location']['edge_location_to_media']['edges'])
  554. except:
  555. self.media_by_tag = []
  556. self.write_log("Except on get_media!")
  557. logging.exception("get_media_id_by_tag")
  558. else:
  559. return 0
  560.  
  561. else:
  562. log_string = "Get Media by tag: %s" % (tag)
  563. self.by_location = False
  564. self.write_log(log_string)
  565. if self.login_status == 1:
  566. url_tag = self.url_tag % (tag)
  567. try:
  568. r = self.s.get(url_tag)
  569. all_data = json.loads(r.text)
  570. self.media_by_tag = list(all_data['graphql']['hashtag']['edge_hashtag_to_media']['edges'])
  571. except:
  572. self.media_by_tag = []
  573. self.write_log("Except on get_media!")
  574. logging.exception("get_media_id_by_tag")
  575. else:
  576. return 0
  577.  
  578. def get_instagram_url_from_media_id(self, media_id, url_flag=True, only_code=None):
  579. """ Get Media Code or Full Url from Media ID Thanks to Nikished """
  580. media_id = int(media_id)
  581. if url_flag is False: return ""
  582. else:
  583. alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
  584. shortened_id = ''
  585. while media_id > 0:
  586. media_id, idx = divmod(media_id, 64)
  587. shortened_id = alphabet[idx] + shortened_id
  588. if only_code: return shortened_id
  589. else: return 'instagram.com/p/' + shortened_id + '/'
  590.  
  591. def get_username_by_media_id(self, media_id):
  592. """ Get username by media ID Thanks to Nikished """
  593.  
  594. if self.login_status:
  595. if self.login_status == 1:
  596. media_id_url = self.get_instagram_url_from_media_id(int(media_id), only_code=True)
  597. url_media = self.url_media_detail % (media_id_url)
  598. try:
  599. r = self.s.get(url_media)
  600. all_data = json.loads(r.text)
  601.  
  602. username = str(all_data['graphql']['shortcode_media']['owner']['username'])
  603. self.write_log("media_id=" + media_id + ", media_id_url=" +
  604. media_id_url + ", username_by_media_id=" + username)
  605. return username
  606. except:
  607. logging.exception("username_by_mediaid exception")
  608. return False
  609. else:
  610. return ""
  611.  
  612. def get_username_by_user_id(self, user_id):
  613. if self.login_status:
  614. try:
  615. profile = instaloader.Profile.from_id(self.instaload.context, user_id)
  616. username = profile.username
  617. return username
  618. except:
  619. logging.exception("Except on get_username_by_user_id")
  620. return False
  621. else:
  622. return False
  623.  
  624. def get_userinfo_by_name(self, username):
  625. """ Get user info by name """
  626.  
  627. if self.login_status:
  628. if self.login_status == 1:
  629. url_info = self.url_user_detail % (username)
  630. try:
  631. r = self.s.get(url_info)
  632. all_data = json.loads(r.text)
  633. user_info = all_data['user']
  634. follows = user_info['follows']['count']
  635. follower = user_info['followed_by']['count']
  636. follow_viewer = user_info['follows_viewer']
  637. if follower > 3000 or follows > 1500:
  638. self.write_log(' >>>This is probably Selebgram, Business or Fake account')
  639. if follow_viewer:
  640. return None
  641. return user_info
  642. except:
  643. logging.exception("Except on get_userinfo_by_name")
  644. return False
  645. else:
  646. return False
  647.  
  648. def like_all_exist_media(self, media_size=-1, delay=True):
  649. """ Like all media ID that have self.media_by_tag """
  650.  
  651. if self.login_status:
  652. if self.media_by_tag != 0:
  653. i = 0
  654. for d in self.media_by_tag:
  655. # Media count by this tag.
  656. if media_size > 0 or media_size < 0:
  657. media_size -= 1
  658. l_c = self.media_by_tag[i]['node']['edge_liked_by']['count']
  659. if ((l_c <= self.media_max_like and
  660. l_c >= self.media_min_like) or
  661. (self.media_max_like == 0 and
  662. l_c >= self.media_min_like) or
  663. (self.media_min_like == 0 and
  664. l_c <= self.media_max_like) or
  665. (self.media_min_like == 0 and
  666. self.media_max_like == 0)):
  667. for blacklisted_user_name, blacklisted_user_id in self.user_blacklist.items(
  668. ):
  669. if self.media_by_tag[i]['node']['owner'][
  670. 'id'] == blacklisted_user_id:
  671. self.write_log(
  672. "Not liking media owned by blacklisted user: "
  673. + blacklisted_user_name)
  674. return False
  675. if self.media_by_tag[i]['node']['owner'][
  676. 'id'] == self.user_id:
  677. self.write_log(
  678. "Keep calm - It's your own media ;)")
  679. return False
  680. if check_already_liked(self, media_id=self.media_by_tag[i]['node']['id']) == 1:
  681. self.write_log("Keep calm - It's already liked ;)")
  682. return False
  683. try:
  684. if (len(self.media_by_tag[i]['node']['edge_media_to_caption']['edges']) > 1):
  685. caption = self.media_by_tag[i]['node']['edge_media_to_caption'][
  686. 'edges'][0]['node']['text'].encode(
  687. 'ascii', errors='ignore')
  688. tag_blacklist = set(self.tag_blacklist)
  689. if sys.version_info[0] == 3:
  690. tags = {
  691. str.lower(
  692. (tag.decode('ASCII')).strip('#'))
  693. for tag in caption.split()
  694. if (tag.decode('ASCII')
  695. ).startswith("#")
  696. }
  697. else:
  698. tags = {
  699. unicode.lower(
  700. (tag.decode('ASCII')).strip('#'))
  701. for tag in caption.split()
  702. if (tag.decode('ASCII')
  703. ).startswith("#")
  704. }
  705.  
  706. if tags.intersection(tag_blacklist):
  707. matching_tags = ', '.join(
  708. tags.intersection(tag_blacklist))
  709. self.write_log(
  710. "Not liking media with blacklisted tag(s): "
  711. + matching_tags)
  712. return False
  713. except:
  714. logging.exception("Except on like_all_exist_media")
  715. return False
  716.  
  717. log_string = "Trying to like media: %s" % \
  718. (self.media_by_tag[i]['node']['id'])
  719. self.write_log(log_string)
  720. like = self.like(self.media_by_tag[i]['node']['id'])
  721. # comment = self.comment(self.media_by_tag[i]['id'], 'Cool!')
  722. # follow = self.follow(self.media_by_tag[i]["owner"]["id"])
  723. if like != 0:
  724. if like.status_code == 200:
  725. # Like, all ok!
  726. self.error_400 = 0
  727. self.like_counter += 1
  728. log_string = "Liked: %s. Like #%i." % \
  729. (self.media_by_tag[i]['node']['id'],
  730. self.like_counter)
  731. insert_media(self,
  732. media_id=self.media_by_tag[i]['node']['id'],
  733. status="200")
  734. self.write_log(log_string)
  735. elif like.status_code == 400:
  736. log_string = "Not liked: %i" \
  737. % (like.status_code)
  738. self.write_log(log_string)
  739. insert_media(self,
  740. media_id=self.media_by_tag[i]['node']['id'],
  741. status="400")
  742. # Some error. If repeated - can be ban!
  743. if self.error_400 >= self.error_400_to_ban:
  744. # Look like you banned!
  745. time.sleep(self.ban_sleep_time)
  746. else:
  747. self.error_400 += 1
  748. else:
  749. log_string = "Not liked: %i" \
  750. % (like.status_code)
  751. insert_media(self,
  752. media_id=self.media_by_tag[i]['node']['id'],
  753. status=str(like.status_code))
  754. self.write_log(log_string)
  755. return False
  756. # Some error.
  757. i += 1
  758. if delay:
  759. time.sleep(self.like_delay * 0.9 +
  760. self.like_delay * 0.2 *
  761. random.random())
  762. else:
  763. return True
  764. else:
  765. return False
  766. else:
  767. return False
  768. else:
  769. return False
  770. else:
  771. self.write_log("No media to like!")
  772.  
  773. def like(self, media_id):
  774. """ Send http request to like media by ID """
  775. if self.login_status:
  776. url_likes = self.url_likes % (media_id)
  777. try:
  778. like = self.s.post(url_likes)
  779. last_liked_media_id = media_id
  780. except:
  781. logging.exception("Except on like!")
  782. like = 0
  783. return like
  784.  
  785. def unlike(self, media_id):
  786. """ Send http request to unlike media by ID """
  787. if self.login_status:
  788. url_unlike = self.url_unlike % (media_id)
  789. try:
  790. unlike = self.s.post(url_unlike)
  791. except:
  792. logging.exception("Except on unlike!")
  793. unlike = 0
  794. return unlike
  795.  
  796. def comment(self, media_id, comment_text):
  797. """ Send http request to comment """
  798. if self.login_status:
  799. comment_post = {'comment_text': comment_text}
  800. url_comment = self.url_comment % (media_id)
  801. try:
  802. comment = self.s.post(url_comment, data=comment_post)
  803. if comment.status_code == 200:
  804. self.comments_counter += 1
  805. log_string = 'Write: "%s". #%i.' % (comment_text,
  806. self.comments_counter)
  807. self.write_log(log_string)
  808. return comment
  809. except:
  810. logging.exception("Except on comment!")
  811. return False
  812.  
  813. def follow(self, user_id):
  814. """ Send http request to follow """
  815. if self.login_status:
  816. url_follow = self.url_follow % (user_id)
  817. try:
  818. follow = self.s.post(url_follow)
  819. if follow.status_code == 200:
  820. self.follow_counter += 1
  821. log_string = "Followed: %s #%i." % (user_id,
  822. self.follow_counter)
  823. self.write_log(log_string)
  824. username = self.get_username_by_user_id(user_id=user_id)
  825. insert_username(self, user_id=user_id, username=username)
  826. return follow
  827. except:
  828. logging.exception("Except on follow!")
  829. return False
  830.  
  831. def unfollow(self, user_id):
  832. """ Send http request to unfollow """
  833. if self.login_status:
  834. url_unfollow = self.url_unfollow % (user_id)
  835. try:
  836. unfollow = self.s.post(url_unfollow)
  837. if unfollow.status_code == 200:
  838. self.unfollow_counter += 1
  839. log_string = "Unfollowed: %s #%i." % (user_id,
  840. self.unfollow_counter)
  841. self.write_log(log_string)
  842. insert_unfollow_count(self, user_id=user_id)
  843. return unfollow
  844. except:
  845. logging.exception("Exept on unfollow!")
  846. return False
  847.  
  848. def unfollow_on_cleanup(self, user_id):
  849. """ Unfollow on cleanup by @rjmayott """
  850. if self.login_status:
  851. url_unfollow = self.url_unfollow % (user_id)
  852. try:
  853. unfollow = self.s.post(url_unfollow)
  854. if unfollow.status_code == 200:
  855. self.unfollow_counter += 1
  856. log_string = "Unfollow: %s #%i of %i." % (
  857. user_id, self.unfollow_counter, self.follow_counter)
  858. self.write_log(log_string)
  859. insert_unfollow_count(self, user_id=user_id)
  860. else:
  861. log_string = "Slow Down - Pausing for 5 minutes so we don't get banned!"
  862. self.write_log(log_string)
  863. time.sleep(300)
  864. unfollow = self.s.post(url_unfollow)
  865. if unfollow.status_code == 200:
  866. self.unfollow_counter += 1
  867. log_string = "Unfollow: %s #%i of %i." % (
  868. user_id, self.unfollow_counter,
  869. self.follow_counter)
  870. self.write_log(log_string)
  871. insert_unfollow_count(self, user_id=user_id)
  872. else:
  873. log_string = "Still no good :( Skipping and pausing for another 5 minutes"
  874. self.write_log(log_string)
  875. time.sleep(300)
  876. return False
  877. return unfollow
  878. except:
  879. log_string = "Except on unfollow... Looks like a network error"
  880. logging.exception(log_string)
  881. return False
  882.  
  883. def auto_mod(self):
  884. """ Star loop, that get media ID by your tag list, and like it """
  885. if self.login_status:
  886. while self.prog_run:
  887. random.shuffle(self.tag_list)
  888. self.get_media_id_by_tag(random.choice(self.tag_list))
  889. self.like_all_exist_media(random.randint \
  890. (1, self.max_like_for_one_tag))
  891. self.write_log("Exit Program... GoodBye")
  892. sys.exit(0)
  893.  
  894. def new_auto_mod(self):
  895. while self.prog_run and self.login_status:
  896. now = datetime.datetime.now()
  897. if (
  898. datetime.time(self.start_at_h, self.start_at_m) <= now.time()
  899. and now.time() <= datetime.time(self.end_at_h, self.end_at_m)
  900. ):
  901. # ------------------- Get media_id -------------------
  902. if len(self.media_by_tag) == 0:
  903. self.get_media_id_by_tag(random.choice(self.tag_list))
  904. self.this_tag_like_count = 0
  905. self.max_tag_like_count = random.randint(
  906. 1, self.max_like_for_one_tag)
  907. self.remove_already_liked()
  908. # ------------------- Like -------------------
  909. self.new_auto_mod_like()
  910. # ------------------- Follow -------------------
  911. self.new_auto_mod_follow()
  912. # ------------------- Unfollow -------------------
  913. self.new_auto_mod_unfollow()
  914. # ------------------- Comment -------------------
  915. self.new_auto_mod_comments()
  916. # Bot iteration in 1 sec
  917. time.sleep(3)
  918. # print("Tic!")
  919. else:
  920. print("!!sleeping until {hour}:{min}".format(hour=self.start_at_h,
  921. min=self.start_at_m), end="\r")
  922. time.sleep(100)
  923. self.write_log("Exit Program... GoodBye")
  924. sys.exit(0)
  925.  
  926. def remove_already_liked(self):
  927. self.write_log("Removing already liked medias..")
  928. x = 0
  929. while x < len(self.media_by_tag):
  930. if check_already_liked(self, media_id=self.media_by_tag[x]['node']['id']) == 1:
  931. self.media_by_tag.remove(self.media_by_tag[x])
  932. else:
  933. x += 1
  934.  
  935. def new_auto_mod_like(self):
  936. if time.time() > self.next_iteration["Like"] and self.like_per_day != 0 \
  937. and len(self.media_by_tag) > 0:
  938. # You have media_id to like:
  939. if self.like_all_exist_media(media_size=1, delay=False):
  940. # If like go to sleep:
  941. self.next_iteration["Like"] = time.time() + \
  942. self.add_time(self.like_delay)
  943. # Count this tag likes:
  944. self.this_tag_like_count += 1
  945. if self.this_tag_like_count >= self.max_tag_like_count:
  946. self.media_by_tag = [0]
  947. # Del first media_id
  948. try:
  949. del self.media_by_tag[0]
  950. except:
  951. print('Could not remove media')
  952.  
  953. def new_auto_mod_follow(self):
  954. if time.time() < self.next_iteration["Follow"]:
  955. return
  956. if time.time() > self.next_iteration["Follow"] and \
  957. self.follow_per_day != 0 and len(self.media_by_tag) > 0:
  958. if self.media_by_tag[0]['node']["owner"]["id"] == self.user_id:
  959. self.write_log("Keep calm - It's your own profile ;)")
  960. return
  961. if check_already_followed(self, user_id=self.media_by_tag[0]['node']["owner"]["id"]) == 1:
  962. self.write_log("Already followed before " + self.media_by_tag[0]['node']["owner"]["id"])
  963. self.next_iteration["Follow"] = time.time() + \
  964. self.add_time(self.follow_delay/2)
  965. return
  966.  
  967. log_string = "Trying to follow: %s" % (
  968. self.media_by_tag[0]['node']["owner"]["id"])
  969. self.write_log(log_string)
  970. self.next_iteration["Follow"] = time.time() + \
  971. self.add_time(self.follow_delay)
  972.  
  973. if self.follow(self.media_by_tag[0]['node']["owner"]["id"]) != False:
  974. self.bot_follow_list.append(
  975. [self.media_by_tag[0]['node']["owner"]["id"], time.time()])
  976. self.next_iteration["Follow"] = time.time() + \
  977. self.add_time(self.follow_delay)
  978.  
  979.  
  980. def populate_from_feed(self):
  981. self.get_media_id_recent_feed()
  982.  
  983. try:
  984. for mediafeed_user in self.media_on_feed:
  985. feed_username = mediafeed_user["node"]["owner"]["username"]
  986. feed_user_id = mediafeed_user["node"]["owner"]["id"]
  987. #print(check_if_userid_exists(self, userid=feed_user_id))
  988. if check_if_userid_exists(self, userid=feed_user_id) is False:
  989. insert_username(self, user_id=feed_user_id, username=feed_username)
  990. self.write_log("Inserted user "+feed_username+" from recent feed")
  991. except:
  992. self.write_log("Notice: could not populate from recent feed")
  993.  
  994.  
  995.  
  996. def new_auto_mod_unfollow(self):
  997. if time.time() > self.next_iteration["Unfollow"] and self.unfollow_per_day != 0:
  998.  
  999. if (time.time() - self.bot_start_ts) < 30:
  1000. #let bot initialize
  1001. return
  1002. if get_username_row_count(self) < 20:
  1003. self.write_log(' >>>Waiting for database to populate before unfollowing (progress '+str(get_username_row_count(self))+"/20)\n (Will try to populate using recent feed)")
  1004. self.populate_from_feed()
  1005.  
  1006. self.next_iteration["Unfollow"] = time.time() + \
  1007. (self.add_time(self.unfollow_delay)/2)
  1008. return #DB doesn't have enough followers yet
  1009.  
  1010. if self.bot_mode == 0 or self.bot_mode == 3:
  1011.  
  1012. try:
  1013. if time.time() > self.next_iteration["Populate"]:
  1014. self.populate_from_feed()
  1015. self.next_iteration["Populate"] = time.time() + \
  1016. (self.add_time(360))
  1017. except:
  1018. self.write_log('Notice: Could not populate from recent feed right now')
  1019.  
  1020.  
  1021. log_string = "Trying to unfollow #%i: " % (self.unfollow_counter + 1)
  1022. self.write_log(log_string)
  1023. self.auto_unfollow()
  1024. self.next_iteration["Unfollow"] = time.time() + \
  1025. self.add_time(self.unfollow_delay)
  1026. if self.bot_mode == 1:
  1027. unfollow_protocol(self)
  1028.  
  1029. def new_auto_mod_comments(self):
  1030. if time.time() > self.next_iteration["Comments"] and self.comments_per_day != 0 \
  1031. and len(self.media_by_tag) > 0 \
  1032. and self.check_exisiting_comment(self.media_by_tag[0]['node']['shortcode']) == False:
  1033. comment_text = self.generate_comment()
  1034. log_string = "Trying to comment: %s" % (self.media_by_tag[0]['node']['id'])
  1035. self.write_log(log_string)
  1036. if self.comment(self.media_by_tag[0]['node']['id'], comment_text) != False:
  1037. self.next_iteration["Comments"] = time.time() + \
  1038. self.add_time(self.comments_delay)
  1039.  
  1040. def add_time(self, time):
  1041. """ Make some random for next iteration"""
  1042. return time * 0.9 + time * 0.2 * random.random()
  1043.  
  1044. def generate_comment(self):
  1045. c_list = list(itertools.product(*self.comment_list))
  1046.  
  1047. repl = [(" ", " "), (" .", "."), (" !", "!")]
  1048. res = " ".join(random.choice(c_list))
  1049. for s, r in repl:
  1050. res = res.replace(s, r)
  1051. return res.capitalize()
  1052.  
  1053. def check_exisiting_comment(self, media_code):
  1054. try:
  1055. url_check = self.url_media % (media_code)
  1056. check_comment = self.s.get(url_check)
  1057. if check_comment.status_code == 200:
  1058. all_data = json.loads(re.search('window._sharedData = (.*?);', check_comment.text, re.DOTALL).group(1))['entry_data']['PostPage'][0] #window._sharedData = (.*?);
  1059. if all_data['graphql']['shortcode_media']['owner']['id'] == self.user_id:
  1060. self.write_log("Keep calm - It's your own media ;)")
  1061. # Del media to don't loop on it
  1062. del self.media_by_tag[0]
  1063. return True
  1064. try:
  1065. comment_list = list(all_data['graphql']['shortcode_media']['edge_media_to_comment']['edges'])
  1066. except:
  1067. comment_list = list(all_data['graphql']['shortcode_media']['edge_media_to_parent_comment']['edges'])
  1068.  
  1069. for d in comment_list:
  1070. if d['node']['owner']['id'] == self.user_id:
  1071. self.write_log("Keep calm - Media already commented ;)")
  1072. # Del media to don't loop on it
  1073. del self.media_by_tag[0]
  1074. return True
  1075. return False
  1076. else:
  1077. insert_media(self, self.media_by_tag[0]['node']['id'], str(check_comment.status_code))
  1078. self.media_by_tag.remove(self.media_by_tag[0])
  1079. return False
  1080. except:
  1081. print ("check_exisiting_comment() EXCEPTION!!")
  1082. return True
  1083.  
  1084. def auto_unfollow(self):
  1085. checking = True
  1086. while checking:
  1087. username_row = get_username_to_unfollow_random(self)
  1088. if not username_row:
  1089. self.write_log("Looks like there is nobody to unfollow.")
  1090. return False
  1091. current_id = username_row[0]
  1092. current_user = username_row[1]
  1093. unfollow_count = username_row[2]
  1094.  
  1095. if not current_user:
  1096. current_user = self.get_username_by_user_id(user_id=current_id)
  1097. if not current_user:
  1098. log_string = "api limit reached from instagram. Will try later"
  1099. self.write_log(log_string)
  1100. return False
  1101. for wluser in self.unfollow_whitelist:
  1102. if wluser == current_user:
  1103. log_string = (
  1104. "found whitelist user, starting search again")
  1105. self.write_log(log_string)
  1106. break
  1107. else:
  1108. checking = False
  1109.  
  1110. if self.login_status:
  1111. log_string = "Getting user info : %s" % current_user
  1112. self.write_log(log_string)
  1113. if self.login_status == 1:
  1114. url_tag = self.url_user_detail % (current_user)
  1115. try:
  1116. r = self.s.get(url_tag)
  1117. if r.text.find('The link you followed may be broken, or the page may have been removed.') != -1:
  1118. log_string = "Looks like account was deleted, skipping : %s" % current_user
  1119. self.write_log(log_string)
  1120. insert_unfollow_count(self, user_id=current_id)
  1121. time.sleep(3)
  1122. return False
  1123. all_data = json.loads(re.search('window._sharedData = (.*?);</script>', r.text, re.DOTALL).group(1))['entry_data']['ProfilePage'][0]
  1124.  
  1125. user_info = all_data['graphql']['user']
  1126. i = 0
  1127. log_string = "Checking user info.."
  1128. self.write_log(log_string)
  1129.  
  1130. follows = user_info['edge_follow']['count']
  1131. follower = user_info['edge_followed_by']['count']
  1132. media = user_info['edge_owner_to_timeline_media']['count']
  1133. follow_viewer = user_info['follows_viewer']
  1134. followed_by_viewer = user_info[
  1135. 'followed_by_viewer']
  1136. requested_by_viewer = user_info[
  1137. 'requested_by_viewer']
  1138. has_requested_viewer = user_info[
  1139. 'has_requested_viewer']
  1140. log_string = "Follower : %i" % (follower)
  1141. self.write_log(log_string)
  1142. log_string = "Following : %s" % (follows)
  1143. self.write_log(log_string)
  1144. log_string = "Media : %i" % (media)
  1145. self.write_log(log_string)
  1146. if follows == 0 or follower / follows > 2:
  1147. self.is_selebgram = True
  1148. self.is_fake_account = False
  1149. self.write_log(' >>>This is probably Selebgram account')
  1150.  
  1151. elif follower == 0 or follows / follower > 2:
  1152. self.is_fake_account = True
  1153. self.is_selebgram = False
  1154. self.write_log(' >>>This is probably Fake account')
  1155. else:
  1156. self.is_selebgram = False
  1157. self.is_fake_account = False
  1158. self.write_log(' >>>This is a normal account')
  1159.  
  1160. if media > 0 and follows / media < 25 and follower / media < 25:
  1161. self.is_active_user = True
  1162. self.write_log(' >>>This user is active')
  1163. else:
  1164. self.is_active_user = False
  1165. self.write_log(' >>>This user is passive')
  1166.  
  1167. if follow_viewer or has_requested_viewer:
  1168. self.is_follower = True
  1169. self.write_log(" >>>This account is following you")
  1170. else:
  1171. self.is_follower = False
  1172. self.write_log(' >>>This account is NOT following you')
  1173.  
  1174. if followed_by_viewer or requested_by_viewer:
  1175. self.is_following = True
  1176. self.write_log(' >>>You are following this account')
  1177.  
  1178. else:
  1179. self.is_following = False
  1180. self.write_log(' >>>You are NOT following this account')
  1181.  
  1182. except:
  1183. logging.exception("Except on auto_unfollow!")
  1184. time.sleep(3)
  1185. return False
  1186. else:
  1187. return False
  1188.  
  1189. if (
  1190. self.is_selebgram is not False
  1191. or self.is_fake_account is not False
  1192. or self.is_active_user is not True
  1193. or self.is_follower is not True
  1194. ):
  1195. self.write_log(current_user)
  1196. self.write_log("Tried to unfollow auto_unfollow()")
  1197. return False
  1198. self.unfollow(current_id)
  1199. # don't insert unfollow count as it is done now inside unfollow()
  1200. #insert_unfollow_count(self, user_id=current_id)
  1201. elif self.is_following is not True:
  1202. # we are not following this account, hence we unfollowed it, let's keep track
  1203. insert_unfollow_count(self, user_id=current_id)
  1204.  
  1205. def unfollow_recent_feed(self):
  1206.  
  1207. if len(self.media_on_feed) == 0:
  1208. self.get_media_id_recent_feed()
  1209.  
  1210. if len(self.media_on_feed) != 0 and self.is_follower_number < 5 and time.time() > self.next_iteration["Unfollow"] and self.unfollow_per_day != 0:
  1211. self.get_media_id_recent_feed()
  1212. chooser = random.randint(0, len(self.media_on_feed) - 1)
  1213. self.current_user = self.media_on_feed[chooser]["node"]["owner"]["username"]
  1214. self.current_id = self.media_on_feed[chooser]["node"]["owner"]["id"]
  1215.  
  1216. current_user = self.current_user
  1217. current_id = self.current_id
  1218.  
  1219. if self.login_status:
  1220. log_string = "Getting user info : %s" % current_user
  1221. self.write_log(log_string)
  1222. if self.login_status == 1:
  1223. url_tag = self.url_user_detail % (current_user)
  1224. try:
  1225. r = self.s.get(url_tag)
  1226. if r.text.find('The link you followed may be broken, or the page may have been removed.') != -1:
  1227. log_string = "Looks like account was deleted, skipping : %s" % current_user
  1228. self.write_log(log_string)
  1229. insert_unfollow_count(self, user_id=current_id)
  1230. time.sleep(3)
  1231. return False
  1232. all_data = json.loads(re.search('window._sharedData = (.*?);</script>', r.text, re.DOTALL).group(1))['entry_data']['ProfilePage'][0]
  1233.  
  1234. user_info = all_data['graphql']['user']
  1235. i = 0
  1236. log_string = "Checking user info.."
  1237. self.write_log(log_string)
  1238.  
  1239. follows = user_info['edge_follow']['count']
  1240. follower = user_info['edge_followed_by']['count']
  1241. media = user_info['edge_owner_to_timeline_media']['count']
  1242. follow_viewer = user_info['follows_viewer']
  1243. followed_by_viewer = user_info[
  1244. 'followed_by_viewer']
  1245. requested_by_viewer = user_info[
  1246. 'requested_by_viewer']
  1247. has_requested_viewer = user_info[
  1248. 'has_requested_viewer']
  1249. log_string = "Follower : %i" % (follower)
  1250. self.write_log(log_string)
  1251. log_string = "Following : %s" % (follows)
  1252. self.write_log(log_string)
  1253. log_string = "Media : %i" % (media)
  1254. self.write_log(log_string)
  1255. if follows == 0 or follower / follows > 2:
  1256. self.is_selebgram = True
  1257. self.is_fake_account = False
  1258. self.write_log(' >>>This is probably Selebgram account')
  1259.  
  1260. elif follower == 0 or follows / follower > 2:
  1261. self.is_fake_account = True
  1262. self.is_selebgram = False
  1263. self.write_log(' >>>This is probably Fake account')
  1264. else:
  1265. self.is_selebgram = False
  1266. self.is_fake_account = False
  1267. self.write_log(' >>>This is a normal account')
  1268.  
  1269. if media > 0 and follows / media < 25 and follower / media < 25:
  1270. self.is_active_user = True
  1271. self.write_log(' >>>This user is active')
  1272. else:
  1273. self.is_active_user = False
  1274. self.write_log(' >>>This user is passive')
  1275.  
  1276. if follow_viewer or has_requested_viewer:
  1277. self.is_follower = True
  1278. self.write_log(" >>>This account is following you")
  1279. else:
  1280. self.is_follower = False
  1281. self.write_log(' >>>This account is NOT following you')
  1282.  
  1283. if followed_by_viewer or requested_by_viewer:
  1284. self.is_following = True
  1285. self.write_log(' >>>You are following this account')
  1286.  
  1287. else:
  1288. self.is_following = False
  1289. self.write_log(' >>>You are NOT following this account')
  1290.  
  1291. except:
  1292. logging.exception("Except on auto_unfollow!")
  1293. time.sleep(3)
  1294. return False
  1295. else:
  1296. return False
  1297.  
  1298. if (
  1299. self.is_selebgram is not False
  1300. or self.is_fake_account is not False
  1301. or self.is_active_user is not True
  1302. or self.is_follower is not True
  1303. ):
  1304. self.write_log(current_user)
  1305. self.write_log("Tried to unfollow unfollow_recent_feed()")
  1306. return False
  1307. self.unfollow(current_id)
  1308. self.next_iteration["Unfollow"] = time.time() + self.add_time(self.unfollow_delay)
  1309. # don't insert unfollow count as it is done now inside unfollow()
  1310. #insert_unfollow_count(self, user_id=current_id)
  1311. elif self.is_following is not True:
  1312. # we are not following this account, hence we unfollowed it, let's keep track
  1313. insert_unfollow_count(self, user_id=current_id)
  1314. time.sleep(8)
  1315.  
  1316.  
  1317. def get_media_id_recent_feed(self):
  1318. if self.login_status:
  1319. now_time = datetime.datetime.now()
  1320. log_string = "%s : Get media id on recent feed" % (self.user_login)
  1321. self.write_log(log_string)
  1322. if self.login_status == 1:
  1323. url_tag = 'https://www.instagram.com/'
  1324. try:
  1325. r = self.s.get(url_tag)
  1326.  
  1327. jsondata = re.search('additionalDataLoaded\(\'feed\',({.*})\);', r.text).group(1)
  1328. all_data = json.loads(jsondata.strip())
  1329.  
  1330. self.media_on_feed = list(
  1331. all_data['user']['edge_web_feed_timeline'][
  1332. 'edges'])
  1333.  
  1334. log_string = "Media in recent feed = %i" % (
  1335. len(self.media_on_feed))
  1336. self.write_log(log_string)
  1337. except:
  1338. logging.exception("get_media_id_recent_feed")
  1339. self.media_on_feed = []
  1340. time.sleep(20)
  1341. return 0
  1342. else:
  1343. return 0
  1344.  
  1345. def write_log(self, log_text):
  1346. """ Write log by print() or logger """
  1347.  
  1348. if self.log_mod == 0:
  1349. try:
  1350. now_time = datetime.datetime.now()
  1351. print(now_time.strftime("%d.%m.%Y_%H:%M") + " " + log_text)
  1352. except UnicodeEncodeError:
  1353. print("Your text has unicode problem!")
  1354. elif self.log_mod == 1:
  1355. # Create log_file if not exist.
  1356. if self.log_file == 0:
  1357. self.log_file = 1
  1358. now_time = datetime.datetime.now()
  1359. self.log_full_path = '%s%s_%s.log' % (
  1360. self.log_file_path, self.user_login,
  1361. now_time.strftime("%d.%m.%Y_%H:%M"))
  1362. formatter = logging.Formatter('%(asctime)s - %(name)s '
  1363. '- %(message)s')
  1364. self.logger = logging.getLogger(self.user_login)
  1365. self.hdrl = logging.FileHandler(self.log_full_path, mode='w')
  1366. self.hdrl.setFormatter(formatter)
  1367. self.logger.setLevel(level=logging.INFO)
  1368. self.logger.addHandler(self.hdrl)
  1369. # Log to log file.
  1370. try:
  1371. self.logger.info(log_text)
  1372. except UnicodeEncodeError:
  1373. print("Your text has unicode problem!")
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!