Merge pull request #50 from d-Rickyy-b/static_typing

Static typing

Author: devcarron

database/db_wrapper.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import os
 import sqlite3
+from time import time
 
 __author__ = 'Rico'
 
@@ -23,7 +24,7 @@ def __init__(self):
             self.connection.text_factory = lambda x: str(x, 'utf-8', "ignore")
             self.cursor = self.connection.cursor()
 
-        def create_database(self, database_path):
+        def create_database(self, database_path: str) -> None:
             # Create database file and add admin and users table to the database
             open(database_path, 'a').close()
 
@@ -51,57 +52,64 @@ def create_database(self, database_path):
             connection.commit()
             connection.close()
 
-        def get_user(self, user_id):
+        def get_user(self, user_id: int) -> tuple:
             self.cursor.execute("SELECT * FROM users WHERE userID=?;", [str(user_id)])
 
             result = self.cursor.fetchone()
             if len(result) > 0:
                 return result
             else:
-                return []
+                return ()
 
-        def get_played_games(self, user_id):
+        def get_recent_players(self):
+            oneDayInSecs = 60 * 60 * 24
+            currentTime = int(time())
+            self.cursor.execute("SELECT userID FROM users WHERE lastPlayed>=?;", [currentTime - oneDayInSecs])
+
+            return self.cursor.fetchall()
+
+        def get_played_games(self, user_id: int) -> int:
             self.cursor.execute("SELECT gamesPlayed FROM users WHERE userID=?;", [str(user_id)])
 
             result = self.cursor.fetchone()
             if len(result) > 0:
-                return result[0]
+                return int(result[0])
             else:
                 return 0
 
-        def get_all_users(self):
+        def get_all_users(self) -> list:
             self.cursor.execute("SELECT rowid, * FROM users;")
             return self.cursor.fetchall()
 
-        def get_admins(self):
+        def get_admins(self) -> list:
             self.cursor.execute("SELECT userID from admins;")
             admins = self.cursor.fetchall()
             admin_list = []
             for admin in admins:
                 admin_list.append(admin[0])
             return admin_list
 
-        def get_lang_id(self, user_id):
+        def get_lang_id(self, user_id: int) -> str:
             self.cursor.execute("SELECT languageID FROM users WHERE userID=?;", [str(user_id)])
             result = self.cursor.fetchone()
             if result:
                 return result[0]
             else:
                 return "en"
 
-        def add_user(self, user_id, lang_id, first_name, last_name, username):
+        def add_user(self, user_id: int, lang_id: str, first_name: str, last_name: str, username: str) -> None:
             try:
-                self.cursor.execute("INSERT INTO users VALUES (?, ?, ?, ?, ?, 0, 0, 0, 0);", (str(user_id), str(lang_id), str(first_name), str(last_name), str(username)))
+                self.cursor.execute("INSERT INTO users VALUES (?, ?, ?, ?, ?, 0, 0, 0, 0);", (str(user_id), lang_id, first_name, last_name, username))
                 self.connection.commit()
             except sqlite3.IntegrityError:
                 pass
 
-        def insert(self, column_name, value, user_id):
-            self.cursor.execute("UPDATE users SET " + str(column_name) + "= ? WHERE userID = ?;",
-                                [str(value), str(user_id)])
+        def insert(self, column_name: str, value: str, user_id: int) -> None:
+            self.cursor.execute("UPDATE users SET " + column_name + "= ? WHERE userID = ?;",
+                                [value, str(user_id)])
             self.connection.commit()
 
-        def is_user_saved(self, user_id):
+        def is_user_saved(self, user_id: int) -> bool:
             self.cursor.execute("SELECT rowid, * FROM users WHERE userID=?;", [str(user_id)])
 
             result = self.cursor.fetchall()
@@ -110,7 +118,7 @@ def is_user_saved(self, user_id):
             else:
                 return False
 
-        def user_data_changed(self, user_id, first_name, last_name, username):
+        def user_data_changed(self, user_id: int, first_name: str, last_name: str, username: str) -> bool:
             self.cursor.execute("SELECT * FROM users WHERE userID=?;", [str(user_id)])
 
             result = self.cursor.fetchone()
@@ -123,15 +131,15 @@ def user_data_changed(self, user_id, first_name, last_name, username):
             else:
                 return True
 
-        def update_user_data(self, user_id, first_name, last_name, username):
-            self.cursor.execute("UPDATE users SET first_name=?, last_name=?, username=? WHERE userID=?;", (str(first_name), str(last_name), str(username), str(user_id)))
+        def update_user_data(self, user_id: int, first_name: str, last_name: str, username: str) -> None:
+            self.cursor.execute("UPDATE users SET first_name=?, last_name=?, username=? WHERE userID=?;", (first_name, last_name, username, str(user_id)))
             self.connection.commit()
 
-        def reset_stats(self, user_id):
+        def reset_stats(self, user_id: int) -> None:
             self.cursor.execute("UPDATE users SET gamesPlayed='0', gamesWon='0', gamesTie='0', lastPlayed='0' WHERE userID=?;", [str(user_id)])
             self.connection.commit()
 
-        def close_conn(self):
+        def close_conn(self) -> None:
             self.connection.close()
 
     instance = None
@@ -141,7 +149,7 @@ def __init__(self):
             DBwrapper.instance = DBwrapper.__DBwrapper()
 
     @staticmethod
-    def get_instance():
+    def get_instance() -> __DBwrapper:
         if not DBwrapper.instance:
             DBwrapper.instance = DBwrapper.__DBwrapper()
 

database/statistics.py

@@ -19,11 +19,11 @@ def set_game_won(user_id):
 
 def add_game_played(user_id):
     db = DBwrapper.get_instance()
-    games_played = int(db.get_played_games(user_id))
+    games_played = db.get_played_games(user_id)
     games_played = games_played + 1
     logger.debug("Add game played for userID: " + str(user_id))
     db.insert("gamesPlayed", str(games_played), user_id)
-    db.insert("lastPlayed", int(time()), user_id)
+    db.insert("lastPlayed", str(int(time())), user_id)
 
 
 def get_stats(percentage):

game/blackJack.py

@@ -26,9 +26,8 @@ def add_player(self, user_id, first_name, message_id, silent=False):
         if not self.game_running:
             if self.get_index_by_user_id(user_id) is None and len(self.players) < self.MAX_PLAYERS:
                 self.logger.debug("Adding user '" + first_name + "' to players.")
-                player = Player(user_id, first_name, self.deck)
+                player = Player(user_id, first_name, self.deck, join_id=message_id)
                 self.players.append(player)
-                self.join_message_ids.append(message_id)
 
                 if silent is False:
                     # When the parameter 'silent' is not set, a message will be sent.
@@ -39,25 +38,26 @@ def add_player(self, user_id, first_name, message_id, silent=False):
 
     def get_index_by_user_id(self, user_id):
         for index, user in enumerate(self.players):
-            if user.get_userid() == user_id:
+            if user.user_id == user_id:
                 return index
 
         return None
 
     def get_user_by_user_id(self, user_id):
         for user in self.players:
-            if user.get_userid() == user_id:
+            if user.user_id == user_id:
                 return user
         return None
 
     def next_player(self):
         if self.game_running:
             if self.current_player is not None and self.current_player < (len(self.players) - 1):
+                user = self.players[self.current_player]
                 self.logger.debug("Next Player!")
                 self.current_player += 1
                 self.send_message(self.chat_id, translate("overview", self.lang_id) + "\n\n" + self.get_player_overview(show_points=True) + "\n" +
                                   translate("nextPlayer", self.lang_id).format(self.players[self.current_player].get_first_name()),
-                                  message_id=self.join_message_ids[self.current_player], reply_markup=self.keyboard_running, game_id=self.__game_id)
+                                  message_id=user.join_id, reply_markup=self.keyboard_running, game_id=self.__game_id)
 
                 self.give_player_one()
             else:
@@ -88,7 +88,7 @@ def give_player_one(self):
                 else:
                     self.send_message(self.chat_id, str(translate("yourCardsAre", self.lang_id).format(
                         user.first_name, cards_string, str(user.cardvalue))), reply_markup=self.keyboard_running,
-                                      message_id=self.join_message_ids[self.current_player], game_id=self.__game_id)
+                                      message_id=user.join_id, game_id=self.__game_id)
             else:
                 card = self.deck.pick_one_card()
                 cardvalue = self.deck.get_card_value(card)
@@ -155,26 +155,26 @@ def dealers_turn(self):
             self.send_message(self.chat_id, output_text, parse_mode="Markdown", reply_markup=self.keyboard_running)
             self.evaluation()
 
-    def start_game(self, message_id=None):
+    def start_game(self, message_id: int = None) -> None:
         if not self.game_running:
             if ((self.game_type == self.GROUP_CHAT or self.game_type == self.MULTIPLAYER_GAME) and len(self.players) > 1) or self.game_type == self.PRIVATE_CHAT:
-                    self.game_running = True
+                self.game_running = True
 
-                    for player in self.players:
-                        add_game_played(player.user_id)
+                for player in self.players:
+                    add_game_played(player.user_id)
 
-                    if self.game_type == self.GROUP_CHAT or self.game_type == self.MULTIPLAYER_GAME:
-                        self.send_message(self.chat_id, translate("gameBegins", self.lang_id) + "\n" + translate("gameBegins2", self.lang_id) + "\n\n" + self.get_player_overview(), game_id=self.__game_id)
+                if self.game_type == self.GROUP_CHAT or self.game_type == self.MULTIPLAYER_GAME:
+                    self.send_message(self.chat_id, translate("gameBegins", self.lang_id) + "\n" + translate("gameBegins2", self.lang_id) + "\n\n" + self.get_player_overview(), game_id=self.__game_id)
 
-                    self.dealers_turn()
-                    self.give_player_one()
+                self.dealers_turn()
+                self.give_player_one()
             else:
                 self.send_message(self.chat_id, translate("notEnoughPlayers", self.lang_id), message_id=message_id, game_id=self.__game_id)
         else:
-            #TODO Game already running
+            # TODO Game already running
             pass
 
-    def evaluation(self):
+    def evaluation(self) -> None:
         list_21 = []
         list_busted = []
         list_lower_21 = []
@@ -202,24 +202,24 @@ def evaluation(self):
 
         if self.dealer.get_cardvalue() > 21:
             for user in list_21:
-                set_game_won(user.get_userid())
+                set_game_won(user.user_id)
             for user in list_lower_21:
-                set_game_won(user.get_userid())
+                set_game_won(user.user_id)
                 # Alle mit 21 > Punkte >= 0 haben Einsatz x 1,5 gewonnen.
                 # Alle mit 21 haben Einsatz mal 2 gewonnen
                 # Alle mit 21 und Kartenanzahl = 2 haben Einsatz mal 3 gewonnen
         elif self.dealer.get_cardvalue() == 21:  # todo differentiate between blackjack and 21
             for user in list_21:
                 if user.get_first_name() != translate("dealerName", self.lang_id):
-                    set_game_won(user.get_userid())
+                    set_game_won(user.user_id)
                     # Alle mit 21 > Punkte >= 0 haben verloren . || Alle mit 21 haben Einsatz gewonnen || Alle mit 21 und Kartenanzahl = 2 haben Einsatz mal 2 gewonnen
                     # todo if dealer got Blackjack: || Everyone with BlackJack won their bet back. || Everone else lost
         elif self.dealer.get_cardvalue() < 21:
             for user in list_21:
-                set_game_won(user.get_userid())
+                set_game_won(user.user_id)
             for user in list_lower_21:
                 if user.get_cardvalue() > self.dealer.get_cardvalue():
-                    set_game_won(user.get_userid())
+                    set_game_won(user.user_id)
                     # print(str(user.get_userid()) + " you've got " + )
                     # Alle mit Dealer > Punkte haben verloren.
                     # Alle mit Dealer = Punkte erhalten Einsatz
@@ -243,7 +243,7 @@ def evaluation(self):
         self.send_message(self.chat_id, final_message, game_id=self.__game_id)
         self.game_handler.gl_remove(self.chat_id)
 
-    def get_player_overview(self, show_points=False, text="", i=0, dealer=False):
+    def get_player_overview(self, show_points: bool = False, text: str = "", i=0, dealer: bool = False) -> str:
         if self.game_running:
             for user in self.players:
                 if i == self.current_player:
@@ -297,14 +297,13 @@ def analyze_message(self, update):
                 if user_id == self.players[0].user_id:
                     self.game_handler.gl_remove(self.chat_id)
 
-    def get_game_id(self):
+    def get_game_id(self) -> int:
         return self.__game_id
 
     # When game is being initialized
     def __init__(self, chat_id, user_id, lang_id, first_name, game_handler, message_id, send_message, multiplayer=None, game_id=None):
         # declare variables and set initial values
         self.players = []
-        self.join_message_ids = []
         self.chat_id = chat_id
         self.__game_id = game_id
         self.lang_id = lang_id

game/dealer.py

@@ -6,6 +6,6 @@
 class Dealer(Player):
     credits = 0
 
-    def __init__(self, first_name, deck):
+    def __init__(self, first_name, deck, join_id=None):
         user_id = -1
-        super(Dealer, self).__init__(user_id, first_name, deck)
+        super(Dealer, self).__init__(user_id, first_name, deck, join_id)

game/deck.py

@@ -9,28 +9,27 @@ class CardDeck(object):
     symbols = ["♥", "♦", "♣", "♠"]
     valueInt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10]
 
-    @staticmethod
-    def create_deck():
+    def create_deck(self) -> list:
         from random import shuffle
         deck = list(range(1, 52))
         shuffle(deck)
         return deck[:]
 
-    def pick_one_card(self):
+    def pick_one_card(self) -> int:
         card = self.deck[0]
         self.deck.pop(0)
         return card
 
-    def get_card_name(self, card):
+    def get_card_name(self, card: int) -> str:
         symbol = self.symbols[card // 13]
         value = self.value_str[card % 13]
         card_name = "|" + symbol + " " + value + "|"
         return card_name
 
-    def get_card_value(self, card):
+    def get_card_value(self, card: int) -> int:
         return self.valueInt[card % 13]
 
-    def __init__(self, lang_id):
+    def __init__(self, lang_id: str) -> None:
         self.deck = self.create_deck()
         self.value_str = [translate("ace", lang_id), "2", "3", "4", "5", "6", "7", "8", "9", "10",
                           translate("jack", lang_id), translate("queen", lang_id), translate("king", lang_id)]

game/player.py

@@ -47,15 +47,21 @@ def get_first_name(self):
     def get_cardvalue(self):
         return self.cardvalue
 
-    def get_userid(self):
-        return self.user_id
+    @property
+    def user_id(self):
+        return self.__user_id
+
+    @property
+    def join_id(self):
+        return self.__join_id
 
     def get_lang_id(self):
         return self.lang_id
 
-    def __init__(self, user_id, first_name, deck, lang_id="en"):
-        self.user_id = user_id
+    def __init__(self, user_id, first_name, deck, join_id, lang_id="en"):
+        self.__user_id = user_id
         self.first_name = first_name
+        self.__join_id = join_id
         self.lang_id = lang_id
         self.deck = deck
         self.number_of_cards = 0

lang/language.py

@@ -13,7 +13,7 @@
 
 
 # translate returns the translation for a specific string
-def translate(string, language):
+def translate(string: str, language: str) -> str:
     if language in translations and string in translations[language]:
         return translations[language][string]
     elif language == "br":