articlib 0.2.9__tar.gz

articlib-0.2.9/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.9/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: articlib
+Version: 0.2.9
+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
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: colorama (>=0.4.6,<0.5.0)
+Requires-Dist: pytest (>=9.0.2,<10.0.0)
+Description-Content-Type: text/markdown
+
+New documentation been written slowly
+

articlib-0.2.9/README.md

@@ -0,0 +1 @@
+New documentation been written slowly

articlib-0.2.9/articlib/articFileUtils.py

@@ -0,0 +1,130 @@
+import os
+import shutil
+import logging
+import logUtils as LU
+
+
+logObj = logging.getLogger()
+
+
+def deleteFile(path: str) -> None:
+    logObj.debug(f"Delete the file on path {path}")
+    os.remove(path)
+
+
+def createFile(path: str) -> None:
+    logObj.debug(f"Create file on path {path}")
+    file = open(path, "w")
+    file.close()
+
+
+def copyFile(source: str, destination: str) -> None:
+    logObj.debug(f"Copy file from {source} to {destination}")
+    shutil.copy(source, destination)
+
+
+def fileExists(path: str) -> bool:
+    return os.path.isfile(path)
+
+
+def getFilesInDirectory(path: str) -> list[str]:
+    return os.listdir(path)
+
+
+def deleteDirectory(path: str) -> None:
+    logObj.debug(f"Delete directory on {path}")
+    os.rmdir(path)
+
+
+def deleteDirectoryTree(path: str) -> None:
+    logObj.debug(f"Remove entire directory tree in {path}")
+    shutil.rmtree(path)
+
+
+def createDirectory(path: str) -> None:
+    logObj.debug(f"Create directory on {path}")
+    os.makedirs(path, exist_ok=True)
+
+
+def directoryExists(path: str) -> bool:
+    return os.path.isdir(path)
+
+
+class FileIO:
+    def __init__(self, path: str, readIt: bool = False, log: bool = True) -> None:
+        self.log = log
+        self.path = path
+        if self.log is True:
+            logObj.debug(f"Create FileIO object with path {self.path}")
+        if readIt is True:
+            logObj.info(f"Reading content in path {self.path}")
+            self.readFile()
+        else:
+            logObj.info("Load file as empty without reading")
+            self.lines: list[str] = []
+
+    def readFile(self) -> None:
+        filePointer = open(self.path, "r")
+        if self.log is True:
+            logObj.info(f"Read file in {self.path}")
+            LU.logFile(self.path, debugFlag=True)
+        self.lines = filePointer.readlines()
+        self.lines = [line[:-1] for line in self.lines]
+        filePointer.close()
+
+    def writeFile(self) -> None:
+        filePointer = open(self.path, "w")
+        for line in self.lines:
+            filePointer.write(line + "\n")
+        if self.log is True:
+            logObj.info(f"Write file in {self.path}")
+            LU.logFile(self.path, debugFlag=True)
+
+        filePointer.close()
+
+    def appendToFile(self) -> None:
+        filePointer = open(self.path, "a")
+        for line in self.lines:
+            filePointer.write(line + "\n")
+        if self.log is True:
+            logObj.info(f"Append to file in {self.path}")
+            LU.logFile(self.path, debugFlag=True)
+        filePointer.close()
+
+    def addLine(self, line: str) -> None:
+        if self.log is True:
+            logObj.info(f"Addline: {line}")
+        self.lines.append(line)
+
+    def modifyLine(self, lineNumber: int, line: str) -> None:
+        if self.log is True:
+            logObj.info(f"Modify line {lineNumber} to {line}")
+        self.lines[lineNumber] = line
+
+    def removeLine(self, lineNumber: int) -> None:
+        if self.log is True:
+            logObj.info(f"Remove line {lineNumber}")
+            logObj.debug(f"Removed content is {self.lines[lineNumber]}")
+        del self.lines[lineNumber]
+
+    def removeLastLine(self) -> None:
+        if self.log is True:
+            logObj.info("Remove last line")
+            logObj.debug(f"Removed content is {self.lines[-1]}")
+        del self.lines[-1]
+
+    def findLine(self, text: str) -> list[int]:
+        result: list[int] = []
+        for i in range(len(self.lines)):
+            if text in self.lines[i]:
+                result.append(i)
+        return result
+
+    def findAndReplace(self, find: str, replace: str) -> None:
+        if self.log is True:
+            logObj.info(f"Find {find} and replace it with {replace}")
+        for i in range(len(self.lines)):
+            self.lines[i] = self.lines[i].replace(find, replace)
+
+    def lineCount(self) -> int:
+        return len(self.lines)

articlib-0.2.9/articlib/consoleUtils.py

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

articlib-0.2.9/articlib/dateTime.py

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

articlib-0.2.9/articlib/dice.py

@@ -0,0 +1,61 @@
+import random
+import logging
+
+
+log = logging.getLogger()
+
+
+class dice:
+    def __init__(self, size: int = 6, log: bool = True) -> None:
+        self.log: bool = log
+        self.size: int = size
+
+    def setSize(self, size: int) -> None:
+        self.size = size
+
+    def setLog(self, log: bool) -> None:
+        self.log = log
+
+    def roll(self) -> int:
+        result: int = random.randint(1, self.size)
+        if self.log is True:
+            log.info(f"Dice of size {self.size} rolled result is {result}")
+        return result
+
+
+class customDice:
+    def __init__(self, faces: list[str], name: str, log: bool = True) -> None:
+        self.faces: list[str] = faces
+        self.name: str = name
+        self.log: bool = log
+        self.size: int = len(faces)
+
+    def roll(self) -> str:
+        face: str = random.choice(self.faces)
+        if self.log is True:
+            log.info(f"{self.name} dice roll result is {face}")
+        return face
+
+
+class dicePool:
+    def __init__(self, diceList: list[dice], log: bool = True) -> None:
+        self.log: bool = log
+        self.diceList: list[dice] = diceList
+
+    def roll(self) -> list[int]:
+        result: list[int] = [d.roll() for d in self.diceList]
+        if self.log is True:
+            log.info(f"Dice pool rolled with the following result {result}")
+        return result
+
+    def rollSum(self) -> int:
+        result: int = sum(self.roll())
+        if self.log is True:
+            log.info(f"Dice pool sum is {result}")
+        return result
+
+    def rollSuccesses(self, target: int) -> int:
+        result: int = sum([1 for roll in self.roll() if roll >= target])
+        if self.log is True:
+            log.info(f"Roll dice pool looking for {target}, {result} successes")
+        return result

articlib-0.2.9/articlib/jsonHandler.py

@@ -0,0 +1,132 @@
+import json
+import socket
+import logging
+import mmap
+from typing import Any
+from datetime import datetime
+
+
+log = logging.getLogger()
+
+
+class JsonFile:
+    def __init__(self, path: str,
+                 type: str = "",
+                 size: int = 1024,
+                 read: bool = False,
+                 write: bool = False) -> None:
+        self.clock: datetime = datetime.now()
+        self.content: dict[str, Any] = {}
+        self._setHostname()
+        self.read: bool = read
+        self.write: bool = write
+
+        if read is False and write is False:
+            msg = "No mode selected at class creation"
+            log.error(msg)
+            raise ValueError(msg)
+
+        if read is True and write is True:
+            msg = "Both mode selected at class creation, only one allowed"
+            log.error(msg)
+            raise ValueError(msg)
+
+        if type == "":
+            self._setType(path)
+        else:
+            self._setType(type)
+
+        self.size = size
+        self.path = path
+
+        if write is True:
+            filePtr = open(path, "wb")
+            filePtr.write(b"\x00" * size)
+            filePtr.close()
+            del filePtr
+
+        if read is True:
+            filePtr2 = open(path, "r+b")
+            filePtr2.seek(size-1)
+            filePtr2.write(b"\x00")
+            filePtr2.close()
+            del filePtr2
+
+        self.filePtr = open(path, "r+b")
+        self.fmap = mmap.mmap(self.filePtr.fileno(), size)
+
+    def __del__(self) -> None:
+        if hasattr(self, "fmap"):
+            self.fmap.close()
+        if self.read is True:
+            return
+        if self.write is True:
+            self.bufferedWrite()
+
+    def _setHostname(self) -> None:
+        self.content["Hostname"] = socket.gethostname()
+
+    def _setType(self, type: str) -> None:
+        self.content["type"] = type
+
+    def _setDate(self) -> None:
+        self.content["year"] = int(self.clock.year)
+        self.content["month"] = int(self.clock.month)
+        self.content["day"] = int(self.clock.day)
+
+    def _setTime(self) -> None:
+        self.content["hour"] = int(self.clock.hour)
+        self.content["minute"] = int(self.clock.minute)
+        self.content["second"] = int(self.clock.second)
+
+    def bufferedWrite(self) -> None:
+        FilePtr = open(self.path, "w")
+        json.dump(self.content, FilePtr, indent=4)
+        FilePtr.close()
+
+    def writeData(self, data: dict[str, Any]) -> int:
+        if self.write is False:
+            log.error("File was open without write mode and can't be written")
+            return 3
+
+        self.clock = datetime.now()
+        self._setDate()
+        self._setTime()
+        self.content["data"] = data
+
+        # Convert dict into bytes
+        file_bytes = json.dumps(self.content, indent=4).encode()
+
+        if len(file_bytes) > self.size:
+            log.error("File too small, too much data to dump")
+            return 1
+
+        # Clear memory map
+        self.fmap.seek(0)
+        self.fmap.write(b"\x00" * self.size)
+
+        # Write data
+        self.fmap.seek(0)
+        self.fmap.write(file_bytes)
+
+        return 0
+
+    def readData(self) -> int:
+        if self.read is False:
+            log.error("File was open without read mode and can't be read")
+            return 2
+
+        # Read the entire memory-mapped region (this IS the file)
+        raw = self.fmap[:]
+
+        # Stop at the first null byte (padding begins here)
+        json_bytes = raw.split(b"\x00", 1)[0]
+
+        # If file is empty or only padding
+        if not json_bytes.strip():
+            log.error("File is empty and can't be read")
+            return 3
+
+        # Decode and parse JSON
+        self.content = json.loads(json_bytes.decode())
+        return 0

articlib-0.2.9/articlib/logUtils.py

@@ -0,0 +1,47 @@
+import logging
+import articFileUtils as FU
+
+
+log = logging.getLogger()
+
+
+def logFile(path: str, debugFlag: bool = False) -> None:
+    if debugFlag is True:
+        logFunc = log.debug
+    else:
+        logFunc = log.info
+
+    logFunc("===================================================")
+    logFunc("   Log contents of file")
+    logFunc(f"   Path: {path}")
+    logFunc("===================================================")
+    if FU.fileExists(path):
+        FP = open(path, "r")
+        lines = FP.readlines()
+        for line in lines:
+            logFunc(line[:-1])
+    else:
+        log.error("File doesn't exist")
+    logFunc("===================================================")
+
+
+def logTestStart(title: str) -> None:
+    logSepDoubleLine()
+    log.info(f"  {title}")
+    logSepDoubleLine()
+
+
+def logTestEnd() -> None:
+    logSepDoubleLine()
+    log.info("  Test finished")
+    logSepDoubleLine()
+    log.info("")
+    log.info("")
+
+
+def logSepDoubleLine() -> None:
+    log.info("===================================================")
+
+
+def logSepLine() -> None:
+    log.info("---------------------------------------------------")

articlib-0.2.9/articlib/sqliteEngine.py

@@ -0,0 +1,72 @@
+import sqlite3
+import logging
+from typing import Any
+
+
+log = logging.getLogger()
+
+
+class sqliteEngine:
+    def __init__(self, dbPath: str):
+        self.con = sqlite3.connect(dbPath)
+        self.cursor = self.con.cursor()
+
+    def executeCommand(self, command: str) -> None:
+        log.debug(f"Executing command: {command}")
+        self.cursor.execute(command)
+
+    def createTable(self, name: str, columns: str) -> None:
+        self.executeCommand(f"CREATE TABLE {name} ({columns});")
+
+    def addColumn(self, table: str, column: str) -> None:
+        self.executeCommand(f"ALTER TABLE {table} ADD COLUMN {column};")
+
+    def deleteColumn(self, table: str, column: str) -> None:
+        self.executeCommand(f"ALTER TABLE {table} DROP COLUMN {column}")
+
+    def addEntry(self, table: str, columns: str, values: str) -> None:
+        self.executeCommand(f"INSERT INTO {table} ({columns}) VALUES ({values});")
+
+    def updateEntry(self, table: str, columns: str, values: str, condition: str) -> None:
+        self.executeCommand(
+            f'UPDATE {table} SET {columns} = "{values}" WHERE {condition};'
+        )
+
+    def deleteEntry(self, table: str, condition: str) -> None:
+        self.executeCommand(f"DELETE FROM {table} WHERE {condition};")
+
+    def readEntry(self, table: str, columns: str) -> list[Any]:
+        self.executeCommand(f"SELECT {columns} FROM {table};")
+        result = self.cursor.fetchall()
+        log.debug(f"Read entry: {result}")
+        return result
+
+    def readNumberOfEntries(self, table: str) -> Any:
+        self.executeCommand(f"SELECT COUNT(*) FROM {table};")
+        result = self.cursor.fetchall()
+        log.debug(f"Read number of entries: {result}")
+        return result[0][0]
+
+    def readEntryFiltered(self, table: str, columns: str, filter: str) -> list[Any]:
+        self.executeCommand(f"SELECT {columns} FROM {table} WHERE {filter};")
+        result = self.cursor.fetchall()
+        log.debug(f"Read entry: {result}")
+        return result
+
+    def entryExistsOnTable(self, table: str, condition: str) -> bool:
+        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: str, condition: str) -> None:
+        self.executeCommand(f"DELETE FROM {table} WHERE {condition};")
+
+    def commit(self) -> None:
+        self.con.commit()
+
+    def commitClose(self) -> None:
+        self.commit()
+        self.con.close()

articlib-0.2.9/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.poetry]
+name = "articlib"
+version = "0.2.9"
+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"
+pytest = "^9.0.2"
+
+[tool.poetry.group.dev.dependencies]
+flake8-pyproject = "^1.2.3"
+flake8 = "^7.1.1"
+mypy = "^1.11.2"
+black = "^24.8.0"
+freezegun = "^1.5.5"
+
+
+[tool.poetry.group.deb.dependencies]
+types-colorama = "^0.4.15.20250801"
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"