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)