API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 21st, 2018
735
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 43.10 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. from .unfollow_protocol import unfollow_protocol
  6. from .userinfo import UserInfo
  7. import atexit
  8. import datetime
  9. import itertools
  10. import json
  11. import logging
  12. import random
  13. import signal
  14. import sys
  15. import sqlite3
  16. import time
  17. import requests
  18. from .sql_updates import check_and_update, check_already_liked, check_already_followed
  19. from .sql_updates import insert_media, insert_username, insert_unfollow_count
  20. from .sql_updates import get_usernames_first, get_usernames, get_username_random
  21. from .sql_updates import check_and_insert_user_agent
  22. from fake_useragent import UserAgent
  23. import re
  24.  
  25. class InstaBot:
  26. """
  27. Instagram bot v 1.2.0
  28. like_per_day=1000 - How many likes set bot in one day.
  29.  
  30. media_max_like=0 - Don't like media (photo or video) if it have more than
  31. media_max_like likes.
  32.  
  33. media_min_like=0 - Don't like media (photo or video) if it have less than
  34. media_min_like likes.
  35.  
  36. tag_list = ['cat', 'car', 'dog'] - Tag list to like.
  37.  
  38. max_like_for_one_tag=5 - Like 1 to max_like_for_one_tag times by row.
  39.  
  40. log_mod = 0 - Log mod: log_mod = 0 log to console, log_mod = 1 log to file,
  41. log_mod = 2 no log.
  42.  
  43. https://github.com/LevPasha/instabot.py
  44. """
  45. database_name = "follows_db.db"
  46. follows_db = None
  47. follows_db_c = None
  48.  
  49. url = 'https://www.instagram.com/'
  50. url_tag = 'https://www.instagram.com/explore/tags/%s/?__a=1'
  51. url_likes = 'https://www.instagram.com/web/likes/%s/like/'
  52. url_unlike = 'https://www.instagram.com/web/likes/%s/unlike/'
  53. url_comment = 'https://www.instagram.com/web/comments/%s/add/'
  54. url_follow = 'https://www.instagram.com/web/friendships/%s/follow/'
  55. url_unfollow = 'https://www.instagram.com/web/friendships/%s/unfollow/'
  56. url_login = 'https://www.instagram.com/accounts/login/ajax/'
  57. url_logout = 'https://www.instagram.com/accounts/logout/'
  58. url_media_detail = 'https://www.instagram.com/p/%s/?__a=1'
  59. url_user_detail = 'https://www.instagram.com/%s/'
  60. api_user_detail = 'https://i.instagram.com/api/v1/users/%s/info/'
  61.  
  62. user_agent = "" ""
  63. accept_language = 'en-US,en;q=0.5'
  64.  
  65. # If instagram ban you - query return 400 error.
  66. error_400 = 0
  67. # If you have 3 400 error in row - looks like you banned.
  68. error_400_to_ban = 3
  69. # If InstaBot think you are banned - going to sleep.
  70. ban_sleep_time = 2 * 60 * 60
  71.  
  72. # All counter.
  73. bot_mode = 0
  74. like_counter = 0
  75. follow_counter = 0
  76. unfollow_counter = 0
  77. comments_counter = 0
  78. current_user = 'hajka'
  79. current_index = 0
  80. current_id = 'abcds'
  81. # List of user_id, that bot follow
  82. bot_follow_list = []
  83. user_info_list = []
  84. user_list = []
  85. ex_user_list = []
  86. unwanted_username_list = []
  87. is_checked = False
  88. is_selebgram = False
  89. is_fake_account = False
  90. is_active_user = False
  91. is_following = False
  92. is_follower = False
  93. is_rejected = False
  94. is_self_checking = False
  95. is_by_tag = False
  96. is_follower_number = 0
  97.  
  98. self_following = 0
  99. self_follower = 0
  100.  
  101. # Log setting.
  102. logging.basicConfig(filename='errors.log', level=logging.INFO)
  103. log_file_path = ''
  104. log_file = 0
  105.  
  106. # Other.
  107. user_id = 0
  108. media_by_tag = 0
  109. media_on_feed = []
  110. media_by_user = []
  111. login_status = False
  112.  
  113. # Running Times
  114. start_at_h = 0,
  115. start_at_m = 0,
  116. end_at_h = 23,
  117. end_at_m = 59,
  118.  
  119. # For new_auto_mod
  120. next_iteration = {"Like": 0, "Follow": 0, "Unfollow": 0, "Comments": 0}
  121.  
  122. def __init__(self,
  123. login,
  124. password,
  125. like_per_day=1000,
  126. media_max_like=50,
  127. media_min_like=0,
  128. follow_per_day=0,
  129. follow_time=5 * 60 * 60,
  130. unfollow_per_day=0,
  131. start_at_h=0,
  132. start_at_m=0,
  133. end_at_h=23,
  134. end_at_m=59,
  135. database_name='follows_db.db',
  136. comment_list=[["this", "the", "your"],
  137. ["photo", "picture", "pic", "shot", "snapshot"],
  138. ["is", "looks", "feels", "is really"],
  139. ["great", "super", "good", "very good", "good",
  140. "wow", "WOW", "cool", "GREAT", "magnificent",
  141. "magical", "very cool", "stylish", "beautiful",
  142. "so beautiful", "so stylish", "so professional",
  143. "lovely", "so lovely", "very lovely", "glorious",
  144. "so glorious", "very glorious", "adorable",
  145. "excellent", "amazing"],
  146. [".", "..", "...", "!", "!!", "!!!"]],
  147. comments_per_day=0,
  148. tag_list=['cat', 'car', 'dog'],
  149. max_like_for_one_tag=5,
  150. unfollow_break_min=15,
  151. unfollow_break_max=30,
  152. log_mod=0,
  153. proxy="",
  154. user_blacklist={},
  155. tag_blacklist=[],
  156. unwanted_username_list=[],
  157. unfollow_whitelist=[]):
  158.  
  159. self.database_name = database_name
  160. self.follows_db = sqlite3.connect(database_name, timeout=0, isolation_level=None)
  161. self.follows_db_c = self.follows_db.cursor()
  162. check_and_update(self)
  163. fake_ua = UserAgent()
  164. self.user_agent = check_and_insert_user_agent(self, str(fake_ua.random))
  165. self.bot_start = datetime.datetime.now()
  166. self.start_at_h = start_at_h
  167. self.start_at_m = start_at_m
  168. self.end_at_h = end_at_h
  169. self.end_at_m = end_at_m
  170. self.unfollow_break_min = unfollow_break_min
  171. self.unfollow_break_max = unfollow_break_max
  172. self.user_blacklist = user_blacklist
  173. self.tag_blacklist = tag_blacklist
  174. self.unfollow_whitelist = unfollow_whitelist
  175. self.comment_list = comment_list
  176.  
  177. self.time_in_day = 24 * 60 * 60
  178. # Like
  179. self.like_per_day = like_per_day
  180. if self.like_per_day != 0:
  181. self.like_delay = self.time_in_day / self.like_per_day
  182.  
  183. # Follow
  184. self.follow_time = follow_time
  185. self.follow_per_day = follow_per_day
  186. if self.follow_per_day != 0:
  187. self.follow_delay = self.time_in_day / self.follow_per_day
  188.  
  189. # Unfollow
  190. self.unfollow_per_day = unfollow_per_day
  191. if self.unfollow_per_day != 0:
  192. self.unfollow_delay = self.time_in_day / self.unfollow_per_day
  193.  
  194. # Comment
  195. self.comments_per_day = comments_per_day
  196. if self.comments_per_day != 0:
  197. self.comments_delay = self.time_in_day / self.comments_per_day
  198.  
  199. # Don't like if media have more than n likes.
  200. self.media_max_like = media_max_like
  201. # Don't like if media have less than n likes.
  202. self.media_min_like = media_min_like
  203. # Auto mod seting:
  204. # Default list of tag.
  205. self.tag_list = tag_list
  206. # Get random tag, from tag_list, and like (1 to n) times.
  207. self.max_like_for_one_tag = max_like_for_one_tag
  208. # log_mod 0 to console, 1 to file
  209. self.log_mod = log_mod
  210. self.s = requests.Session()
  211. # if you need proxy make something like this:
  212. # self.s.proxies = {"https" : "http://proxyip:proxyport"}
  213. # by @ageorgios
  214. if proxy != "":
  215. proxies = {
  216. 'http': 'http://' + proxy,
  217. 'https': 'http://' + proxy,
  218. }
  219. self.s.proxies.update(proxies)
  220. # convert login to lower
  221. self.user_login = login.lower()
  222. self.user_password = password
  223. self.bot_mode = 0
  224. self.media_by_tag = []
  225. self.media_on_feed = []
  226. self.media_by_user = []
  227. self.unwanted_username_list = unwanted_username_list
  228. now_time = datetime.datetime.now()
  229. log_string = 'Instabot v1.2.0 started at %s:\n' % \
  230. (now_time.strftime("%d.%m.%Y %H:%M"))
  231. self.write_log(log_string)
  232. self.login()
  233. self.populate_user_blacklist()
  234. signal.signal(signal.SIGTERM, self.cleanup)
  235. atexit.register(self.cleanup)
  236.  
  237. def populate_user_blacklist(self):
  238. for user in self.user_blacklist:
  239. user_id_url = self.url_user_detail % (user)
  240. info = self.s.get(user_id_url)
  241.  
  242. # prevent error if 'Account of user was deleted or link is invalid
  243. from json import JSONDecodeError
  244. try:
  245. all_data = json.loads(info.text)
  246. except JSONDecodeError as e:
  247. self.write_log('Account of user %s was deleted or link is '
  248. 'invalid' % (user))
  249. else:
  250. # prevent exception if user have no media
  251. id_user = all_data['user']['id']
  252. # Update the user_name with the user_id
  253. self.user_blacklist[user] = id_user
  254. log_string = "Blacklisted user %s added with ID: %s" % (user,
  255. id_user)
  256. self.write_log(log_string)
  257. time.sleep(5 * random.random())
  258.  
  259. def login(self):
  260. log_string = 'Trying to login as %s...\n' % (self.user_login)
  261. self.write_log(log_string)
  262. self.login_post = {
  263. 'username': self.user_login,
  264. 'password': self.user_password
  265. }
  266.  
  267. self.s.headers.update({
  268. 'Accept': '*/*',
  269. 'Accept-Language': self.accept_language,
  270. 'Accept-Encoding': 'gzip, deflate, br',
  271. 'Connection': 'keep-alive',
  272. 'Content-Length': '0',
  273. 'Host': 'www.instagram.com',
  274. 'Origin': 'https://www.instagram.com',
  275. 'Referer': 'https://www.instagram.com/',
  276. 'User-Agent': self.user_agent,
  277. 'X-Instagram-AJAX': '1',
  278. 'Content-Type': 'application/x-www-form-urlencoded',
  279. 'X-Requested-With': 'XMLHttpRequest'
  280. })
  281.  
  282. r = self.s.get(self.url)
  283. #self.s.headers.update({'X-CSRFToken': r.cookies['csrftoken']})
  284. csrf_token = re.search('(?<=\"csrf_token\":\")\w+', r.text).group(0)
  285. self.s.headers.update({'X-CSRFToken': csrf_token})
  286. time.sleep(5 * random.random())
  287. login = self.s.post(
  288. self.url_login, data=self.login_post, allow_redirects=True)
  289. self.s.headers.update({'X-CSRFToken': login.cookies['csrftoken']})
  290. #ig_vw=1536; ig_pr=1.25; ig_vh=772; ig_or=landscape-primary;
  291. self.s.cookies['ig_vw'] = '1536'
  292. self.s.cookies['ig_pr'] = '1.25'
  293. self.s.cookies['ig_vh'] = '772'
  294. self.s.cookies['ig_or'] = 'landscape-primary'
  295. time.sleep(5 * random.random())
  296.  
  297. if login.status_code == 200:
  298. r = self.s.get('https://www.instagram.com/')
  299. finder = r.text.find(self.user_login)
  300. if finder != -1:
  301. ui = UserInfo()
  302. self.user_id = ui.get_user_id_by_login(self.user_login)
  303. self.login_status = True
  304. log_string = '%s login success!' % (self.user_login)
  305. self.write_log(log_string)
  306. else:
  307. self.login_status = False
  308. self.write_log('Login error! Check your login data!')
  309. else:
  310. self.write_log('Login error! Connection error!')
  311.  
  312. def logout(self):
  313. now_time = datetime.datetime.now()
  314. log_string = 'Logout: likes - %i, follow - %i, unfollow - %i, comments - %i.' % \
  315. (self.like_counter, self.follow_counter,
  316. self.unfollow_counter, self.comments_counter)
  317. self.write_log(log_string)
  318. work_time = datetime.datetime.now() - self.bot_start
  319. log_string = 'Bot work time: %s' % (work_time)
  320. self.write_log(log_string)
  321.  
  322. try:
  323. logout_post = {'csrfmiddlewaretoken': self.csrftoken}
  324. logout = self.s.post(self.url_logout, data=logout_post)
  325. self.write_log("Logout success!")
  326. self.login_status = False
  327. except:
  328. logging.exception("Logout error!")
  329.  
  330. def cleanup(self, *_):
  331. # Unfollow all bot follow
  332. if self.follow_counter >= self.unfollow_counter:
  333. for f in self.bot_follow_list:
  334. log_string = "Trying to unfollow: %s" % (f[0])
  335. self.write_log(log_string)
  336. self.unfollow_on_cleanup(f[0])
  337. sleeptime = random.randint(self.unfollow_break_min,
  338. self.unfollow_break_max)
  339. log_string = "Pausing for %i seconds... %i of %i" % (
  340. sleeptime, self.unfollow_counter, self.follow_counter)
  341. self.write_log(log_string)
  342. time.sleep(sleeptime)
  343. self.bot_follow_list.remove(f)
  344.  
  345. # Logout
  346. if self.login_status:
  347. self.logout()
  348.  
  349. def get_media_id_by_tag(self, tag):
  350. """ Get media ID set, by your hashtag """
  351.  
  352. if self.login_status:
  353. log_string = "Get media id by tag: %s" % (tag)
  354. self.write_log(log_string)
  355. if self.login_status == 1:
  356. url_tag = self.url_tag % (tag)
  357. try:
  358. r = self.s.get(url_tag)
  359. all_data = json.loads(r.text)
  360. self.media_by_tag = list(all_data['graphql']['hashtag']['edge_hashtag_to_media']['edges'])
  361. except:
  362. self.media_by_tag = []
  363. self.write_log("Except on get_media!")
  364. logging.exception("get_media_id_by_tag")
  365. else:
  366. return 0
  367.  
  368. def get_instagram_url_from_media_id(self, media_id, url_flag=True, only_code=None):
  369. """ Get Media Code or Full Url from Media ID Thanks to Nikished """
  370. media_id = int(media_id)
  371. if url_flag is False: return ""
  372. else:
  373. alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
  374. shortened_id = ''
  375. while media_id > 0:
  376. media_id, idx = divmod(media_id, 64)
  377. shortened_id = alphabet[idx] + shortened_id
  378. if only_code: return shortened_id
  379. else: return 'instagram.com/p/' + shortened_id + '/'
  380.  
  381. def get_username_by_media_id(self, media_id):
  382. """ Get username by media ID Thanks to Nikished """
  383.  
  384. if self.login_status:
  385. if self.login_status == 1:
  386. media_id_url = self.get_instagram_url_from_media_id(int(media_id), only_code=True)
  387. url_media = self.url_media_detail % (media_id_url)
  388. try:
  389. r = self.s.get(url_media)
  390. all_data = json.loads(r.text)
  391.  
  392. username = str(all_data['graphql']['shortcode_media']['owner']['username'])
  393. self.write_log("media_id=" + media_id + ", media_id_url=" +
  394. media_id_url + ", username_by_media_id=" + username)
  395. return username
  396. except:
  397. logging.exception("username_by_mediaid exception")
  398. return False
  399. else:
  400. return ""
  401.  
  402. def get_username_by_user_id(self, user_id):
  403. """ Get username by user_id """
  404. if self.login_status:
  405. try:
  406. url_info = self.api_user_detail % user_id
  407. r = self.s.get(url_info, headers="")
  408. all_data = json.loads(r.text)
  409. username = all_data["user"]["username"]
  410. return username
  411. except:
  412. logging.exception("Except on get_username_by_user_id")
  413. return False
  414. else:
  415. return False
  416.  
  417. def get_userinfo_by_name(self, username):
  418. """ Get user info by name """
  419.  
  420. if self.login_status:
  421. if self.login_status == 1:
  422. url_info = self.url_user_detail % (username)
  423. try:
  424. r = self.s.get(url_info)
  425. all_data = json.loads(r.text)
  426. user_info = all_data['user']
  427. follows = user_info['follows']['count']
  428. follower = user_info['followed_by']['count']
  429. follow_viewer = user_info['follows_viewer']
  430. if follower > 3000 or follows > 1500:
  431. self.write_log(' >>>This is probably Selebgram, Business or Fake account')
  432. if follow_viewer:
  433. return None
  434. return user_info
  435. except:
  436. logging.exception("Except on get_userinfo_by_name")
  437. return False
  438. else:
  439. return False
  440.  
  441. def like_all_exist_media(self, media_size=-1, delay=True):
  442. """ Like all media ID that have self.media_by_tag """
  443.  
  444. if self.login_status:
  445. if self.media_by_tag != 0:
  446. i = 0
  447. for d in self.media_by_tag:
  448. # Media count by this tag.
  449. if media_size > 0 or media_size < 0:
  450. media_size -= 1
  451. l_c = self.media_by_tag[i]['node']['edge_liked_by']['count']
  452. if ((l_c <= self.media_max_like and
  453. l_c >= self.media_min_like) or
  454. (self.media_max_like == 0 and
  455. l_c >= self.media_min_like) or
  456. (self.media_min_like == 0 and
  457. l_c <= self.media_max_like) or
  458. (self.media_min_like == 0 and
  459. self.media_max_like == 0)):
  460. for blacklisted_user_name, blacklisted_user_id in self.user_blacklist.items(
  461. ):
  462. if self.media_by_tag[i]['node']['owner'][
  463. 'id'] == blacklisted_user_id:
  464. self.write_log(
  465. "Not liking media owned by blacklisted user: "
  466. + blacklisted_user_name)
  467. return False
  468. if self.media_by_tag[i]['node']['owner'][
  469. 'id'] == self.user_id:
  470. self.write_log(
  471. "Keep calm - It's your own media ;)")
  472. return False
  473. if check_already_liked(self, media_id=self.media_by_tag[i]['node']['id']) == 1:
  474. self.write_log("Keep calm - It's already liked ;)")
  475. return False
  476. try:
  477. if (len(self.media_by_tag[i]['node']['edge_media_to_caption']['edges']) > 1):
  478. caption = self.media_by_tag[i]['node']['edge_media_to_caption'][
  479. 'edges'][0]['node']['text'].encode(
  480. 'ascii', errors='ignore')
  481. tag_blacklist = set(self.tag_blacklist)
  482. if sys.version_info[0] == 3:
  483. tags = {
  484. str.lower(
  485. (tag.decode('ASCII')).strip('#'))
  486. for tag in caption.split()
  487. if (tag.decode('ASCII')
  488. ).startswith("#")
  489. }
  490. else:
  491. tags = {
  492. unicode.lower(
  493. (tag.decode('ASCII')).strip('#'))
  494. for tag in caption.split()
  495. if (tag.decode('ASCII')
  496. ).startswith("#")
  497. }
  498.  
  499. if tags.intersection(tag_blacklist):
  500. matching_tags = ', '.join(
  501. tags.intersection(tag_blacklist))
  502. self.write_log(
  503. "Not liking media with blacklisted tag(s): "
  504. + matching_tags)
  505. return False
  506. except:
  507. logging.exception("Except on like_all_exist_media")
  508. return False
  509.  
  510. log_string = "Trying to like media: %s" % \
  511. (self.media_by_tag[i]['node']['id'])
  512. self.write_log(log_string)
  513. like = self.like(self.media_by_tag[i]['node']['id'])
  514. # comment = self.comment(self.media_by_tag[i]['id'], 'Cool!')
  515. # follow = self.follow(self.media_by_tag[i]["owner"]["id"])
  516. if like != 0:
  517. if like.status_code == 200:
  518. # Like, all ok!
  519. self.error_400 = 0
  520. self.like_counter += 1
  521. log_string = "Liked: %s. Like #%i." % \
  522. (self.media_by_tag[i]['node']['id'],
  523. self.like_counter)
  524. insert_media(self,
  525. media_id=self.media_by_tag[i]['node']['id'],
  526. status="200")
  527. self.write_log(log_string)
  528. elif like.status_code == 400:
  529. log_string = "Not liked: %i" \
  530. % (like.status_code)
  531. self.write_log(log_string)
  532. insert_media(self,
  533. media_id=self.media_by_tag[i]['node']['id'],
  534. status="400")
  535. # Some error. If repeated - can be ban!
  536. if self.error_400 >= self.error_400_to_ban:
  537. # Look like you banned!
  538. time.sleep(self.ban_sleep_time)
  539. else:
  540. self.error_400 += 1
  541. else:
  542. log_string = "Not liked: %i" \
  543. % (like.status_code)
  544. insert_media(self,
  545. media_id=self.media_by_tag[i]['node']['id'],
  546. status=str(like.status_code))
  547. self.write_log(log_string)
  548. return False
  549. # Some error.
  550. i += 1
  551. if delay:
  552. time.sleep(self.like_delay * 0.9 +
  553. self.like_delay * 0.2 *
  554. random.random())
  555. else:
  556. return True
  557. else:
  558. return False
  559. else:
  560. return False
  561. else:
  562. return False
  563. else:
  564. self.write_log("No media to like!")
  565.  
  566. def like(self, media_id):
  567. """ Send http request to like media by ID """
  568. if self.login_status:
  569. url_likes = self.url_likes % (media_id)
  570. try:
  571. like = self.s.post(url_likes)
  572. last_liked_media_id = media_id
  573. except:
  574. logging.exception("Except on like!")
  575. like = 0
  576. return like
  577.  
  578. def unlike(self, media_id):
  579. """ Send http request to unlike media by ID """
  580. if self.login_status:
  581. url_unlike = self.url_unlike % (media_id)
  582. try:
  583. unlike = self.s.post(url_unlike)
  584. except:
  585. logging.exception("Except on unlike!")
  586. unlike = 0
  587. return unlike
  588.  
  589. def comment(self, media_id, comment_text):
  590. """ Send http request to comment """
  591. if self.login_status:
  592. comment_post = {'comment_text': comment_text}
  593. url_comment = self.url_comment % (media_id)
  594. try:
  595. comment = self.s.post(url_comment, data=comment_post)
  596. if comment.status_code == 200:
  597. self.comments_counter += 1
  598. log_string = 'Write: "%s". #%i.' % (comment_text,
  599. self.comments_counter)
  600. self.write_log(log_string)
  601. return comment
  602. except:
  603. logging.exception("Except on comment!")
  604. return False
  605.  
  606. def follow(self, user_id):
  607. """ Send http request to follow """
  608. if self.login_status:
  609. url_follow = self.url_follow % (user_id)
  610. try:
  611. follow = self.s.post(url_follow)
  612. if follow.status_code == 200:
  613. self.follow_counter += 1
  614. log_string = "Followed: %s #%i." % (user_id,
  615. self.follow_counter)
  616. self.write_log(log_string)
  617. username = self.get_username_by_user_id(user_id=user_id)
  618. insert_username(self, user_id=user_id, username=username)
  619. return follow
  620. except:
  621. logging.exception("Except on follow!")
  622. return False
  623.  
  624. def unfollow(self, user_id):
  625. """ Send http request to unfollow """
  626. if self.login_status:
  627. url_unfollow = self.url_unfollow % (user_id)
  628. try:
  629. unfollow = self.s.post(url_unfollow)
  630. if unfollow.status_code == 200:
  631. self.unfollow_counter += 1
  632. log_string = "Unfollowed: %s #%i." % (user_id,
  633. self.unfollow_counter)
  634. self.write_log(log_string)
  635. return unfollow
  636. except:
  637. logging.exception("Exept on unfollow!")
  638. return False
  639.  
  640. def unfollow_on_cleanup(self, user_id):
  641. """ Unfollow on cleanup by @rjmayott """
  642. if self.login_status:
  643. url_unfollow = self.url_unfollow % (user_id)
  644. try:
  645. unfollow = self.s.post(url_unfollow)
  646. if unfollow.status_code == 200:
  647. self.unfollow_counter += 1
  648. log_string = "Unfollow: %s #%i of %i." % (
  649. user_id, self.unfollow_counter, self.follow_counter)
  650. self.write_log(log_string)
  651. else:
  652. log_string = "Slow Down - Pausing for 5 minutes so we don't get banned!"
  653. self.write_log(log_string)
  654. time.sleep(300)
  655. unfollow = self.s.post(url_unfollow)
  656. if unfollow.status_code == 200:
  657. self.unfollow_counter += 1
  658. log_string = "Unfollow: %s #%i of %i." % (
  659. user_id, self.unfollow_counter,
  660. self.follow_counter)
  661. self.write_log(log_string)
  662. else:
  663. log_string = "Still no good :( Skipping and pausing for another 5 minutes"
  664. self.write_log(log_string)
  665. time.sleep(300)
  666. return False
  667. return unfollow
  668. except:
  669. log_string = "Except on unfollow... Looks like a network error"
  670. logging.exception(log_string)
  671. return False
  672.  
  673. def auto_mod(self):
  674. """ Star loop, that get media ID by your tag list, and like it """
  675. if self.login_status:
  676. while True:
  677. random.shuffle(self.tag_list)
  678. self.get_media_id_by_tag(random.choice(self.tag_list))
  679. self.like_all_exist_media(random.randint \
  680. (1, self.max_like_for_one_tag))
  681.  
  682. def new_auto_mod(self):
  683. while True:
  684. now = datetime.datetime.now()
  685. if (
  686. datetime.time(self.start_at_h, self.start_at_m) <= now.time()
  687. and now.time() <= datetime.time(self.end_at_h, self.end_at_m)
  688. ):
  689. # ------------------- Get media_id -------------------
  690. if len(self.media_by_tag) == 0:
  691. self.get_media_id_by_tag(random.choice(self.tag_list))
  692. self.this_tag_like_count = 0
  693. self.max_tag_like_count = random.randint(
  694. 1, self.max_like_for_one_tag)
  695. self.remove_already_liked()
  696. # ------------------- Like -------------------
  697. self.new_auto_mod_like()
  698. # ------------------- Follow -------------------
  699. self.new_auto_mod_follow()
  700. # ------------------- Unfollow -------------------
  701. self.new_auto_mod_unfollow()
  702. # ------------------- Comment -------------------
  703. self.new_auto_mod_comments()
  704. # Bot iteration in 1 sec
  705. time.sleep(3)
  706. # print("Tic!")
  707. else:
  708. print("sleeping until {hour}:{min}".format(hour=self.start_at_h,
  709. min=self.start_at_m), end="\r")
  710. time.sleep(100)
  711.  
  712. def remove_already_liked(self):
  713. self.write_log("Removing already liked medias..")
  714. x = 0
  715. while x < len(self.media_by_tag):
  716. if check_already_liked(self, media_id=self.media_by_tag[x]['node']['id']) == 1:
  717. self.media_by_tag.remove(self.media_by_tag[x])
  718. else:
  719. x += 1
  720.  
  721. def new_auto_mod_like(self):
  722. if time.time() > self.next_iteration["Like"] and self.like_per_day != 0 \
  723. and len(self.media_by_tag) > 0:
  724. # You have media_id to like:
  725. if self.like_all_exist_media(media_size=1, delay=False):
  726. # If like go to sleep:
  727. self.next_iteration["Like"] = time.time() + \
  728. self.add_time(self.like_delay)
  729. # Count this tag likes:
  730. self.this_tag_like_count += 1
  731. if self.this_tag_like_count >= self.max_tag_like_count:
  732. self.media_by_tag = [0]
  733. # Del first media_id
  734. del self.media_by_tag[0]
  735.  
  736. def new_auto_mod_follow(self):
  737. if time.time() > self.next_iteration["Follow"] and \
  738. self.follow_per_day != 0 and len(self.media_by_tag) > 0:
  739. if self.media_by_tag[0]['node']["owner"]["id"] == self.user_id:
  740. self.write_log("Keep calm - It's your own profile ;)")
  741. return
  742. if check_already_followed(self, user_id=self.media_by_tag[0]['node']["owner"]["id"]) == 1:
  743. self.write_log("Already followed before " + self.media_by_tag[0]['node']["owner"]["id"])
  744. self.next_iteration["Follow"] = time.time() + \
  745. self.add_time(self.follow_delay/2)
  746. return
  747. log_string = "Trying to follow: %s" % (
  748. self.media_by_tag[0]['node']["owner"]["id"])
  749. self.write_log(log_string)
  750.  
  751. if self.follow(self.media_by_tag[0]['node']["owner"]["id"]) != False:
  752. self.bot_follow_list.append(
  753. [self.media_by_tag[0]['node']["owner"]["id"], time.time()])
  754. self.next_iteration["Follow"] = time.time() + \
  755. self.add_time(self.follow_delay)
  756.  
  757. def new_auto_mod_unfollow(self):
  758. if time.time() > self.next_iteration["Unfollow"] and self.unfollow_per_day != 0:
  759. if self.bot_mode == 0:
  760. log_string = "Trying to unfollow #%i: " % (self.unfollow_counter + 1)
  761. self.write_log(log_string)
  762. self.auto_unfollow()
  763. self.next_iteration["Unfollow"] = time.time() + \
  764. self.add_time(self.unfollow_delay)
  765. if self.bot_mode == 1:
  766. unfollow_protocol(self)
  767.  
  768. def new_auto_mod_comments(self):
  769. if time.time() > self.next_iteration["Comments"] and self.comments_per_day != 0 \
  770. and len(self.media_by_tag) > 0 \
  771. and self.check_exisiting_comment(self.media_by_tag[0]['node']['shortcode']) == False:
  772. comment_text = self.generate_comment()
  773. log_string = "Trying to comment: %s" % (self.media_by_tag[0]['node']['id'])
  774. self.write_log(log_string)
  775. if self.comment(self.media_by_tag[0]['node']['id'], comment_text) != False:
  776. self.next_iteration["Comments"] = time.time() + \
  777. self.add_time(self.comments_delay)
  778.  
  779. def add_time(self, time):
  780. """ Make some random for next iteration"""
  781. return time * 0.9 + time * 0.2 * random.random()
  782.  
  783. def generate_comment(self):
  784. c_list = list(itertools.product(*self.comment_list))
  785.  
  786. repl = [(" ", " "), (" .", "."), (" !", "!")]
  787. res = " ".join(random.choice(c_list))
  788. for s, r in repl:
  789. res = res.replace(s, r)
  790. return res.capitalize()
  791.  
  792. def check_exisiting_comment(self, media_code):
  793. url_check = self.url_media_detail % (media_code)
  794. check_comment = self.s.get(url_check)
  795. if check_comment.status_code == 200:
  796. all_data = json.loads(check_comment.text)
  797. if all_data['graphql']['shortcode_media']['owner']['id'] == self.user_id:
  798. self.write_log("Keep calm - It's your own media ;)")
  799. # Del media to don't loop on it
  800. del self.media_by_tag[0]
  801. return True
  802. comment_list = list(all_data['graphql']['shortcode_media']['edge_media_to_comment']['edges'])
  803. for d in comment_list:
  804. if d['node']['owner']['id'] == self.user_id:
  805. self.write_log("Keep calm - Media already commented ;)")
  806. # Del media to don't loop on it
  807. del self.media_by_tag[0]
  808. return True
  809. return False
  810. else:
  811. insert_media(self, self.media_by_tag[0]['node']['id'], str(check_comment.status_code))
  812. self.media_by_tag.remove(self.media_by_tag[0])
  813. return False
  814.  
  815. def auto_unfollow(self):
  816. checking = True
  817. while checking:
  818. username_row = get_username_random(self)
  819. if not username_row:
  820. self.write_log("Looks like there is nobody to unfollow.")
  821. return False
  822. current_id = username_row[0]
  823. current_user = username_row[1]
  824. unfollow_count = username_row[2]
  825.  
  826. if not current_user:
  827. current_user = self.get_username_by_user_id(user_id=current_id)
  828. if not current_user:
  829. log_string = "api limit reached from instagram. Will try later"
  830. self.write_log(log_string)
  831. return False
  832. for wluser in self.unfollow_whitelist:
  833. if wluser == current_user:
  834. log_string = (
  835. "found whitelist user, starting search again")
  836. self.write_log(log_string)
  837. break
  838. else:
  839. checking = False
  840.  
  841. if self.login_status:
  842. log_string = "Getting user info : %s" % current_user
  843. self.write_log(log_string)
  844. if self.login_status == 1:
  845. url_tag = self.url_user_detail % (current_user)
  846. try:
  847. r = self.s.get(url_tag)
  848. all_data = json.loads(re.search('{"activity.+show_app', r.text, re.DOTALL).group(0)+'":""}')['entry_data']['ProfilePage'][0]
  849.  
  850. user_info = all_data['graphql']['user']
  851. i = 0
  852. log_string = "Checking user info.."
  853. self.write_log(log_string)
  854.  
  855. follows = user_info['edge_follow']['count']
  856. follower = user_info['edge_followed_by']['count']
  857. media = user_info['edge_owner_to_timeline_media']['count']
  858. follow_viewer = user_info['follows_viewer']
  859. followed_by_viewer = user_info[
  860. 'followed_by_viewer']
  861. requested_by_viewer = user_info[
  862. 'requested_by_viewer']
  863. has_requested_viewer = user_info[
  864. 'has_requested_viewer']
  865. log_string = "Follower : %i" % (follower)
  866. self.write_log(log_string)
  867. log_string = "Following : %s" % (follows)
  868. self.write_log(log_string)
  869. log_string = "Media : %i" % (media)
  870. self.write_log(log_string)
  871. if follows == 0 or follower / follows > 2:
  872. self.is_selebgram = True
  873. self.is_fake_account = False
  874. print(' >>>This is probably Selebgram account')
  875. elif follower == 0 or follows / follower > 2:
  876. self.is_fake_account = True
  877. self.is_selebgram = False
  878. print(' >>>This is probably Fake account')
  879. else:
  880. self.is_selebgram = False
  881. self.is_fake_account = False
  882. print(' >>>This is a normal account')
  883.  
  884. if media > 0 and follows / media < 25 and follower / media < 25:
  885. self.is_active_user = True
  886. print(' >>>This user is active')
  887. else:
  888. self.is_active_user = False
  889. print(' >>>This user is passive')
  890.  
  891. if follow_viewer or has_requested_viewer:
  892. self.is_follower = True
  893. print(" >>>This account is following you")
  894. else:
  895. self.is_follower = False
  896. print(' >>>This account is NOT following you')
  897.  
  898. if followed_by_viewer or requested_by_viewer:
  899. self.is_following = True
  900. print(' >>>You are following this account')
  901.  
  902. else:
  903. self.is_following = False
  904. print(' >>>You are NOT following this account')
  905.  
  906. except:
  907. logging.exception("Except on auto_unfollow!")
  908. time.sleep(3)
  909. return False
  910. else:
  911. return False
  912.  
  913. if (
  914. self.is_selebgram is not False
  915. or self.is_fake_account is not False
  916. or self.is_active_user is not True
  917. or self.is_follower is not True
  918. ):
  919. self.write_log(current_user)
  920. self.unfollow(current_id)
  921. insert_unfollow_count(self, user_id=current_id)
  922.  
  923. def get_media_id_recent_feed(self):
  924. if self.login_status:
  925. now_time = datetime.datetime.now()
  926. log_string = "%s : Get media id on recent feed" % (self.user_login)
  927. self.write_log(log_string)
  928. if self.login_status == 1:
  929. url_tag = 'https://www.instagram.com/?__a=1'
  930. try:
  931. r = self.s.get(url_tag)
  932. all_data = json.loads(r.text)
  933.  
  934. self.media_on_feed = list(
  935. all_data['graphql']['user']['edge_web_feed_timeline'][
  936. 'edges'])
  937.  
  938. log_string = "Media in recent feed = %i" % (
  939. len(self.media_on_feed))
  940. self.write_log(log_string)
  941. except:
  942. logging.exception("get_media_id_recent_feed")
  943. self.media_on_feed = []
  944. time.sleep(20)
  945. return 0
  946. else:
  947. return 0
  948.  
  949. def write_log(self, log_text):
  950. """ Write log by print() or logger """
  951.  
  952. if self.log_mod == 0:
  953. try:
  954. now_time = datetime.datetime.now()
  955. print(now_time.strftime("%d.%m.%Y_%H:%M") + " " + log_text)
  956. except UnicodeEncodeError:
  957. print("Your text has unicode problem!")
  958. elif self.log_mod == 1:
  959. # Create log_file if not exist.
  960. if self.log_file == 0:
  961. self.log_file = 1
  962. now_time = datetime.datetime.now()
  963. self.log_full_path = '%s%s_%s.log' % (
  964. self.log_file_path, self.user_login,
  965. now_time.strftime("%d.%m.%Y_%H:%M"))
  966. formatter = logging.Formatter('%(asctime)s - %(name)s '
  967. '- %(message)s')
  968. self.logger = logging.getLogger(self.user_login)
  969. self.hdrl = logging.FileHandler(self.log_full_path, mode='w')
  970. self.hdrl.setFormatter(formatter)
  971. self.logger.setLevel(level=logging.INFO)
  972. self.logger.addHandler(self.hdrl)
  973. # Log to log file.
  974. try:
  975. self.logger.info(log_text)
  976. except UnicodeEncodeError:
  977. 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!