articlib 0.2.1__tar.gz

articlib-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2023 Iñaki Arrondo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

articlib-0.2.1/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: articlib
+Version: 0.2.1
+Summary: Small set of tools and utilities in python. Destined to be use in my personal projects.
+License: MIT
+Author: Artic42
+Author-email: engineer@artic42.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: colorama (>=0.4.6,<0.5.0)
+Description-Content-Type: text/markdown
+
+# pythonLib
+
+This is my personal general case python modules and apps to be used in other projects
+
+## testEngine
+
+Test engine is a simple module with the propose of running automated test, this allows to create test for the rest of the library easily. Test are separated in scenario, once a test in a scenario fail the rest of the scenario is skipped. It also outputs using colored test with errors in red and pass test in green. It has the following methods:
+* testIfEqual
+* testIfFalse
+* testIfEqual
+* testIfNotEqual
+* ...
+
+## dateTime
+
+Library to manage dates for other proposes.
+
+Public methods for setting dates
+* __setToNow__
+* __setTo__ (year, month, day, hour, minute, second)
+* __setToString__ (string)
+* __setMode__ (mode)
+    * _mode1_: YYYYMMDD
+    * _mode2_: DDMMYYYY
+    * _mode3_: MMDDYYYY
+
+Public methods to get values from the object
+* __getDate__
+* __getTime__
+* __getDateTime__
+* __getYear__
+* __getMonth__
+* __getDay__
+* __getHour__
+* __getMinute__
+* __getSecond__
+* __getMode__
+* __getDateTimePathFomat__ (It prints the date and time in a format usable in paths, for files)
+
+## Log
+
+A simple log system, it creates a log iwth 7 mask levels and a maximun size of file. If you log more lines than max it creates a new log file. Available masks
+
+* INFO_MASK
+* WARN_MASK
+* ERROR_MASK
+* COMMS_SEND_MASK
+* COMMS_RECV_MASK
+* HERMES_MASK000
+* COMMS_MASK
+* DEBUG_MASK
+

articlib-0.2.1/README.md

@@ -0,0 +1,51 @@
+# pythonLib
+
+This is my personal general case python modules and apps to be used in other projects
+
+## testEngine
+
+Test engine is a simple module with the propose of running automated test, this allows to create test for the rest of the library easily. Test are separated in scenario, once a test in a scenario fail the rest of the scenario is skipped. It also outputs using colored test with errors in red and pass test in green. It has the following methods:
+* testIfEqual
+* testIfFalse
+* testIfEqual
+* testIfNotEqual
+* ...
+
+## dateTime
+
+Library to manage dates for other proposes.
+
+Public methods for setting dates
+* __setToNow__
+* __setTo__ (year, month, day, hour, minute, second)
+* __setToString__ (string)
+* __setMode__ (mode)
+    * _mode1_: YYYYMMDD
+    * _mode2_: DDMMYYYY
+    * _mode3_: MMDDYYYY
+
+Public methods to get values from the object
+* __getDate__
+* __getTime__
+* __getDateTime__
+* __getYear__
+* __getMonth__
+* __getDay__
+* __getHour__
+* __getMinute__
+* __getSecond__
+* __getMode__
+* __getDateTimePathFomat__ (It prints the date and time in a format usable in paths, for files)
+
+## Log
+
+A simple log system, it creates a log iwth 7 mask levels and a maximun size of file. If you log more lines than max it creates a new log file. Available masks
+
+* INFO_MASK
+* WARN_MASK
+* ERROR_MASK
+* COMMS_SEND_MASK
+* COMMS_RECV_MASK
+* HERMES_MASK000
+* COMMS_MASK
+* DEBUG_MASK

articlib-0.2.1/articlib/articFileUtils.py

@@ -0,0 +1,54 @@
+import os
+
+def deleteFile(path):
+    os.remove(path)
+    
+def createFile(path):
+    file = open (path, "r")
+    file.close()
+
+def fileExists(path):
+    return os.path.isfile(path)
+
+def getFilesInDirectory(path):
+    return os.listdir(path)
+    
+def deleteDirectory(path):
+    os.rmdir(path)
+    
+def createDirectory(path):
+    os.makedirs(path, exist_ok=True)
+
+class FileIO:
+    def __init__(self, path, readIt = False):
+        self.path = path
+        if readIt:
+            self.readFile()
+        else:
+            lines = []
+    
+    def readFile(self):
+        filePointer = open (self.path, "r")
+        self.lines = filePointer.readlines()
+        filePointer.close()
+    
+    def writeFile(self):
+        filePointer = open (self.path, "w")
+        for line in self.lines:
+            filePointer.write(line + "\n")
+        filePointer.close()
+    
+    def appendToFile(self):
+        filePointer = open (self.path, "a")
+        for line in self.lines:
+            filePointer.write(line + "\n")
+        filePointer.close()
+    
+    def addLine(self, line):
+        self.lines.append(line)
+
+    def modifyLine(self, lineNumber, line):
+        self.lines[lineNumber] = line
+        
+    def lineCount(self):
+        return len(self.lines)

articlib-0.2.1/articlib/articLogger.py

@@ -0,0 +1,102 @@
+import dateTime
+import os
+
+if __name__ == "__main__":
+    pass
+
+INFO_MASK = 0b00000001
+WARN_MASK = 0b00000010
+ERROR_MASK = 0b00000100
+COMMS_SEND_MASK = 0b00001000
+COMMS_RECV_MASK = 0b00010000
+HERMES_MASK = 0b00100000
+COMMS_MASK= 0b00011000
+DEBUG_MASK = 0b01000000
+DEFAULT_MASK = INFO_MASK | COMMS_MASK | ERROR_MASK | HERMES_MASK
+
+class Logger:
+    def __init__(self):
+        self.init = False
+        self.logName = ""
+        self.maxLines = 0
+        self.lines = 0
+        self.logPath = ""
+        self.mask = 0b0
+    
+    def initialize(self, logName, maxLines = 1000, logPath = "logs", mask = DEFAULT_MASK):
+        self.init = True
+        self.logName = logName
+        self.maxLines = maxLines
+        self.lines = 0
+        self.logPath = logPath
+        self.mask = mask
+        self.date = dateTime.createDate(dateTime.YYYYMMDD)
+        self.createLogFile()
+    
+    def createLogFile(self):
+        self.date.setToNow()
+        dateSring = self.date.getDateTimePathFomat()
+        os.makedirs(self.logPath, exist_ok=True)
+        self.logFilePath = self.logPath + "/" + self.logName + "_" + dateSring + ".log"
+        if os.path.isfile(self.logFilePath):
+            self.logFile = open(self.logFilePath, "a")
+        else:
+            self.logFile = open(self.logFilePath, "w")
+            self.logFile.write(f"Log file created at {self.date.getDateTime()} with name {self.logName}\n")
+            self.lines = 0
+    
+    def addEntry(self, message, mask = INFO_MASK):
+        maskName = self.getMaskName(mask)
+        if mask & self.mask:
+            if self.init:
+                self.writeLog(message, maskName)
+    
+    def getMaskName(self, mask):
+        switcher = {
+            INFO_MASK: "INFO",
+            WARN_MASK: "WARN",
+            ERROR_MASK: "ERROR",
+            COMMS_SEND_MASK: "COMMS_SEND",
+            COMMS_RECV_MASK: "COMMS_RECV",
+            HERMES_MASK: "HERMES",
+            DEBUG_MASK: "DEBUG",
+            DEFAULT_MASK: "DEFAULT"
+        }
+        return switcher.get(mask, "UNKNOWN")
+    
+    def writeLog(self, message, maskName):
+        self.date.setToNow()
+        dateSring = self.date.getDateTime()
+        self.lines += 1
+        self.logFile.write(f"{dateSring} - {maskName} - {message}\n")
+        if self.lines >= self.maxLines:
+            self.logFile.close()
+            self.createLogFile()
+    
+    def setMask(self, mask):
+        self.mask = mask
+    
+    def getMask(self):
+        return self.mask
+    
+    def setValueInMask(self, mask):
+        self.mask = self.mask | mask
+    
+    def unsetValueInMask(self, mask):
+        self.mask = self.mask & ~mask
+    
+    def flush(self):
+        self.logFile.flush()
+        
+    def restartFile(self):
+        self.logFile.close()
+        self.lines = 0
+        self.createLogFile()
+        
+    def getLogFilePath(self):
+        return self.logFilePath        
+    
+    def close(self):
+        self.logFile.close()
+        
+log = Logger()

articlib-0.2.1/articlib/consoleUtils.py

@@ -0,0 +1,36 @@
+import colorama
+from colorama import Fore, Back, Style
+
+def printRed(text):
+    print(Fore.RED + text + Style.RESET_ALL)
+
+def printGreen(text):
+    print(Fore.GREEN + text + Style.RESET_ALL)
+
+def printYellow(text):
+    print(Fore.YELLOW + text + Style.RESET_ALL)
+
+def printBlue(text):
+    print(Fore.BLUE + text + Style.RESET_ALL)
+
+def printMagenta(text):
+    print(Fore.MAGENTA + text + Style.RESET_ALL)
+    
+def printBold(text):
+    print(Style.BRIGHT + text + Style.RESET_ALL)
+    
+def printRedBold(text):
+    print(Style.BRIGHT + Fore.RED + text + Style.RESET_ALL)
+    
+def printGreenBold(text):
+    print(Style.BRIGHT + Fore.GREEN + text + Style.RESET_ALL)
+
+def printYellowBold(text):
+    print(Style.BRIGHT + Fore.YELLOW + text + Style.RESET_ALL)
+    
+def printBlueBold(text):
+    print(Style.BRIGHT + Fore.BLUE + text + Style.RESET_ALL)
+    
+def printMagentaBold(text):
+    print(Style.BRIGHT + Fore.MAGENTA + text + Style.RESET_ALL)
+    

articlib-0.2.1/articlib/dateTime.py

@@ -0,0 +1,121 @@
+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-0.2.1/articlib/dice.py

@@ -0,0 +1,32 @@
+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])

articlib-0.2.1/articlib/sqliteEngine.py

@@ -0,0 +1,66 @@
+import sqlite3
+import articLogger as Logger
+from 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-0.2.1/articlib/systemUtils.py

@@ -0,0 +1,34 @@
+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
+
+
+
+    

articlib-0.2.1/articlib/testEngine.py

@@ -0,0 +1,111 @@
+import articLogger as logger
+from consoleUtils import printRed, printGreen, printYellow, printMagenta, printGreenBold, printRedBold
+
+class testEngine:
+    def __init__(self):
+        self.passed = True
+        self.failed = False
+        self.escenarioPassed = True
+        self.escenarioFailed = False
+        self.testCount = 0
+        self.scenarioCount = 0
+        self.passCount = 0
+        self.failCount = 0
+        self.skipCount = 0
+        
+    def testIfTrue(self, test, message):
+        if self.escenarioPassed:
+            self.testCount += 1
+            if test:
+                self.passCount += 1
+                printGreen(f"\tTest {self.testCount} passed: {message}")
+                return 1
+            else:
+                self.failCount += 1
+                printRed(f"\tTest {self.testCount} failed: {message}")
+                self.scenarioPassed = False
+                self.scenarioFailed= True
+                return 2
+        else:
+            self.skipCount += 1
+            printYellow(f"\tTest {self.testCount} skipped: {message}")
+            return 3
+    
+    def testIfFalse(self, test, message):
+        self.testIfTrue(not test, message)
+    
+    def testIfEqual(self, expected, testValue, message):
+        response = self.testIfTrue(expected == testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value equal to {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+    
+    def testIfNotEqual(self, expected, testValue, message):
+        response = self.testIftrue(expected != testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value differen to {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+    
+    def testIfGreater(self, expected, testValue, message):
+        response = self.testIftrue(expected > testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value greater than {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+    
+    def testIfGreaterEqual(self, expected, testValue, message):
+        response = self.testIftrue(expected >= testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value greater or equal than {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+    
+    def testIfLess(self, expected, testValue, message):
+        response = self.testIftrue(expected < testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value less than {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+    
+    def testIfLessEqual(self, expected, testValue, message):
+        response = self.testIftrue(expected <= testValue, message)
+        if response == 2:
+            printMagenta(f"\t\tExpected value less or equal than {expected}")
+            printMagenta(f"\t\tValue equal to {testValue}")
+        
+    def newScenario(self, name):
+        self.scenarioCount += 1
+        print(f"Starting scenario {self.scenarioCount}: {name}")
+        
+    def endScenario(self, name):
+        if self.escenarioPassed:
+            print(f"Scenario {self.scenarioCount}:{name} ended with result: PASSED")
+        else:
+            print(f"Scenario {self.scenarioCount}:{name} ended with result: FAILED")
+        if self.escenarioFailed:
+            self.passed = False
+            self.failed = True
+        self.escenarioPassed = True
+        self.escenarioFailed = False
+        
+        
+    # Output test results in different ways
+    def printResults(self):
+        if self.passed:
+            printGreenBold("TEST PASSED")
+        else:
+            printRedBold("TEST FAILED")
+        print(f"\t {self.scenarioCount} scenarios")
+        print(f"\t {self.testCount} tests")
+        print(f"\t {self.passCount} passed")
+        print(f"\t {self.failCount} failed")
+        print(f"\t {self.skipCount} skipped")
+        
+    def lofResults(self, log):
+        if self.passed:
+            logger.addEntry("TEST PASSED", log.INFO_MASK)
+        else:
+            logger.addEntry("TEST FAILED", log.ERROR_MASK)
+        logger.addEntry(f"\t {self.passCount} passed\n")
+        logger.addEntry(f"\t {self.failCount} failed\n")
+        logger.addEntry(f"\t {self.skipCount} skipped\n")
+        logger.addEntry(f"\t {self.testCount} total\n")
+    
+test = testEngine()

articlib-0.2.1/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "articlib"
+version = "0.2.1"
+description = "Small set of tools and utilities in python. Destined to be use in my personal projects."
+authors = ["Artic42 <engineer@artic42.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+colorama = "^0.4.6"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"