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