def __init__(self, name, sid) -> None: super().__init__(name) self.sid = sid self.connexion_time = datetime.now() self.connexion_time_stamp = self.connexion_time.strftime( '%B %d, %Y %H:%M:%S') self.rooms: ChatroomList = ChatroomList() self.mongo_manager = MongoManager()
def __init__(self, name: str) -> None: if name.startswith(PrivateChatroom.PRIVATE_TAG): raise InvalidName() super().__init__(name) self.mongo_manager = MongoManager() try: self.mongo_manager.create_chatroom(name) except Exception: # TODO MAYBE HANDLE THIS BETTER, MAYBE IGNORE pass
def __init__(self, name: str, lang: str, diff: str = '') -> None: super().__init__(name) self.users: UserList = UserList() self.chatroom: PrivateChatroom = PrivateChatroom(name) self.current_img = "" self.mongo_manager = MongoManager() self.lang = lang self.diff = diff self.current_word = self._get_word() self.word = self.current_word['word'] self.tries = 0 self.round_counter = 0 self.is_full = (self.users.length() == self.MAX_USERS) self.creator = None self.is_started = False
class PublicChatroom(Chatroom): def __init__(self, name: str) -> None: if name.startswith(PrivateChatroom.PRIVATE_TAG): raise InvalidName() super().__init__(name) self.mongo_manager = MongoManager() try: self.mongo_manager.create_chatroom(name) except Exception: # TODO MAYBE HANDLE THIS BETTER, MAYBE IGNORE pass def message(self, message: UserMessage) -> None: super().message(message) self.mongo_manager.add_chatroom_logs(self.name, message) def get_logs(self) -> list[UserMessage]: return self.mongo_manager.get_chatroom_logs(self.name)
def on_message(self, headers, message): print('Iniciou o processamento!') ia = machine.IA() ia.trainning(message) print('Treinamento concluído!') mongo = MongoManager() connection_mongo = mongo.connectMongo( mongo_address=mongo._mongo_address, database=mongo._database) products = mongo.getProducts(mongoConnection=connection_mongo, collection=mongo._collection) print('Dados coletados do mongo') ia.predict(products) mongo.clearMongo(mongoConnection=connection_mongo, collection=mongo._collection) print('predições feitas') mysql = MySQLManager() connection_mysql = mysql.connectDefaultMySQL() print(ia.objectProducts[0].link) mysql.saveResults(connection=connection_mysql, products=ia.objectProducts) print('Finalizou o processamento!')
from gameroom.gameroom import Gameroom, GameroomList from gameroom.solo_gameroom import SoloGameroom from gameroom.tuto_gameroom import TutoGameroom from message import UserMessage from mongo_manager import AbsentEntryError, MissingParameterError, MongoManager from user import User, UserList Payload.max_decode_packets = 1000 app = Flask(__name__) app.config['SECRET_KEY'] = random.randbytes(16) socketio = SocketIO(app, cors_allowed_origins="*", ping_timeout=12000) connectedUsers = {} connected_users_list = UserList() db = MongoManager() chatrooms = ChatroomList() gamerooms = GameroomList() ######### # UTILS # ######### def verify_session(event): def verify_session_decor(fn): def wrapper(*args, **kwargs): user = connected_users_list.get_instance_by_sid(request.sid) if user is None: print(f'Unauthorized user event: {event}') resp = get_resp(0, 'Unauthorized: user not connected', {}) emit(event, resp)
POINTS_AWARDED = "points_awarded" QUESTIONS = "questions" WAGERS = "wagers" ROUNDS_USED = "rounds_used" GAME = "game" SESSION = "session" CORRECT = "correct" SCOREBOARD = "scoreboard" ROUND_NAMES = "round_names" MONGO_HOST = "localhost" MONGO_DB = "trivia" URL_BASE = "/gameplay" mongo = MongoManager(MONGO_HOST, MONGO_DB) def create_and_respond(endpoint, data): """ try to create some object and return a failure/success resp """ if endpoint == "session": return _resp(create_session(data)) if endpoint == "player": return _resp(create_player(data)) raise Exception(f"unsupported create '{endpoint}'") def update_and_respond(endpoint, object_id, data):
class Gameroom(Instance): MAX_USERS = 4 ROLES = ["Dessinateur", "Devineur"] def __init__(self, name: str, lang: str, diff: str = '') -> None: super().__init__(name) self.users: UserList = UserList() self.chatroom: PrivateChatroom = PrivateChatroom(name) self.current_img = "" self.mongo_manager = MongoManager() self.lang = lang self.diff = diff self.current_word = self._get_word() self.word = self.current_word['word'] self.tries = 0 self.round_counter = 0 self.is_full = (self.users.length() == self.MAX_USERS) self.creator = None self.is_started = False def on_start(self, timestamp): pass def send_drawing_info(self, drawing_info): emit('drawing_info', { 'code': 1, 'data': drawing_info }, room=self.chatroom.name) def emit_end_line(self, type): emit('end_line', { 'code': 1, 'data': { 'type': type } }, room=self.chatroom.name) def is_user_here(self, user): if user in self.users: return True return False def reply_right(self, timestamp): pass def clear_users(self): copy_users = self.users.instances.copy() for user in copy_users: self.users.remove(user) if (not isinstance(user, VirtualPlayer)): user.rooms.remove(self.chatroom) self.chatroom.leave(user) def game_done(self): pass def add_virt_player(self, type, team): pass def remove_virt_player(self, team): pass def join(self, user: User) -> None: if self.users.length() >= self.MAX_USERS: raise RoomAlreadyFullError() if self.users.get_instance_by_sid(user.sid) is not None: raise UserAlreadyInRoomError() self.users.add(user) if (not isinstance(user, VirtualPlayer)): self.chatroom.join(user) user.rooms.add(self.chatroom) def leave(self, user: User) -> None: self.users.remove(user) if (not isinstance(user, VirtualPlayer)): user.rooms.remove(self.chatroom) self.chatroom.leave(user) def message(self, message: UserMessage) -> None: self.chatroom.message(message) def get_logs(self): return self.chatroom.get_logs() def verify_answer(self, answer: str) -> bool: return self.word.lower() == answer.lower() def handle_gameroom_message(self, user: User, message: str): message = UserMessage(user.name, message) self.chatroom.message(message) def get_end_time_stamp(self, start_time_stamp): end_time_stamp = "" if self.diff == "hard": end_time_stamp = start_time_stamp + timedelta(seconds=30) elif self.diff == "mid": end_time_stamp = start_time_stamp + timedelta(minutes=1) elif self.diff == "easy": end_time_stamp = start_time_stamp + \ timedelta(minutes=1, seconds=30) return end_time_stamp.strftime('%B %d, %Y %H:%M:%S') def get_number_of_tries(self): num_of_tries = 0 if self.diff == "hard": num_of_tries = 2 elif self.diff == "mid": num_of_tries = 4 elif self.diff == "easy": num_of_tries = 6 return num_of_tries def get_hint(self, user): pass def get_type(self): pass def get_word(): pass def _get_word(self) -> str: words = self.mongo_manager.get_words({ 'lang': self.lang, 'diff': self.diff }) rand = random.randint(0, len(words) - 1) return words[rand] def get_usernames(self): usernames = [] for user in self.users: usernames.append(user.name) return usernames
class User(Instance): def __init__(self, name, sid) -> None: super().__init__(name) self.sid = sid self.connexion_time = datetime.now() self.connexion_time_stamp = self.connexion_time.strftime( '%B %d, %Y %H:%M:%S') self.rooms: ChatroomList = ChatroomList() self.mongo_manager = MongoManager() def __del__(self) -> None: session_length = self.calculate_session_length() pass def get_avatar(self): db_user = self.mongo_manager.get_user(self.name) return db_user['avatar'] def get_first_name(self): db_user = self.mongo_manager.get_user(self.name) return db_user['first_name'] def get_last_name(self): db_user = self.mongo_manager.get_user(self.name) return db_user['last_name'] def leave_all_rooms(self) -> None: for room in rooms(self.sid)[1:]: leave_room(room, self.sid) def join_room(self, room: Chatroom) -> None: self.rooms.add(room) room.join(self) self.mongo_manager.add_user_chatroom(self.name, room.name) def leave_room(self, room: Chatroom) -> None: self.rooms.remove(room) room.leave(self) self.mongo_manager.remove_user_chatroom(self.name, room.name) def calculate_session_length(self): return datetime.now() - self.connexion_time def get_stats(self) -> dict: user_data = self.mongo_manager.get_user(self.name) win_count = user_data['win_count'] lose_count = user_data['lose_count'] game_times = user_data['game_times'] object_game_times = [pickle.loads(item) for item in game_times] total_game_time = self.get_timedelta_sum(object_game_times) connections: list[datetime] = user_data['connection_timestamps'] disconnections: list[datetime] = user_data['disconnection_timestamps'] connection_timestamps = [ User.jsonify_date(entry) for entry in connections ] disconnection_timestamps = [ User.jsonify_date(entry) for entry in disconnections ] user_stats = { 'first_name': self.get_first_name(), 'last_name': self.get_last_name(), 'user_name': self.name, 'avatar': self.get_avatar(), 'game_count': win_count + lose_count, 'win_ratio': 0.00 if win_count + lose_count == 0 else (win_count / (win_count + lose_count)) * 100, 'average_game_time': User.jsonify_timedelta(timedelta(seconds=0)) if len(game_times) == 0 else User.jsonify_timedelta( (total_game_time / len(game_times))), 'total_game_time': User.jsonify_timedelta(total_game_time), 'connection_timestamps': connection_timestamps, 'disconnection_timestamps': disconnection_timestamps, 'solo_max_score': self.get_max_solo_score(), 'game_history': user_data['game_history'] } return user_stats def log_connection(self) -> None: self.mongo_manager.add_connection(self.name, datetime.now()) def log_disconnection(self) -> None: self.mongo_manager.add_disconnection(self.name, datetime.now()) def log_game_results(self, results: dict) -> None: self.mongo_manager.add_game_results(self.name, results) def log_win(self) -> None: self.mongo_manager.increment_win_count(self.name) def log_lose(self) -> None: self.mongo_manager.increment_lose_count(self.name) def log_game_time(self, game_time: timedelta) -> None: game_time = pickle.dumps(game_time) self.mongo_manager.add_game_time(self.name, game_time) def get_timedelta_sum(self, deltas: list[timedelta]) -> timedelta: sum = timedelta(seconds=0) for delta in deltas: sum = sum + delta return sum def get_max_solo_score(self): user_data = self.mongo_manager.get_user(self.name) game_data = user_data['game_history'] max_score = 0 for game in game_data: if game['game_mode'] == 'solo': score = game['result'] if score > max_score: max_score = score return max_score @staticmethod def jsonify_date(date: datetime): return { 'date': { 'year': date.year, 'month': date.month, 'day': date.day }, 'time': { 'hour': date.hour, 'minute': date.minute, 'second': date.second } } @staticmethod def jsonify_timedelta(timedelta: timedelta): return { 'days': timedelta.days, 'hours': timedelta.seconds // 3600, 'minutes': (timedelta.seconds // 60) % 60, 'seconds': timedelta.seconds % 60 }
def run(): args = parse_commandline_args() init_logging(args.config) logging.info(' ---------- ') logging.info(' started downloader with action: %s', args.action) logging.info(' ---------- ') if args.action == "download_notes": mm = MongoManager() downloader = Downloader(username=args.username, password=args.password, debug=args.debug) downloader.download_data( max_records=args.max_records, pagesize=args.page_size, mongo_manager=mm, download_details=args.download_details) elif args.action == "download_note_details": mm = MongoManager() downloader = Downloader(username=args.username, password=args.password, debug=args.debug) downloader.download_note_details(mm, pagesize=args.page_size) elif args.action == "update_orders": downloader = Downloader(username=args.username, password=args.password, debug=args.debug) orders = downloader.download_data( max_records=args.max_records, pagesize=args.page_size) logging.info('%s records fetched', len(orders)) if not args.skip_db: mm = MongoManager() mm.update_orders(orders) logging.info('%s orders updated in mongo', len(orders)) if args.filename: write_csv(orders, args.filename) logging.info('finished writing to %s', args.filename) elif args.action == "update_loans": downloader = Downloader() loans = downloader.download_historical_loan_data() if not args.skip_db: mm = MongoManager() mm.update_loans(loans) logging.info('%s loans updated in mongo', len(loans)) elif args.action == "show_volumes": mm = MongoManager() start = time.time() - 2*7*24*60*60 # show last two weeks of data end = time.time() - 60*60 # omit the last hour volumes = mm.get_market_volumes(start, end) for v in volumes: mytime = datetime.datetime.fromtimestamp(v['period_start']).ctime() print '[%s] +%d / -%d' % ( mytime, v['records_added'], v['records_removed']) else: logging.error('unknown action: %s', args.action)