def login(self, username: str, password: str):
"""Logs to Instagram
:param username: Instagram login name
:param password: Instagram login password
"""
self.api = Client(username, password)
def main():
global api
try:
api = Client(None, None, settings=file_get_contents("data.bin", "rb"))
except:
if os.path.exists("data.bin"):
os.remove("data.bin")
username = input('Your username:'******'Your password:'******'fetch':
fetch()
elif command == 'hide':
hide_all()
elif command == 'unhide':
unhide_all()
elif command == 'reset':
reset()
else:
show_help()
if os.path.exists("data.bin") == False:
file_put_contents("data.bin", "wb", api.settings)
def __init__(self,
username,
password,
similar_users,
API=None,
action_interval=8.0,
rate=75,
interval=5400):
self.username = username
self.password = password
if isinstance(similar_users, str):
self.similar_users = [x.strip() for x in similar_users.split(",")]
else:
self.similar_users = similar_users
self.action_interval = action_interval
self.rate = rate
self.interval = interval
self.logger = logging.LoggerAdapter(logger, {
'user': self.username,
'bot': 'instafollow'
})
self.API = Client(self.username, self.password) if API is None else API
self.webAPI = WebClient()
class StorySaver:
def __init__(self, user_name: str, password: str, result_file_path: str):
self.user_name = user_name
self.api = Client(user_name, password)
self.api.login()
self.rank_token = Client.generate_uuid()
# self.result_json = open(result_file_path, "w", encoding='utf-8')
def getMyFollowingList(self) -> list:
user_pk = self.api.user_detail_info(
self.user_name)["user_detail"]["user"]["pk"]
return self.api.user_following(user_pk, self.rank_token)["users"]
def _saveStory(self, user_pk):
stories = self.api.user_story_feed(user_pk).get("reel", "")
if stories is not None:
# self.result_json.write(json.dumps(stories))
# self.result_json.write("\n")
for item in stories.get("items", []):
username = item["user"]["username"]
img_url = item.get("image_versions2",
[]).get("candidates", [])[0]["url"]
img_folder = "photos/" + username + "/"
img_filename = img_folder + urlparse(img_url).path.split(
"/")[-1]
self.save_To_S3(img_filename, img_url)
if item.get("video_versions", []):
video_url = item.get("video_versions", [])[0]["url"]
video_folder = "video/" + username + "/"
video_filename = video_folder + urlparse(
video_url).path.split("/")[-1]
self.save_To_S3(video_filename, video_url)
logging.debug(img_url)
def startSave(self):
users = self.getMyFollowingList()
for user in users:
time.sleep(1)
self._saveStory(str(user["pk"]))
@staticmethod
def saveFileSystem(url, path_and_filename):
if not os.path.exists(path_and_filename):
os.makedirs(path_and_filename)
urlretrieve(url, path_and_filename)
@staticmethod
def save_To_S3(s3_folder, url):
service_url = "https://url-2-s3.herokuapp.com/upload"
payload = json.dumps({"url": url, "fileNameAndPath": s3_folder})
headers = {'Content-Type': 'application/json'}
response = requests.request("POST",
service_url,
headers=headers,
data=payload)
print(response.text.encode('utf8'))
def __init__(self):
settings_file = "settings.json"
if len(sys.argv) < 3:
print(
'Usage: python unliker.py username password max_remove(optional)'
)
os._exit(1)
else:
self.user = sys.argv[1]
self.pwd = sys.argv[2]
if not os.path.isfile(settings_file):
print("Settings file not found...")
self.api = Client(
self.user,
self.pwd,
on_login=lambda x: self.onlogin_callback(x, settings_file))
else:
with open(settings_file) as file_data:
cached_settings = json.load(file_data,
object_hook=self.from_json)
print("Reusing settings...")
self.api = Client(self.user, self.pwd, settings=cached_settings)
self.following = set([
u['username']
for u in self.api.user_following(self.api.authenticated_user_id,
self.api.generate_uuid())['users']
]) # used for filtering
def login(api: Client):
username = pil.ig_user
try:
api.login()
except (ClientCheckpointRequiredError, ClientChallengeRequiredError) as e:
challenge_url = e.challenge_url
challenge_pattern = r'.*challenge/(?P<account_id>\d.*)/(?P<identifier>\w.*)/'
match = re.search(challenge_pattern, challenge_url)
if not match:
raise ClientError('Unable to parse challenge')
match_dict = match.groupdict()
account_id = match_dict['account_id']
identifier = match_dict['identifier']
res = api.choose_confirm_method(
account_id,
'1') # confirm_method param has default value 1, you can pass 0
magic_code = get_code_from_email(username)
if magic_code:
code = magic_code
else:
code = input('Enter code from email: ')
api.send_challenge(account_id, identifier, code)
def insta_api(message, photo_list, user_name, password, hashtag):
api = Client(user_name, password)
caption = str(message) + " " + hashtag
# Generate new credintails or load existing
basepath = path.dirname(__file__)
filepath = path.abspath(path.join(basepath, "..", "credentials.json"))
with open(filepath, "r") as read_file:
data = json.load(read_file)
print(data)
# Force api credits (saved)
api.uuid = data['uuid']
api.device_id = data['device_id']
api.ad_id = data['ad_id']
api.session_id = data['session_id']
# if len(photo_list) == 1: # Если пришла 1 фотка в списке
one_image = photo_list[0]
print(one_image)
buf = io.BytesIO()
one_image.save(buf, format='JPEG')
byte_im = buf.getvalue()
print(byte_im)
size = (one_image.width, one_image.height)
print(size)
api.login()
api.post_photo(byte_im, size, caption)
def __init__(self, username, password):
self.__username = username
self.__password = password
self.__api = None
try:
self.__api = Client(auto_patch=True,
authenticate=True,
username=self.__username,
password=self.__password)
print("login effettuato con successo!\n")
except ClientLoginError:
print("La password che hai inserito non è corretta\n")
return
except ClientError:
print(
"Se hai l'autenticazione a due fattori attiva, il bot non può funzionare\n"
)
print(
"Puoi disattivarla per usare il bot, e al termine riattivarla\n"
)
return
user_feed_info = self.__api.user_feed('329452045', count=10)
for post in user_feed_info:
print('%s from %s' % (post['link'], post['user']['username']))
def already_liked(api: Client,
target_id: str,
type_like: str = 'post',
own_feed: bool = False) -> bool:
"""
Check if the post / comment is already liked by the current user
Arguments:
api (Client) : Object instagram Client
target_id (str) : Id of comment or post
type_like (str) : String that can be post or comment
own_feed (bool) : If it's the current user's feed
Returns:
bool - if the post or comment is already liked
"""
is_liked = False
if type_like == 'post':
likes = api.media_likers(target_id)['users']
else:
likes = api.comment_likers(target_id)
bot_id = int(api.authenticated_user_id)
if likes:
collection_likes = likes['users'] if own_feed else likes
for likers in collection_likes:
if bot_id == likers['pk']:
is_liked = True
return is_liked
def __init__(self, username, password):
print("setting up instagram scraper...")
self.username = username
self.password = password
self.api = Client(username=username, password=password)
self.user_id = self.api.username_info(self.username)['user']['pk']
print("instagram scraper successfully initialized!")
def delete(api: Client,
target_id: str,
target_type: str,
parent_id: str = '') -> None:
"""
Delete a post or comment chosen by the current user
Arguments:
api (Client) : Object instagram Client
target_id (str) : Id of the post or comment to delete
target_type (str) : String that can be post or comment
parent_id (str) : In the event that a comment is deleted,
it stores the id of the post that contains said comment,
"""
if target_type == 'post':
result = api.delete_media(media_id=target_id)
else:
result = api.delete_comment(media_id=parent_id, comment_id=target_id)
if result['status'] == 'ok':
print_write_chatbot(
f"The {target_type} has been successfully removed!\n",
color='green',
attrs_color=['bold'])
else:
print_write_chatbot(
f"The {target_type} could not be removed. Please try again later\n",
color='red',
attrs_color=['bold'])
def setup_api(self):
'''
isitialise self.api for the given user
reusing or creating new settings
'''
try:
with open(self.settings_path) as settings_file:
cached_settings = json.load(settings_file, object_hook=from_json)
self.device_id = cached_settings.get('device_id')
print('Reusing settings: {0}'.format(self.settings_path))
self.api = Client(self.user.username,
self.user.password,
settings=cached_settings)
except (ClientCookieExpiredError, ClientLoginRequiredError, FileNotFoundError) as ex:
print(str(ex))
# Login expired, renew cookie upon login
self.api = Client(self.user.username,
self.user.password,
on_login=lambda x: on_login(x, self.settings_path))
except ClientLoginError as ex:
print('ClientLoginError {0!s}'.format(ex))
sys.exit(9)
except ClientError as ex:
print('ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(ex.msg,
ex.code,
ex.error_response))
sys.exit(9)
except Exception as ex:
print('Unexpected Exception: {0!s}'.format(ex))
sys.exit(99)
def get_follows(api: Client,
show: bool = True,
follow_type: str = 'following') -> dict:
"""
Depending on the follow_type, a dictionary will be obtained
that contains the users who follow the current user or those that the current user is following
Arguments:
api (Client) : Object instagram Client
show (bool) : Indicates whether the filtered user names should be printed or not
follow_type (str) : Can be following or followed
"""
rank = api.generate_uuid()
user_id = api.authenticated_user_id
if follow_type == 'following':
results = api.user_following(user_id, rank)
prefix = "You are"
else:
results = api.user_followers(user_id, rank)
prefix = "Your"
text = f"{prefix} {follow_type}: \n"
if show:
print_write_chatbot(text,
color='blue',
attrs_color=['bold', 'underline'])
for user in results['users']:
print_write_chatbot(f"{user['username']}")
return results
def setupClients(self):
self.log_info("Setting up clients with given credentials")
for account in self.account_creds:
u = account["u"]
p = account["p"]
self.log_debug(
"Creating Instagram client object with username: %s " % u)
try:
c = Client(account["u"], account["p"])
self.client_objs.append({
"client": c,
"feed": None,
"u": u,
"uuid": c.generate_uuid()
})
self.log_info(
"Successfully created Instagram client object with username: %s "
% u)
except Exception as e:
self.log_warning(
"Error encountered when authenticating to Instagram with username: %s - SKIPPING"
% u)
self.log_error("%s\n%s" % (e, traceback.format_exc()))
continue
def __init__(self,
username,
password,
API=None,
action_interval=8.0,
rate=120,
interval=5400,
unfollow_all=True):
self.username = username
self.password = password
self.action_interval = action_interval
self.rate = rate
self.interval = interval
self.unfollow_all = unfollow_all
try:
from app import logger
logger = get_logger()
except ImportError:
pass
self.logger = logging.LoggerAdapter(logger, {
'user': self.username,
'bot': 'instaunfollow'
})
self.API = Client(self.username, self.password) if API is None else API
self.webAPI = WebClient()
def InstagramPoster(photo, description, credit):
import requests
import json
import time
from random import randint
from instagram_private_api import Client, MediaRatios
from instagram_private_api_extensions import media
from PIL import Image
global instagram_username, instagram_password, insta_hashtags
InstagramAPI = Client(instagram_username, instagram_password)
try:
mycaption = '"' + description + '"' + " (Via: u/" + credit + ")\n\n.\n.\n.\n.\n.\n.\n" + insta_hashtags
try:
post_before = NumberOfPosts(instagram_username)
photo_data, photo_size = media.prepare_image(
'picture_to_post.jpg', aspect_ratios=MediaRatios.standard)
InstagramAPI.post_photo(photo_data, photo_size, caption=mycaption)
if NumberOfPosts(instagram_username) == post_before:
print("ERROR: It did not post, please try again!")
else:
print("Photo posted!")
except Exception as e:
print("Error...")
exit(0)
except Exception as e:
print(e)
def edit_profile(api: Client) -> None:
"""
Available personal data is edited.
What are full name, private account, biography, url, email, phone number and gender
Arguments:
api (Client) - object Client instagram
"""
# I call _call_api because the original function "current_user" was passing wrong parameters
# and the request was not made correctly
user_profile = api._call_api('accounts/current_user/',
query={'edit': 'true'})['user']
text_to_print = "Your actual profile is: \n"
genders = ['male', 'female', 'unspecified']
print_write_chatbot(text_to_print)
attributes = {
'Full name': 'full_name',
'Private account': 'is_private',
'Biography': 'biography',
'External url': 'external_url',
'Email': 'email',
'Phone number': 'phone_number',
'Gender': 'gender',
}
new_profile_data = {}
all_data = show_profile_data(user_profile, attributes, genders)
text_to_print += all_data
get_new_profile_data(user_profile, attributes, new_profile_data, genders)
try:
status_account = api.set_account_private(
) if new_profile_data['is_private'] else api.set_account_public()
result = api.edit_profile(
first_name=new_profile_data['full_name'],
biography=new_profile_data['biography'],
external_url=new_profile_data['external_url'],
email=new_profile_data['email'],
gender=int(new_profile_data['gender']),
phone_number=new_profile_data['phone_number'])
if result and status_account['status'] == 'ok':
text = "Profile has been modified successfully!"
print_write_chatbot(message=text,
color='green',
attrs_color=['bold'])
else:
text = "There was a problem updating the profile, please try again\n"
print_write_chatbot(message=text,
color='red',
attrs_color=['bold'])
except Exception as error:
write_log(STATUS_FILE, str(error), 'Exception')
print_write_chatbot(f"There was an error:{error}",
color='red',
attrs_color=['bold'])
def __init__(self, instaData):
self.data = instaData
self.instaApi = Client("sammy.g.spam", "vq86koli")
self.counter = 6
self.comments = {}
self.maybe = {}
self.contestants = []
print("InstagramValidityCheck.State : Initialized")
def do_authenticate(args, app_logger):
'''
Authenticate using user and password
'''
app_logger.debug('Authenticating against Instagram')
try:
cache_file = args.cache_file_path
if not os.path.isfile(cache_file):
app_logger.debug('Unable to find file: {0!s}'.format(cache_file))
app_logger.debug('Continuing with new login...')
api = Client(args.username,
args.password,
on_login=lambda x: onlogin_callback(
x, args.cache_file_path, app_logger))
else:
app_logger.debug(
'Loading cache from file: {0!s}'.format(cache_file))
cached_settings = read_json_file(cache_file, app_logger)
#with open(cache_file) as file_data:
# cached_settings = json.load(file_data, object_hook=from_json)
device_id = cached_settings.get('device_id')
app_logger.debug('Reusing auth settings...')
api = Client(args.username,
args.password,
settings=cached_settings)
except (ClientCookieExpiredError, ClientLoginRequiredError) as auth_err:
app_logger.debug(
'ClientCookieExpiredError/ClientLoginRequiredError: {0!s}'.format(
auth_err))
app_logger.debug('Login expired...')
app_logger.debug('Doing relogin with same UA and settings...')
api = Client(args.username,
args.password,
device_id=device_id,
on_login=lambda x: onlogin_callback(
x, args.cache_file_path, app_logger))
except ClientLoginError as auth_err:
app_logger.critical('ClientLoginError {0!s}'.format(auth_err))
sys.exit(9)
except (ClientCheckpointRequiredError,
ClientChallengeRequiredError) as auth_err:
app_logger.critical(
'ClientChallengeRequired {0!s} (Code: {1:d}, Response: {2!s})'.
format(auth_err.msg, auth_err.code, auth_err.error_response))
sys.exit(9)
except ClientError as auth_err:
app_logger.critical(
'ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(
auth_err.msg, auth_err.code, auth_err.error_response))
sys.exit(9)
except Exception as auth_err:
app_logger.critical('Unexpected Exception: {0!s}'.format(auth_err))
sys.exit(99)
cookie_expiry = api.cookie_jar.auth_expires
app_logger.debug('Cookie Expiry: {0!s}'.format(
datetime.fromtimestamp(cookie_expiry).strftime('%Y-%m-%dT%H:%M:%SZ')))
return api
def get_instagram_users(search, max_id=None):
user_name = 'lam.laca'
password = '******'
api = Client(user_name, password)
if max_id:
results = api.search_users(search, max_id=max_id)
else:
results = api.search_users(search)
return results
def init_grammer(self, iduser):
self.id_user = iduser
self.datauser = self.get_auth_data()
instalogin = self.datauser['login']
instapwd = self.datauser['passwd']
instacookie = self.datauser['cookie']
device_id = None
settings_file = instacookie
try:
if not os.path.isfile(settings_file):
# settings file does not exist
#если файл куки не найден то он создается
#print('Невозможно найти файл: {0!s}'.format(settings_file))
# login new
api = Client(
instalogin, instapwd,
on_login=lambda x: self.onlogin_callback(x, instacookie))
return api
else:
#если куки найдены то они используются
with open(settings_file) as file_data:
cached_settings = json.load(file_data, object_hook = self.from_json)
#print('Повторное использование настроек: {0!s}'.format(settings_file))
device_id = cached_settings.get('device_id')
# reuse auth settings
api = Client(
instalogin, instapwd,
settings=cached_settings)
return api
except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
print('ClientCookieExpiredError/ClientLoginRequiredError: {0!s}'.format(e))
#если куки просрочены или нужна авторизация то
#происходит перезапись куков и авторизация
# Login expired
# Do relogin but use default ua, keys and such
api = Client(
instalogin, instapwd,
device_id=device_id,
on_login=lambda x: self.onlogin_callback(x, instacookie))
return api
except ClientLoginError as e:
print('ClientLoginError {0!s}'.format(e))
exit(9)
except ClientError as e:
print('ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(e.msg, e.code, e.error_response))
exit(9)
except Exception as e:
print('Unexpected Exception: {0!s}'.format(e))
exit(99)
def get_stories(twitter_api):
last = src.last.get_last(src.last.PostType.STORY)
highest = last
try:
if not os.path.isfile(SETTINGS_FILE_PATH):
insta_api = Client(
USERNAME,
PASSWORD,
on_login=lambda x: login_callback(x, SETTINGS_FILE_PATH))
else:
with open(SETTINGS_FILE_PATH) as settings_file:
cached_settings = json.load(settings_file,
object_hook=from_json)
print('Reusing settings: {0!s}'.format(SETTINGS_FILE_PATH))
insta_api = Client(USERNAME, PASSWORD, settings=cached_settings)
#except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
except Exception as e:
print('Exception: {0!s}'.format(e))
exit(-1)
# Show when login expires
cookie_expiry = insta_api.cookie_jar.auth_expires
print('Cookie Expiry: {0!s}'.format(
datetime.datetime.fromtimestamp(cookie_expiry).strftime(
'%Y-%m-%dT%H:%M:%SZ')))
data = insta_api.user_story_feed(os.getenv('INSTAGRAM_USERID'))
if data['reel'] != None:
for item in data['reel']['items']:
story_id = item['pk']
if (story_id > last):
print(story_id)
print(item['taken_at'])
timestamp = datetime.datetime.fromtimestamp(
item['taken_at'], pytz.timezone('Asia/Tokyo'))
tweet_data = [
'【Story】 #鈴木このみ ',
timestamp.strftime('%Y-%m-%d %H:%M')
]
if os.getenv('ENV', 'dev') == 'production':
twitter_api.PostUpdate(''.join(tweet_data),
item['video_versions'][0]['url'])
else:
twitter_api.write(''.join(tweet_data) + '\n\n')
twitter_api.write(item['video_versions'][0]['url'] +
'\n\n')
if story_id > highest:
highest = story_id
if highest > last:
src.last.set_last(str(highest), src.last.PostType.STORY)
def __init__(self, username, password, API=None, action_interval=8.0, rate=1, interval=86400):
self.username = username
self.password = password
self.action_interval = action_interval
self.rate = rate
self.interval = interval
self.logger = logging.LoggerAdapter(logger, {'user': self.username, 'bot': 'instapost'})
self.API = Client(self.username, self.password) if API is None else API
def get_client(username, password) -> Client:
if os.path.isfile(settings_file_path):
print(f'Reusing settings: {settings_file_path}')
device_id = get_settings().get('device_id')
return Client(username, password, settings=get_settings())
return Client(username,
password,
on_login=lambda x: onlogin_callback(x, settings_file_path))
def get_non_followers(username, password, my_max_following=1000):
api = Client(username, password, timeout=30)
print('Successfully Logged In.')
my_account = api.username_info(username)['user']
# Getting my following list
my_following = api.user_following(my_account['pk'], api.generate_uuid())
all_following = [*my_following['users']]
print('Getting your followers...')
sleep(2) # mimicking the real user
while len(my_following) < my_max_following and my_following['next_max_id']:
next_list = api.user_following(my_account['pk'],
api.generate_uuid(),
max_id=my_following['next_max_id'])
print(next_list['next_max_id'])
all_following += next_list['users']
sleep(2) # mimicking the real user
if not next_list['next_max_id']:
break
# Checking
print('Checking...')
not_following = 0
for user in all_following:
try:
resp = api.user_following(user['pk'],
api.generate_uuid(),
query=username)
if not resp['users']:
print(f"@{user['username']} is not following you back")
not_following += 1
except:
pass
print(f'Total of {not_following} accounts do not follow you back')
def Login(self, username, password):
device_id = None
api = None
try:
settings_file = 'info.json'
if not os.path.isfile(settings_file):
# settings file does not exist
self.PrintText('UNABLE TO FIND FILE',
'{0!s}'.format(settings_file), Fore.MAGENTA,
Fore.MAGENTA)
# login new
api = Client(
username,
password,
on_login=lambda x: self.onlogin_callback(x, settings_file))
else:
with open(settings_file) as file_data:
cached_settings = json.load(file_data,
object_hook=self.from_json)
self.PrintText('REUSING SETTINGS',
'{0!s}'.format(settings_file), Fore.MAGENTA,
Fore.MAGENTA)
device_id = cached_settings.get('device_id')
# reuse auth settings
api = Client(username, password, settings=cached_settings)
except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
self.PrintText('ClientCookieExpiredError/ClientLoginRequiredError',
'{0!s}'.format(e), Fore.RED, Fore.RED)
# Login expired
# Do relogin but use default ua, keys and such
api = Client(
username,
password,
device_id=device_id,
on_login=lambda x: self.onlogin_callback(x, settings_file))
except ClientLoginError as e:
self.PrintText('ClientLoginError', '{0!s}'.format(e), Fore.RED,
Fore.RED)
except ClientError as e:
self.PrintText(
'ClientError {0!s}', '(Code: {1:d}, Response: {2!s})'.format(
e.msg, e.code, e.error_response), Fore.RED, Fore.RED)
except Exception as e:
self.PrintText('Unexpected Exception', '{0!s}'.format(e), Fore.RED,
Fore.RED)
# Show when login expires
#cookie_expiry = api.cookie_jar.auth_expires
#print('Cookie Expiry: {0!s}'.format(datetime.datetime.fromtimestamp(cookie_expiry).strftime('%Y-%m-%dT%H:%M:%SZ')))
return api
def login(args):
settings_file_path = args.settings_file_path
username = args.username
password = args.password
print('Client version: {0!s}'.format(client_version))
device_id = None
try:
settings_file = settings_file_path
if not os.path.isfile(settings_file):
# settings file does not exist
print('Unable to find file: {0!s}'.format(settings_file))
print('New login...')
# login new
api = Client(
username, password,
on_login=lambda x: onlogin_callback(x, settings_file_path))
else:
with open(settings_file) as file_data:
cached_settings = json.load(file_data, object_hook=from_json)
print('Reusing settings: {0!s}'.format(settings_file))
device_id = cached_settings.get('device_id')
# reuse auth settings
api = Client(
username, password,
settings=cached_settings)
except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
print('ClientCookieExpiredError/ClientLoginRequiredError: {0!s}'.format(e))
print('New login using default ua, keys etc...')
# Login expired
# Do relogin but use default ua, keys and such
api = Client(
username, password,
device_id=device_id,
on_login=lambda x: onlogin_callback(x, settings_file_path))
except ClientLoginError as e:
print('ClientLoginError {0!s}'.format(e))
exit(9)
except ClientError as e:
print('ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(e.msg, e.code, e.error_response))
exit(9)
except Exception as e:
print('Unexpected Exception: {0!s}'.format(e))
exit(99)
# Show when login expires
cookie_expiry = api.cookie_jar.expires_earliest
print('Cookie Expiry date: {0!s}'.format(datetime.datetime.fromtimestamp(cookie_expiry).strftime('%Y-%m-%dT%H:%M:%SZ')))
return api
def generate_client_from_cache(username: str, password: str, settingsFilePath: str = None) -> object:
"""
Summary:
Generates an instance of instagram_private_api.Client that reuses saved settings,
like cookies, to minimize login attempts. If no file exists, then a settings file
will be generated.
CREDIT: https://github.com/ping/instagram_private_api
Args:
username: a valid instagram username
password: a valid instagram password
settingsFilePath: (optional) the path to the file that holds settings
Returns:
An instance of instagram_private_api.Client
"""
try:
if settingsFilePath == None:
settingsFile = "instagram_client_cache.json"
else:
settingsFile = settingsFilePath
if not os.path.isfile(settingsFile):
# settings file does not exist
print('Unable to find file: {0!s}'.format(settingsFile))
# login new
api = Client(
username, password,
on_login=lambda x: onlogin_callback(x, settingsFile))
else:
with open(settingsFile) as fileData:
cachedSettings = json.load(fileData, object_hook=from_json)
print('Reusing settings: {0!s}'.format(settingsFile))
#deviceId = cachedSettings.get('device_id')
# reuse auth settings
api = Client(
username, password,
settings=cachedSettings)
return api
except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
print('ClientCookieExpiredError/ClientLoginRequiredError: {0!s}'.format(e))
# Login expired
# Do relogin but use default ua, keys and such
api = Client(
username, password,
on_login=lambda x: onlogin_callback(x, settingsFilePath))
except ClientLoginError as e:
print('ClientLoginError {0!s}'.format(e))
exit(9)
except ClientError as e:
print('ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(e.msg, e.code, e.error_response))
exit(9)
except Exception as e:
print('Unexpected Exception: {0!s}'.format(e))
exit(99)
def connection_instagram(user_credentials: dict = {}) -> object:
"""
The connection with the instagram api is generated (instagram_private_api module)
Arguments:
user_credentials (dict) = Dictionary in which the credentials of the user's instagram
account are stored (default {})
Returns:
object - The Client object
"""
api = ''
if not user_credentials:
credentials = get_credentials()
username = credentials['instagram']['username']
password = credentials['instagram']['password']
else:
username = user_credentials['username']
password = user_credentials['password']
settings_file = os.path.abspath('credentials/instagram_api.json')
if os.path.isfile(settings_file):
delete_expired_cookie(settings_file)
if not os.path.isfile(settings_file):
# If the credentials do not exist, do a new login
try:
api = Client(
username,
password,
on_login=lambda x: on_login_callback(x, settings_file))
except Exception as err:
write_log(STATUS_FILE, str(err), "Exception")
else:
# If the credentials do not exist, do a new login
cached_settings = get_cached_settings(settings_file)
device_id = cached_settings.get('device_id')
try:
api = Client(username,
password,
device_id=device_id,
settings=cached_settings)
except Exception as e:
write_log(STATUS_FILE, str(e), "Exception")
print_write_chatbot(
"You have successfully connected with the instagram! \n",
color='green',
attrs_color=['bold'])
return api
def login(self, u, p):
try:
settings_file = "config/settings.json"
if not os.path.isfile(settings_file):
# settings file does not exist
print('Unable to find file: {0!s}'.format(settings_file))
# login new
self.api = AppClient(
auto_patch=True,
authenticate=True,
username=u,
password=p,
on_login=lambda x: self.onlogin_callback(x, settings_file))
else:
with open(settings_file) as file_data:
cached_settings = json.load(file_data,
object_hook=self.from_json)
# print('Reusing settings: {0!s}'.format(settings_file))
# reuse auth settings
self.api = AppClient(
username=u,
password=p,
settings=cached_settings,
on_login=lambda x: self.onlogin_callback(x, settings_file))
except (ClientCookieExpiredError, ClientLoginRequiredError) as e:
print('ClientCookieExpiredError/ClientLoginRequiredError: {0!s}'.
format(e))
# Login expired
# Do relogin but use default ua, keys and such
self.api = AppClient(
auto_patch=True,
authenticate=True,
username=u,
password=p,
on_login=lambda x: self.onlogin_callback(x, settings_file))
except ClientError as e:
#pc.printout('ClientError {0!s} (Code: {1:d}, Response: {2!s})'.format(e.msg, e.code, e.error_response), pc.RED)
error = json.loads(e.error_response)
pc.printout(error['message'], pc.RED)
pc.printout(": ", pc.RED)
pc.printout(e.msg, pc.RED)
pc.printout("\n")
if 'challenge' in error:
print("Please follow this link to complete the challenge: " +
error['challenge']['url'])
exit(9)
