articlib 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

articlib/dateTime.py

@@ -1,121 +1,155 @@
-from datetime import datetime
-
-YYYYMMDD = 1
-DDMMYYYY = 2
-MMDDYYYY = 3
-
-class createDate:
-    def __init__(self, mode):
-        self.mode = mode
-    
-    def setToNow(self):
-        date = datetime.now()
-        self.year = int(date.year)
-        self.month = int(date.month)
-        self.day = int(date.day)
-        self.hour = int(date.hour)
-        self.minute = int(date.minute)
-        self.second = int(date.second)
-        self.calculateStringDate()
-        self.calculateStringTime()
-    
-    def setTo(self, year, month, day, hour, minute, second):
-        self.year = year
-        self.month = month
-        self.day = day
-        self.hour = hour
-        self.minute = minute
-        self.second = second
-        self.calculateStringDate()
-        self.calculateStringTime()
-        
-    def setToString(self, string):
-        string = string.split(" ")
-        date = string[0]
-        time = string[1]
-        self.dateString = date
-        self.timeString = time
-        self.calculateDate()
-        self.calculateTime()
-    
-    def calculateDate(self):
-        if self.mode == YYYYMMDD:
-            self.year = int(self.dateString[0:4])
-            self.month = int(self.dateString[5:7])
-            self.day = int(self.dateString[8:10])
-        elif self.mode == DDMMYYYY:
-            self.day = int(self.dateString[0:2])
-            self.month = int(self.dateString[3:5])
-            self.year = int(self.dateString[6:10])
-        elif self.mode == MMDDYYYY:
-            self.month = int(self.dateString[0:2])
-            self.day = int(self.dateString[3:5])
-            self.year = int(self.dateString[6:10])
-        else:
-            raise ValueError("Invalid mode")
-        
-    def calculateTime(self):
-        self.hour = int(self.timeString[0:2])
-        self.minute = int(self.timeString[3:5])
-        self.second = int(self.timeString[6:8])
-        
-    def calculateStringDate(self):
-        if self.mode == YYYYMMDD:
-            self.dateString = str(self.year) + "/" + str(self.month).zfill(2) + "/" + str(self.day).zfill(2)
-        elif self.mode == DDMMYYYY:
-            self.dateString = str(self.day).zfill(2) + "/" + str(self.month).zfill(2) + "/" + str(self.year)
-        elif self.mode == MMDDYYYY:
-            self.dateString = str(self.month).zfill(2) + "/" + str(self.day).zfill(2) + "/" + str(self.year)
-        else:
-            raise ValueError("Invalid mode")
-    
-    def calculateStringTime(self):
-        self.timeString = str(self.hour).zfill(2) + ":" + str(self.minute).zfill(2) + ":" + str(self.second).zfill(2)
-        
-    def setMode(self, mode):
-        self.mode = mode
-        self.calculateStringDate()
-        
-    ## Output values
-    def getDateTimePathFomat(self):
-        if self.mode == YYYYMMDD:
-            dateString = str(self.year) + str(self.month).zfill(2) + str(self.day).zfill(2)
-        elif self.mode == DDMMYYYY:
-            dateString = str(self.day).zfill(2) + str(self.month).zfill(2) + str(self.year)
-        elif self.mode == MMDDYYYY:
-            dateString = str(self.month).zfill(2) + str(self.day).zfill(2) + str(self.year)
-        else:
-            raise ValueError("Invalid mode")
-        timeString = str(self.hour).zfill(2) + str(self.minute).zfill(2) + str(self.second).zfill(2)
-        return f"{dateString}_{timeString}"
-    
-    def getDate(self):
-        return self.dateString
-    
-    def getTime(self):
-        return self.timeString
-    
-    def getDateTime(self):
-        return self.dateString + " " + self.timeString
-    
-    def getYear(self):
-        return self.year
-    
-    def getMonth(self):
-        return self.month
-    
-    def getDay(self):
-        return self.day
-    
-    def getHour(self):
-        return self.hour
-    
-    def getMinute(self):
-        return self.minute
-    
-    def getSecond(self):
-        return self.second
-    
-    def getMode(self):
-        return self.mode
-    
+from datetime import datetime
+
+YYYYMMDD = 1
+DDMMYYYY = 2
+MMDDYYYY = 3
+
+
+class createDate:
+    def __init__(self, mode):
+        self.mode = mode
+
+    def setToNow(self):
+        date = datetime.now()
+        self.year = int(date.year)
+        self.month = int(date.month)
+        self.day = int(date.day)
+        self.hour = int(date.hour)
+        self.minute = int(date.minute)
+        self.second = int(date.second)
+        self.calculateStringDate()
+        self.calculateStringTime()
+
+    def setTo(self, year, month, day, hour, minute, second):
+        self.year = year
+        self.month = month
+        self.day = day
+        self.hour = hour
+        self.minute = minute
+        self.second = second
+        self.calculateStringDate()
+        self.calculateStringTime()
+
+    def setToString(self, string):
+        string = string.split(" ")
+        date = string[0]
+        time = string[1]
+        self.dateString = date
+        self.timeString = time
+        self.calculateDate()
+        self.calculateTime()
+
+    def calculateDate(self):
+        if self.mode == YYYYMMDD:
+            self.year = int(self.dateString[0:4])
+            self.month = int(self.dateString[5:7])
+            self.day = int(self.dateString[8:10])
+        elif self.mode == DDMMYYYY:
+            self.day = int(self.dateString[0:2])
+            self.month = int(self.dateString[3:5])
+            self.year = int(self.dateString[6:10])
+        elif self.mode == MMDDYYYY:
+            self.month = int(self.dateString[0:2])
+            self.day = int(self.dateString[3:5])
+            self.year = int(self.dateString[6:10])
+        else:
+            raise ValueError("Invalid mode")
+
+    def calculateTime(self):
+        self.hour = int(self.timeString[0:2])
+        self.minute = int(self.timeString[3:5])
+        self.second = int(self.timeString[6:8])
+
+    def calculateStringDate(self):
+        if self.mode == YYYYMMDD:
+            self.dateString = (
+                str(self.year)
+                + "/"
+                + str(self.month).zfill(2)
+                + "/"
+                + str(self.day).zfill(2)
+            )
+        elif self.mode == DDMMYYYY:
+            self.dateString = (
+                str(self.day).zfill(2)
+                + "/"
+                + str(self.month).zfill(2)
+                + "/"
+                + str(self.year)
+            )
+        elif self.mode == MMDDYYYY:
+            self.dateString = (
+                str(self.month).zfill(2)
+                + "/"
+                + str(self.day).zfill(2)
+                + "/"
+                + str(self.year)
+            )
+        else:
+            raise ValueError("Invalid mode")
+
+    def calculateStringTime(self):
+        self.timeString = (
+            str(self.hour).zfill(2)
+            + ":"
+            + str(self.minute).zfill(2)
+            + ":"
+            + str(self.second).zfill(2)
+        )
+
+    def setMode(self, mode):
+        self.mode = mode
+        self.calculateStringDate()
+
+    ## Output values
+    def getDateTimePathFomat(self):
+        if self.mode == YYYYMMDD:
+            dateString = (
+                str(self.year) + str(self.month).zfill(2) + str(self.day).zfill(2)
+            )
+        elif self.mode == DDMMYYYY:
+            dateString = (
+                str(self.day).zfill(2) + str(self.month).zfill(2) + str(self.year)
+            )
+        elif self.mode == MMDDYYYY:
+            dateString = (
+                str(self.month).zfill(2) + str(self.day).zfill(2) + str(self.year)
+            )
+        else:
+            raise ValueError("Invalid mode")
+        timeString = (
+            str(self.hour).zfill(2)
+            + str(self.minute).zfill(2)
+            + str(self.second).zfill(2)
+        )
+        return f"{dateString}_{timeString}"
+
+    def getDate(self):
+        return self.dateString
+
+    def getTime(self):
+        return self.timeString
+
+    def getDateTime(self):
+        return self.dateString + " " + self.timeString
+
+    def getYear(self):
+        return self.year
+
+    def getMonth(self):
+        return self.month
+
+    def getDay(self):
+        return self.day
+
+    def getHour(self):
+        return self.hour
+
+    def getMinute(self):
+        return self.minute
+
+    def getSecond(self):
+        return self.second
+
+    def getMode(self):
+        return self.mode

articlib/dice.py

@@ -1,32 +1,35 @@
-import random
-
-class dice:
-    def __init__(self, size=6):
-        self.size = size
-        
-    def setSize(self, size):
-        self.size = size
-        
-    def roll(self):
-        return random.randint(1, self.size)
-    
-class customDice(dice):
-    def __init__(self, faces):
-        self.faces = faces
-        self.size = len(faces)
-        
-    def roll(self):
-        return random.choice(self.faces)
-    
-class dicePool:
-    def __init__(self, diceList):
-        self.diceList = diceList
-        
-    def roll(self):
-        return [d.roll() for d in self.diceList]
-    
-    def rollSum(self):
-        return sum(self.roll())
-    
-    def rollSuccesses(self, target):
-        return sum([1 for roll in self.roll() if roll >= target])
+import random
+
+
+class dice:
+    def __init__(self, size: int = 6) -> None:
+        self.size = size
+
+    def setSize(self, size: int) -> None:
+        self.size = size
+
+    def roll(self) -> int:
+        return random.randint(1, self.size)
+
+
+class customDice(dice):
+    def __init__(self, faces: list[str]) -> None:
+        self.faces = faces
+        self.size = len(faces)
+
+    def roll(self) -> str:
+        return random.choice(self.faces)
+
+
+class dicePool:
+    def __init__(self, diceList) -> None:
+        self.diceList = diceList
+
+    def roll(self) -> list[int]:
+        return [d.roll() for d in self.diceList]
+
+    def rollSum(self) -> int:
+        return sum(self.roll())
+
+    def rollSuccesses(self, target: int) -> int:
+        return sum([1 for roll in self.roll() if roll >= target])

articlib/sqliteEngine.py

@@ -1,66 +1,69 @@
-import sqlite3
-import articlib.articLogger as Logger
-from articlib.articLogger import log
-
-class sqliteEngine:
-    def __init__(self, dbPath):
-        self.con = sqlite3.connect (dbPath)
-        self.cursor = self.con.cursor()
-    
-    def executeCommand (self, command):
-        log.addEntry(f"Executing command: {command}", Logger.DEBUG_MASK)
-        self.cursor.execute (command)
-        
-    def createTable (self, name, columns):
-        self.executeCommand (f"CREATE TABLE {name} ({columns});")
-    
-    def addColumn (self, table, column):
-        self.executeCommand (f"ALTER TABLE {table} ADD COLUMN {column};")
-        
-    def deleteColumn (self, table, column):
-        self.executeCommand (f"ALTER TABLE {table} DROP COLUMN {column}")
-    
-    def addEntry (self, table, columns, values):
-        self.executeCommand (f"INSERT INTO {table} ({columns}) VALUES ({values});")
-    
-    def updateEntry (self, table, columns, values, condition):
-        self.executeCommand (f"UPDATE {table} SET {columns} = \"{values}\" WHERE {condition};")
-    
-    def deleteEntry (self, table, condition):
-        self.executeCommand (f"DELETE FROM {table} WHERE {condition};")
-    
-    def readEntry (self, table, columns):
-        self.executeCommand (f"SELECT {columns} FROM {table};")
-        result = self.cursor.fetchall()
-        log.addEntry(f"Read entry: {result}", Logger.DEBUG_MASK)
-        return result
-    
-    def readNumberOfEntries (self, table):
-        self.executeCommand (f"SELECT COUNT(*) FROM {table};")
-        result = self.cursor.fetchall()
-        log.addEntry(f"Read number of entries: {result}", Logger.DEBUG_MASK)
-        return result[0][0]
-
-    def readEntryFiltered (self, table, columns, filter):
-        self.executeCommand(f"SELECT {columns} FROM {table} WHERE {filter};")
-        result = self.cursor.fetchall()
-        log.addEntry(f"Read entry: {result}", Logger.DEBUG_MASK)
-        return result
-
-    def entryExistsOnTable (self, table, condition):
-        self.executeCommand (f"SELECT * FROM {table} WHERE {condition};")
-        entry = self.cursor.fetchall()
-        if len(entry) != 0:
-            return True
-        else:
-            return False
-    
-    def deleteEntryFromTable (self, table, condition):
-        self.executeCommand (f"DELETE FROM {table} WHERE {condition};")
-
-    def commit(self):
-        self.con.commit()
-
-    def commitClose(self):
-        self.commit()
-        self.con.close()
+import sqlite3
+import articlib.articLogger as Logger
+from articlib.articLogger import log
+
+
+class sqliteEngine:
+    def __init__(self, dbPath):
+        self.con = sqlite3.connect(dbPath)
+        self.cursor = self.con.cursor()
+
+    def executeCommand(self, command):
+        log.addEntry(f"Executing command: {command}", Logger.DEBUG_MASK)
+        self.cursor.execute(command)
+
+    def createTable(self, name, columns):
+        self.executeCommand(f"CREATE TABLE {name} ({columns});")
+
+    def addColumn(self, table, column):
+        self.executeCommand(f"ALTER TABLE {table} ADD COLUMN {column};")
+
+    def deleteColumn(self, table, column):
+        self.executeCommand(f"ALTER TABLE {table} DROP COLUMN {column}")
+
+    def addEntry(self, table, columns, values):
+        self.executeCommand(f"INSERT INTO {table} ({columns}) VALUES ({values});")
+
+    def updateEntry(self, table, columns, values, condition):
+        self.executeCommand(
+            f'UPDATE {table} SET {columns} = "{values}" WHERE {condition};'
+        )
+
+    def deleteEntry(self, table, condition):
+        self.executeCommand(f"DELETE FROM {table} WHERE {condition};")
+
+    def readEntry(self, table, columns):
+        self.executeCommand(f"SELECT {columns} FROM {table};")
+        result = self.cursor.fetchall()
+        log.addEntry(f"Read entry: {result}", Logger.DEBUG_MASK)
+        return result
+
+    def readNumberOfEntries(self, table):
+        self.executeCommand(f"SELECT COUNT(*) FROM {table};")
+        result = self.cursor.fetchall()
+        log.addEntry(f"Read number of entries: {result}", Logger.DEBUG_MASK)
+        return result[0][0]
+
+    def readEntryFiltered(self, table, columns, filter):
+        self.executeCommand(f"SELECT {columns} FROM {table} WHERE {filter};")
+        result = self.cursor.fetchall()
+        log.addEntry(f"Read entry: {result}", Logger.DEBUG_MASK)
+        return result
+
+    def entryExistsOnTable(self, table, condition):
+        self.executeCommand(f"SELECT * FROM {table} WHERE {condition};")
+        entry = self.cursor.fetchall()
+        if len(entry) != 0:
+            return True
+        else:
+            return False
+
+    def deleteEntryFromTable(self, table, condition):
+        self.executeCommand(f"DELETE FROM {table} WHERE {condition};")
+
+    def commit(self):
+        self.con.commit()
+
+    def commitClose(self):
+        self.commit()
+        self.con.close()

articlib/systemUtils.py

@@ -1,34 +1,33 @@
-import subprocess
-import datetime
-
-def executeCommand(command):
-    result = subprocess.run(command)
-    return result.returncode
-
-class command:
-    def __init__(self, command, run=True, capture=True, timeout=-1):
-        self.command = command
-        self.capture = capture
-        self.timeout = timeout
-        if run:
-            self.run
-    
-    def run(self):
-        if self.timeout > 0:
-            self.process = subprocess.run(command, capture_output=self.capture, timeout=self.timeout)
-        else:
-            self.runWithoutTimeout
-            
-
-    def runWithoutTimeout(self):
-        self.process = subprocess.run(command, capture_output=self.capture)
-    
-    def stdout(self):
-        return self.process.stdout
-    
-    def stderr(self):
-        return self.process.stderr
-
-
-
-    
+import subprocess
+import datetime
+
+
+def executeCommand(command):
+    result = subprocess.run(command)
+    return result.returncode
+
+
+class command:
+    def __init__(self, command, run=True, capture=True, timeout=-1):
+        self.command = command
+        self.capture = capture
+        self.timeout = timeout
+        if run:
+            self.run
+
+    def run(self):
+        if self.timeout > 0:
+            self.process = subprocess.run(
+                command, capture_output=self.capture, timeout=self.timeout
+            )
+        else:
+            self.runWithoutTimeout
+
+    def runWithoutTimeout(self):
+        self.process = subprocess.run(command, capture_output=self.capture)
+
+    def stdout(self):
+        return self.process.stdout
+
+    def stderr(self):
+        return self.process.stderr