class Endpoint:
def __init__(self, username, password):
self.username = username
self.password = password
self.api = Client(username, password)
def getUserID(self):
return self.api.authenticated_user_id
def getFollowers(self, userid):
return self.api.user_followers(userid, self.api.generate_uuid())
def getFollowing(self, userid):
return self.api.user_following(userid, self.api.generate_uuid())
def getFeedLiked(self):
return self.api.feed_liked()
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)
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')))
rank_token = Client.generate_uuid()
tag_results = []
resultsForTimeline = api.feed_timeline()
resultsForLikedFeeds = api.feed_liked()
apple = json.dumps([resultsForTimeline], indent=100)
mango = json.dumps([resultsForLikedFeeds], indent=100)
y = json.loads(apple)
z = json.loads(mango)
stringList = []
for s in y:
for e in s['feed_items']:
try:
stringList.append(e['media_or_ad']['caption']['text'])
except:
print('')
captionDetails = []
# print (str)
# # byteString = unicode_string.encode(str)
# api.post_photo(str, (436,436), caption='my cat! #cat #kitten')
def get_user_with_hashtag (hashtag):
rank_token = api.generate_uuid()
tagged = api.feed_tag(hashtag, rank_token)
items = tagged.get('items', [])
# paginate here
userIds = []
for item in items:
print(item['user']['username'])
userIds.append(item['user']['username'])
print(userIds)
return userIds
like_count = 0
liked_feed = api.feed_liked()
# print(len(liked_feed['items']))
# print(liked_feed['items'][0].keys())
# for item in items:
# if like_count < 20:
# # Manually patch the entity to match the public api as closely as possible, optional
# # To automatically patch entities, initialise the Client with auto_patch=True
# ClientCompatPatch.media(item)
# print(item['id'])
# api.post_like(item['id'], 'feed_timeline')
# like_count += 1
get_user_with_hashtag('blockchain')
userID = api.authenticated_user_id
conn = sqlite3.connect(":memory:")
# conn = sqlite3.connect('test.db')
conn.text_factory = str
conn.execute('''CREATE TABLE YourActions
(pk INT PRIMARY KEY NOT NULL,
username TEXT,
full_name TEXT,
is_following INTEGER,
Number_of_Liked_Posts INTEGER,
UNIQUE(pk)
);''')
result = api.feed_liked()
items = result.get('items', [])
counter = 1
for x in items:
media_id = x.get('pk', [])
like_count = str(x.get('like_count', []))
comment_count = str(x.get('comment_count', []))
post_sender = x.get('user', [])
sender_username = post_sender.get('username', [])
sender_full_name = post_sender.get('full_name', [])
sender_pk = post_sender.get('pk', [])
friendship_status_with_sender = post_sender.get('friendship_status', [])
do_u_follow_sender = '1' if friendship_status_with_sender.get(
'following', []) else '0'
is_bestie = friendship_status_with_sender.get('is_bestie', [])
print("Working on media NO " + str(counter) + " ==> " + str(media_id))
#####################Лайкинг####################################
my_id = api.authenticated_user_id
rank_tok = api.generate_uuid()
print('ID: ' + my_id)
print('RANK_TOKEN: ' + rank_tok)
print()
conn = psycopg2.connect(dbname='grammer',
user='******',
password='******',
host='localhost')
cursor = conn.cursor()
liked_feed = api.feed_liked()
mid = liked_feed['next_max_id']
print('максимальный ID: ' + str(mid))
ss = 1 #сквозной счетчик
sp = 0 #Счетчик постов
while mid:
try:
print()
print('Проход #' + str(ss))
like_posts = []
liked_feed = api.feed_liked(max_id=mid)
for like in liked_feed['items']:
sp += 1
class Unliker():
def to_json(self, python_object):
if isinstance(python_object, bytes):
return {
'__class__': 'bytes',
'__value__': codecs.encode(python_object, 'base64').decode()
}
raise TypeError(repr(python_object) + ' is not JSON serializable')
def from_json(self, json_object):
if '__class__' in json_object and json_object['__class__'] == 'bytes':
return codecs.decode(json_object['__value__'].encode(), 'base64')
return json_object
def onlogin_callback(self, api, new_settings_file):
cache_settings = api.settings
with open(new_settings_file, 'w') as outfile:
json.dump(cache_settings, outfile, default=self.to_json)
print('SAVED: {0!s}'.format(new_settings_file))
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 followerFilter(self, post):
return post['user']['username'] in self.following
def dogFilter(self, post):
user = post['user']['username']
if post['caption']:
caption = post['caption']['text']
return 'dog' in caption or 'dog' in user or 'corg' in caption or 'corg' in user
else:
return False
def unlike(self, filters=[followerFilter], max_remove=40):
removed = 0
while removed < max_remove:
liked = self.api.feed_liked()
print('Beginning deletion of liked photos')
for p in liked['items']:
post_id = p['id']
if not any([f(p) for f in filters]):
print('Deleted', post_id, 'by', p['user']['username'])
self.api.delete_like(post_id)
removed += 1
if removed >= max_remove:
break
print('Grabbing more posts...')
while True:
liked = self.api.feed_liked()
if liked['status'] == 'ok':
break
print('Grabbed', liked['num_results'], 'more posts.')
if liked['num_results'] == 0:
print("No more posts to unlike.")
break
print('Finished deleting liked photos')
