def is_bastard_by_entity(self, user_):
can_send_friend_request = user_.get('can_send_friend_request', 0)
deactivated = True if user_.get('deactivated', None) else False
has_photo = user_.get('has_photo', 0)
bastard = not (not deactivated or has_photo != 0)
info('can_send_friend_request: {}. deactivated: {}. has_photo: {}. bastard: {}'.format(str(can_send_friend_request), str(deactivated), str(has_photo), str(bastard)))
return bastard, can_send_friend_request, deactivated, has_photo
def group_get_invited_users(self, count=20, offset=0, fields=None):
info('[Group] get invited users. count: "{}". offset: {}. fields: {}'.
format(str(count), str(offset), str(fields)))
return self.vk.groups.getInvitedUsers(group_id=self.group_id,
offset=offset,
count=count,
fields=fields)
def group_get_invites(self, count=20, offset=0, extended=0):
info('[Group] get invites. count: "{}". offset: {}. extended: {}'.
format(str(count), str(offset), str(extended)))
return self.vk.groups.getInvites(group_id=self.group_id,
offset=offset,
count=count,
extended=extended)
def create_post(self, wall_item, owner_id, owner_name, owner_post_id,
create_date) -> bool:
try:
info('Create post. BEGIN', '\r\n')
text = self.get_wall_text(wall_item)
info('Text: "{}"'.format(str(text)))
attachments = self.get_wall_attachments(wall_item)
info('Attachments: {}'.format(attachments.__len__()))
if attachments.__len__() < 1:
error('No post was created without attachments')
return False
post_id = self.vk_app.group_wall_post(text, attachments)
info('Created post: "{}"'.format(str(post_id)))
self.db.insert_wall_posts(post_id, owner_id, owner_name,
owner_post_id, create_date)
info('Create post. END')
return True
except Exception:
error('Unknown error during create post')
error(traceback.format_exc())
return False
def load_model(self):
mdir = self.args.load_model_dir
logger.info('loading models from {}'.format(mdir))
encoder_path = os.path.join(mdir, 'encoder.model')
decoder_path = os.path.join(mdir, 'decoder.model')
self.encoder.load_state_dict(torch.load(encoder_path))
self.decoder.load_state_dict(torch.load(decoder_path))
def DeleteSeasons(self):
markedForDelete = self.db.queryIfcDB(queries.Ifc.seasonsToDeleteInStalker)
if isinstance(markedForDelete, bool): #no records to delete in Stalker found
return
for r in markedForDelete:
ss.StalkerSeasons.DeleteNonExistingSeason(self.db,r[0])
logger.info("ifc_tv_seasons: deleting non exisitng in Plex season with season_metadata_id = {}".format(r[1]))
self.db.queryIfcDB(queries.Ifc.deleteSeason.format(r[1]))
def user_get_friends(self, user_id=None, count=40, offset=0, fields=None):
info(
'[User] get friends. user_id: "{}". count: {}. offset: {}. fields: {}'
.format(str(user_id), str(count), str(offset), str(fields)))
return self.vk.friends.get(user_id=user_id,
count=count,
offset=offset,
fields=fields)
def group_wall_post(self, message: str, attachments: list, from_group=1):
info(
'[Group] wall post. Message: "{}". Attachments: {}. From group: {}'
.format(message, str(attachments), str(from_group)))
return self.vk.wall.post(owner_id='-{}'.format(self.group_id),
message=message,
attachments=','.join(attachments),
from_group=from_group).get('post_id', {})
def run(self):
info('User processing. BEGIN', '\r\n')
# execute_wrap_exception(self.remove_bastards_processing)
# execute_wrap_exception(self.incoming_request_processing)
# execute_wrap_exception(self.out_request_processing)
# execute_wrap_exception(self.invite_users_to_group_processing)
execute_wrap_exception(self.search_users_processing)
info('User processing. END')
def WriteStalkerSeasonIDs(cls, db, records_type,ids):
for t in ids:
if records_type in "new":
logger.info("Writing stalker_season_id {} against season_metadata_id {}".format(t[0],t[1]))
query = queries.Ifc.writeStalkerSeasonIDs.format(t[0],t[1])
else:
logger.info("Clearing updt_seas for season_metadata_id {}".format(t[1]))
query = queries.Ifc.muteUpdtSeasFlagInIfcSeasons.format(t[1])
db.queryIfcDB(query)
def wall_get(self, owner_id, offset=0, count=1, extended=0, fields=None):
info(
'[Wall] get. owner_id: "{}". offset: {}. count: {}. extended: {}. fields: {}'
.format(str(owner_id), str(offset), str(count), str(extended),
str(fields)))
return self.vk.wall.get(owner_id='-{}'.format(owner_id),
offset=offset,
count=count,
extended=extended,
fields=fields)
def delete_empty_post(self):
info('Check if last post is empty. BEGIN')
wall: dict = self.vk_app.wall_get(owner_id=self.group_id, offset=0)
wall_item = self.get_wall_item(wall)
attachments = self.get_wall_attachments(wall_item)
if attachments.__len__() < 1:
warn('Post created without attachments. Post will be deleted')
self.vk_app.group_delete_post(wall_item.get('id', 0))
return True
info('Check if last post is empty. Result "False"')
return False
def __init__(self,
user_id=None,
login=None,
password=None,
token=None,
group_id=None):
info(str('Init vk api'))
self.login = login
self.password = password
self.token = token
self.group_id = group_id
self.user_id = user_id
self.default_fields = 'nickname, domain, sex, bdate, city, country, timezone, photo_50, photo_100, photo_200_orig, has_mobile, contacts, education, online, relation, last_seen, status, can_write_private_message, can_see_all_posts, can_post, universities'
self.vk: VkApiMethod = self.auth()
def stop(args):
if args.debug:
logger.setLevel(args.debug)
config = Config(Request(args))
for index in xrange(config.wld_fleet_number):
if config.wld_fleet_type == 'persistent':
cancel_persistent_instances(config, index)
elif config.wld_fleet_type == 'on-demand':
cancel_on_demand_instances(config, index)
else:
cancel_fleet(config, index)
logger.info('Workload stop successfully.')
def test(args):
trainer = Trainer(args)
trainer.load_model()
for pair in trainer.test_data:
i, t, p = trainer.translate(pair)
logger.info('--' * 10)
logger.info('input: {}'.format(i))
logger.info('truth: {}'.format(t))
logger.info('predict: {}'.format(p))
def user_search(self,
has_photo=1,
age_from=0,
age_to=100,
country=1,
count=40,
offset=0,
fields='can_send_friend_request'):
info(
'[User] search. has_photo: {}, age_from: {}, age_to: {}, country: {}, count: {}, offset: {}'
.format(str(has_photo), str(age_from), str(age_to), str(country),
str(count), str(offset), str(fields)))
return self.vk.users.search(has_photo=has_photo,
country=country,
count=count,
offset=offset,
fields=fields)
def get_wall_attachments(wall_item_: dict) -> list:
attachments_ = []
for attachment in wall_item_.get('attachments', []):
doc_type = attachment.get('type', None)
if not doc_type:
continue
doc_ = attachment.get(doc_type, {})
owner_id = doc_.get('owner_id', None)
id = doc_.get('id', None)
if not doc_ or not owner_id or not id:
info('Attachment is broken')
continue
attachments_.append('{}{}_{}'.format(str(doc_type), str(owner_id),
str(id)))
return attachments_
def run(self):
try:
info('Group processing. BEGIN')
theft_result = self.get_first_wall_item()
if theft_result:
is_post_created = self.create_post(
theft_result['wall_item'], theft_result['group_id'],
theft_result['group_name'], theft_result['wall_item_id'],
theft_result['date_time'])
if not is_post_created or self.delete_empty_post():
self.run()
info('Group processing. END')
except Exception:
error('Unknown error during create post')
error(traceback.format_exc())
self.run()
def __connect(self, **kw):
con = None
try:
if kw.get('database') == "stalker":
con = mysql.connector.connect(
host=self.stalker_db_host,
user=self.stalker_db_user,
password=self.stalker_db_pass,
database=mappings.Stalker.database)
if kw.get('database') == "plex":
con = sqlite3.connect(self.plex_db_path)
if kw.get('database') == "ifc":
con = sqlite3.connect(self.ifc_db_path)
except sqlite3.Error as e:
logger.error("SQLite connection error: %s" % e)
except mysql.connector.Error as e:
logger.error("MySQL connection error: %s" % e)
logger.info("success opening {0} database connection".format(
kw.get('database')))
return con
def __init__(self, app_dir, plex_dir, stalker_db_host, stalker_db_user,
stalker_db_pass):
self.app_dir = app_dir
logger.info("Path to this application: " + self.app_dir)
self.ifc_db_path = app_dir + '/interface.db'
logger.info("Using interface db path: " + self.ifc_db_path)
self.plex_dir = plex_dir
self.plex_db_path = plex_dir + '/Plug-in Support/Databases/com.plexapp.plugins.library.db'
logger.info("Using plex db path: " + self.plex_db_path)
self.plex_metadata_dir = plex_dir + '/Metadata'
logger.info("Using plex metadata folder path: " + self.plex_db_path)
self.stalker_db_host = stalker_db_host
self.stalker_db_user = stalker_db_user
self.stalker_db_pass = stalker_db_pass
logger.info(
"Using stalker database {0} on {1}, connected as {2} user: "******"plex")
self.ifcDBcon = self.__connect(database="ifc")
self.stalkerDBcon = self.__connect(database="stalker")
def WriteStalkerVideoIDs(self):
logger.info("Updating stalker Video ID from ifc_media to ifc_tv_seasons")
ids = self.db.queryIfcDB(queries.Ifc.stalkerVideoIDtoPlexSeriesId)
if isinstance(ids, bool):
no = 0
logger.info("No series seasons for which to copy stalker Video ID")
else:
no = len(ids)
for item in ids:
logger.info("Writing Stalker Video ID {} to series_metadata_id {}".format(item[0], item[1]))
query = queries.Ifc.writeStalkerVideoIDtoSeason.format(item[0],item[1])
self.db.queryIfcDB(query)
def incoming_request_processing(self):
info('Incoming request processing. BEGIN', '\r\n')
users: dict = self.vk_app.user_get_in_requests(count=self.batch_size)
count = users.get('count', 0)
info('Found {} requests'.format(str(count)))
current_date_time = current_time()
for user_id in users.get('items', []):
bastard, can_send_friend_request, deactivated, has_photo = self.is_bastard_by_id(user_id)
if not bastard:
info('Apply user: {}'.format(str(user_id)))
self.vk_app.user_add(user_id, "APPLY")
self.db.add_user(user_id=user_id, out=0, date=current_date_time, can_send_friend_request=can_send_friend_request)
else:
self.vk_app.user_delete(user_id)
self.db.users_set_removed(user_id=user_id, date_time=current_date_time)
info('Incoming request processing. END')
def invite_users_to_group_processing(self):
info('Invite users to group processing. BEGIN', '\r\n')
for id_ in self.get_group_hand_shake_ids():
info('User id: {}'.format(str(id_)))
try:
self.vk_app.group_invite(id_)
self.db.add_user_to_group(id_)
except Exception:
error(traceback.format_exc())
info('Invite users to group processing. END')
def status(args):
if args.debug:
logger.setLevel(args.debug)
config = Config(Request(args))
total_price = 0.0
for index in xrange(config.wld_fleet_number):
if config.wld_fleet_type == 'persistent':
continue
elif config.wld_fleet_type == 'on-demand':
continue
else:
price = fleet_status(config, index)
if price:
total_price += price
if config.wld_fleet_type == 'persistent':
logger.info('We dont support persistent status yet.')
elif config.wld_fleet_type == 'on-demand':
logger.info('We dont support on-demand status yet.')
else:
logger.info('Workload total price : ' + str(total_price))
logger.info("Workload status all show.")
def SyncStalker(self):
modIDs = self.WriteToStalker()
new = [r for r in modIDs if r[2] in "new"]
updt = [r for r in modIDs if r[2] in "updated"]
if isinstance(new, list):
logger.info(
"Writing back {} stalker_season_id records into ifc_tv_seasons"
.format(len(new)))
ifc.IfcSeasons.WriteStalkerSeasonIDs(self.db, "new", new)
if isinstance(updt, list):
logger.info(
"Set as update completed for {} stalker_season_id records in ifc_tv_seasons"
.format(len(updt)))
ifc.IfcSeasons.WriteStalkerSeasonIDs(self.db, "updated", updt)
if len(modIDs) == 0:
logger.info("No new records inserted in stalker_db.video_season")
def interactive(args):
trainer = Trainer(args)
trainer.load_model()
sent = input('input a sentence: ')
sent = sent.split() + ['</s>']
sent = utils.prepare_sequence(sent, trainer.s_w2i, False).view(1, -1)
src = sent
sent = ['fake', '</s>']
sent = utils.prepare_sequence(sent, trainer.s_w2i, False).view(1, -1)
tgt = sent
pair = (src, tgt)
i, t, p = trainer.translate(pair)
logger.info('--' * 10)
logger.info('input: {}'.format(i))
logger.info('predict: {}'.format(p))
def get_group_hand_shake_ids(self) -> list:
hand_shake_ids: list = []
count_friends = self.vk_app.user_get_friends(user_id=None, count=1, offset=0, fields=None).get('count', 0)
info('Found {} friends'.format(count_friends))
if count_friends == 0:
warn('Friends not found')
return hand_shake_ids
number_of_packs = math.ceil(count_friends / self.batch_size)
info('Packs: {}'.format(number_of_packs))
current_number = 1
for i in range(0, number_of_packs):
offset = i * self.batch_size
info('Pack: {}. Offset: {}'.format(str(i), str(offset)))
friends_ids = self.vk_app.user_get_friends(user_id=None, count=self.batch_size, offset=offset, fields=None).get('items', [])
for is_member in self.vk_app.group_is_members(','.join(str(x) for x in friends_ids)):
user_id = is_member.get('user_id', 0)
if self.db.user_in_group(user_id):
continue
can_invite = is_member.get('can_invite', 0)
member = is_member.get('member', 1)
info('[{}/{}] User: {}. Member: {}. Can be invite: {}'.format(
str(current_number),
str(count_friends),
str(user_id),
str(member),
str(can_invite)
))
current_number += 1
if can_invite == 1:
hand_shake_ids.append(user_id)
if hand_shake_ids.__len__() == self.batch_size:
return hand_shake_ids
return hand_shake_ids
def remove_bastards_processing(self):
info('Remove bastards processing. BEGIN', '\r\n')
count_friends = self.vk_app.user_get_friends(user_id=None, count=1, offset=0, fields=None).get('count', 0)
info('Found {} friends'.format(count_friends))
number_of_packs = math.ceil(count_friends / self.batch_size)
for i in range(0, number_of_packs):
current_date_time = current_time()
offset = i * self.batch_size
friends_ids = self.vk_app.user_get_friends(user_id=None, count=self.batch_size, offset=offset, fields=None).get('items', [])
for friends_id in friends_ids:
bastard, can_send_friend_request, deactivated, has_photo = self.is_bastard_by_id(friends_id)
if bastard:
self.vk_app.user_delete(friends_id)
self.db.users_set_removed(user_id=friends_id, date_time=current_date_time)
info('Remove bastards processing. END')
def WriteToStalker(self):
"Updates stalker_db.video_season table with data from the interface"
ifcRecords = self.db.queryIfcDB(
queries.Ifc.toWriteinStalkerVideoSeason)
if isinstance(ifcRecords, bool):
logger.info("no ifc_tv_seasons to write or update in Stalker")
return []
new = [r for r in ifcRecords if r[0] == None]
updt = [r for r in ifcRecords if r[0] != None]
modIDs = []
if isinstance(new, list):
logger.info(
"{} ifc_tv_seasons new records will be written in Stalker".
format(len(new)))
insertQuery = queries.Stalker.insertSeason
for r in new:
params = (
r[1], #stalker_video_id
r[2], #season_index
r[3], #season_name
r[4], #nbr_episodes
datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S"), #date_add
datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S") #date_modify
)
sId = self.db.queryStalker(insertQuery, params)
modIDs.append(
(sId, r[5], "new")
) #tuple stalker_season_id, season_metadata_id - use to update ifc_tv_seasons
if isinstance(updt, list):
logger.info(
"{} ifc_tv_seasons records will be updated in Stalker".format(
len(updt)))
for r in updt:
updateQuery = queries.Stalker.updateSeason.format(r[0])
params = (
r[4], #nbr_episodes
datetime.datetime.now().strftime(
"%Y-%m-%d %H:%M:%S") #date_modify
)
sId = self.db.queryStalker(updateQuery, params)
modIDs.append((r[0], r[5], "updated"))
return modIDs
def get_first_wall_item(self, max_offset=10) -> dict:
for offset in range(0, max_offset):
for group in self.favorite_groups:
date_time = current_time()
group_id = group[1]
group_name = group[2]
attempts = group[4]
info(
'Try theft from group. Id: {}. Name: {}. Attempts: {}. Time: "{}"'
.format(str(group_id), str(group_name), str(attempts),
str(date_time)), '\r\n')
wall: dict = self.vk_app.wall_get(owner_id=group_id,
offset=offset)
wall_item = self.get_wall_item(wall)
if wall_item:
wall_item_id = wall_item.get('id', {})
info('Found wall item: {}'.format(str(wall_item_id)))
if self.db.exists_wall_post(wall_item_id):
info('The post has already been stolen')
continue
self.db.update_favorite_groups(group_id, date_time,
attempts, wall_item_id)
if self.is_ads(wall_item, self.favorite_groups):
warn('Wall item contains ads')
continue
return {
'wall_item': wall_item,
'group_id': group_id,
'group_name': group_name,
'wall_item_id': wall_item_id,
'date_time': date_time
}
else:
warn('Wall item not found')
return None
