logfore 2.1.3.1__py3-none-any.whl

logfore/__init__.py

@@ -0,0 +1,7 @@
+# logfore/__init__.py
+
+from .logger import Logger, Loader, Home, LogLevel
+from .updater import AutoUpdater
+from .version import __version__
+
+__all__ = ["Logger", "Loader", "Home", "LogLevel", "AutoUpdater", "__version__"]

logfore/font.py

@@ -0,0 +1,605 @@
+ascii_art = {
+    'A': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$$$$$$$ ',
+        r'| $$__  $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|__/  |__/'
+    ],
+    'B': [
+        r' /$$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$$$$$$/ ',
+        r'|_______/  '
+    ],
+    'C': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'| $$       ',
+        r'| $$       ',
+        r'| $$    $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'D': [
+        r' /$$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$$$$$$/ ',
+        r'|_______/  '
+    ],
+    'E': [
+        r' /$$$$$$$$ ',
+        r'| $$_____/ ',
+        r'| $$       ',
+        r'| $$$$$    ',
+        r'| $$__/    ',
+        r'| $$       ',
+        r'| $$$$$$$$ ',
+        r'|________/ '
+    ],
+    'F': [
+        r' /$$$$$$$$ ',
+        r'| $$_____/ ',
+        r'| $$       ',
+        r'| $$$$$    ',
+        r'| $$__/    ',
+        r'| $$       ',
+        r'| $$       ',
+        r'|__/       '
+    ],
+    'G': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'| $$ /$$$$ ',
+        r'| $$|_  $$ ',
+        r'| $$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'H': [
+        r' /$$   /$$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$$$$$$$ ',
+        r'| $$__  $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|__/  |__/ '
+    ],
+    'I': [
+        r' /$$$$$$ ',
+        r'|_  $$_/ ',
+        r'  | $$   ',
+        r'  | $$   ',
+        r'  | $$   ',
+        r'  | $$   ',
+        r' /$$$$$$ ',
+        r'|______/ '
+    ],
+    'J': [
+        r'    /$$$$$ ',
+        r'   |__  $$ ',
+        r'      | $$ ',
+        r'      | $$ ',
+        r' /$$  | $$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'K': [
+        r' /$$   /$$ ',
+        r'| $$  /$$/ ',
+        r'| $$ /$$/  ',
+        r'| $$$$$/   ',
+        r'| $$  $$   ',
+        r'| $$\  $$  ',
+        r'| $$ \  $$ ',
+        r'|__/  \__/ '
+    ],
+    'L': [
+        r' /$$       ',
+        r'| $$       ',
+        r'| $$       ',
+        r'| $$       ',
+        r'| $$       ',
+        r'| $$       ',
+        r'| $$$$$$$$ ',
+        r'|________/ '
+    ],
+    'M': [
+        r' /$$      /$$ ',
+        r'| $$$    /$$$ ',
+        r'| $$$$  /$$$$ ',
+        r'| $$ $$/$$ $$ ',
+        r'| $$  $$$| $$ ',
+        r'| $$\  $ | $$ ',
+        r'| $$ \/  | $$ ',
+        r'|__/     |__/ '
+    ],
+    'N': [
+        r' /$$   /$$ ',
+        r'| $$$ | $$ ',
+        r'| $$$$| $$ ',
+        r'| $$ $$ $$ ',
+        r'| $$  $$$$ ',
+        r'| $$\  $$$ ',
+        r'| $$ \  $$ ',
+        r'|__/  \__/ '
+    ],
+    'O': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'P': [
+        r' /$$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$$$$$$/ ',
+        r'| $$____/  ',
+        r'| $$       ',
+        r'| $$       ',
+        r'|__/       '
+    ],
+    'Q': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'| $$/$$ $$ ',
+        r'|  $$$$$$/ ',
+        r' \____ $$$ ',
+        r'      \__/ ',
+    ],
+    'R': [
+        r' /$$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$$$$$$/ ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'|__/  |__/ '
+    ],
+    'S': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'|  $$$$$$  ',
+        r' \____  $$ ',
+        r' /$$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'T': [
+        r' /$$$$$$$$ ',
+        r'|__  $$__/ ',
+        r'   | $$    ',
+        r'   | $$    ',
+        r'   | $$    ',
+        r'   | $$    ',
+        r'   | $$    ',
+        r'   |__/    '
+    ],
+    'U': [
+        r' /$$   /$$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'V': [
+        r' /$$    /$$ ',
+        r'| $$   | $$ ',
+        r'| $$   | $$ ',
+        r'|  $$ / $$/ ',
+        r' \  $$ $$/  ',
+        r'  \  $$$/   ',
+        r'   \  $/    ',
+        r'    \_/     '
+    ],
+    'W': [
+        r' /$$      /$$ ',
+        r'| $$  /$ | $$ ',
+        r'| $$ /$$$| $$ ',
+        r'| $$/$$ $$ $$ ',
+        r'| $$$$_  $$$$ ',
+        r'| $$$/ \  $$$ ',
+        r'| $$/   \  $$ ',
+        r'|__/     \__/ ',
+    ],
+    'X': [
+        r' /$$   /$$ ',
+        r'| $$  / $$ ',
+        r'|  $$/ $$/ ',
+        r' \  $$$$/  ',
+        r'  >$$  $$  ',
+        r' /$$/\  $$ ',
+        r'| $$  \ $$ ',
+        r'|__/  \__/ ',
+    ],
+    'Y': [
+        r' /$$     /$$ ',
+        r'|  $$   /$$/ ',
+        r' \  $$ /$$/  ',
+        r'  \  $$$$/   ',
+        r'   \  $$/    ',
+        r'    | $$     ',
+        r'    | $$     ',
+        r'    |__/     ',
+    ],
+    'Z': [
+        r' /$$$$$$$$ ',
+        r'|_____ $$  ',
+        r'     /$$/  ',
+        r'    /$$/   ',
+        r'   /$$/    ',
+        r'  /$$/     ',
+        r' /$$$$$$$$ ',
+        r'|________/ ',
+    ],
+    'a': [
+        r'  /$$$$$$  ',
+        r' |____  $$ ',
+        r'  /$$$$$$$ ',
+        r' /$$__  $$ ',
+        r'|  $$$$$$$ ',
+        r' \_______/ ',
+    ],
+    'b': [
+        r' /$$       ',
+        r'| $$       ',
+        r'| $$$$$$$  ',
+        r'| $$    $$ ',
+        r'| $$$$$$$/ ',
+        r'|_______/  '
+    ],
+    'c': [
+        r'  /$$$$$$$ ',
+        r' /$$_____/ ',
+        r'| $$       ',
+        r'| $$       ',
+        r'|  $$$$$$$ ',
+        r' \_______/ '
+    ],
+    'd': [
+        r'       /$$ ',
+        r'      | $$ ',
+        r'  /$$$$$$$ ',
+        r' /$$    $$ ',
+        r'|  $$$$$$$ ',
+        r' \_______/ '
+    ],
+    'e': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$$$$$$$ ',
+        r'| $$_____/ ',
+        r'|  $$$$$$$ ',
+        r' \_______/ '
+    ],
+    'f': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'| $$$$     ',
+        r'| $$|      ',
+        r'|___|      '
+    ],
+    'g': [
+        r'  /$$$$$$  ',
+        r' /$$    $$ ',
+        r'|  $$$$$$$ ',
+        r' \____  $$ ',
+        r' /$$  \ $$ ',
+        r'|  $$$$$$/ ',
+    ],
+    'h': [
+        r' /$$       ',
+        r'| $$       ',
+        r'| $$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'|__/  |__/ '
+    ],
+    'i': [
+        r' /$$ ',
+        r'|__/ ',
+        r' /$$ ',
+        r'| $$ ',
+        r'| $$ ',
+        r'|__/ '
+    ],
+    'j': [
+ 
+        r'       /$$ ',
+        r'      |__/ ',
+        r'       /$$ ',
+        r' /$$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'k': [
+        r' /$$   /$$ ',
+        r'| $$  /$$/ ',
+        r'| $$$$$$/  ',
+        r'| $$_  $$  ',
+        r'| $$ \  $$ ',
+        r'|__/  \__/ '
+    ],
+    'l': [
+        r' /$$ ',
+        r'| $$ ',
+        r'| $$ ',
+        r'| $$ ',
+        r'| $$ ',
+        r'|__/ '
+    ],
+    'm': [
+        r' /$$$$$$/$$$$  ',
+        r'| $$_  $$_  $$ ',
+        r'| $$ \ $$ \ $$ ',
+        r'| $$ | $$ | $$ ',
+        r'| $$ | $$ | $$ ',
+        r'|__/ |__/ |__/ '
+    ],
+    'n': [
+        r' /$$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|__/  |__/ '
+    ],
+    'o': [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  '
+    ],
+    'p': [
+        r'  /$$$$$$  ',
+        r' /$$    $$ ',
+        r'| $$$$$$$/ ',
+        r'| $$____/  ',
+        r'| $$       ',
+        r'|__/       '
+    ],
+    'q': [
+
+        r'  /$$$$$$  ',
+        r' /$$    $$ ',
+        r'|  $$$$$$$ ',
+        r' \____  $$ ',
+        r'      | $$ ',
+        r'      |__/ '
+    ],
+    'r': [
+
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'| $$       ',
+        r'| $$       ',
+        r'|__/       ',
+    ],
+    's': [
+        r'  /$$$$$$$ ',
+        r' /$$_____/ ',
+        r'|  $$$$$$  ',
+        r' \____  $$ ',
+        r' /$$$$$$$/ ',
+        r'|_______/  ',
+    ],
+    't': [
+
+
+        r'  | $$   ',
+        r' /$$$$$$ ',
+        r'|_  $$_/ ',
+        r'  | $$   ',
+        r'  |  $$$ ',
+        r'   \___/ ',
+    ],
+
+    'u': [
+        r' /$$   /$$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+    ],
+    'v': [
+
+        r' /$$    /$$ ',
+        r'|  $$  /$$/ ',
+        r' \  $$/$$/  ',
+        r'  \  $$$/   ',
+        r'   \  $/    ',
+        r'    \_/     '
+    ],
+    'w': [
+        r' /$$  /$$  /$$ ',
+        r'| $$ | $$ | $$ ',
+        r'| $$ | $$ | $$ ',
+        r'| $$ | $$ | $$ ',
+        r'|  $$$$$/$$$$/ ',
+        r' \_____\___/   ',
+    ],
+    
+    'x': [
+
+        r' /$$   /$$ ',
+        r'|  $$ /$$/ ',
+        r' \  $$$$/  ',
+        r'  >$$  $$  ',
+        r' /$$/\  $$ ',
+        r'|__/  \__/ ',
+    ],
+    'y': [
+        r' /$$   /$$ ',
+        r'| $$  | $$ ',
+        r'|  $$$$$$$ ',
+        r' \____  $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+   
+    ],
+    'z': [
+        r' /$$$$$$$$ ',
+        r'|____ /$$/ ',
+        r'   /$$$$/  ',
+        r'  /$$__/   ',
+        r' /$$$$$$$$ ',
+        r'|________/ '
+    ],
+    "0": [
+        r'  /$$$$$$  ',
+        r' /$$$_  $$ ',
+        r'| $$$$\ $$ ',
+        r'| $$ $$ $$ ',
+        r'| $$\ $$$$ ',
+        r'| $$ \ $$$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+
+    ],
+
+    "1": [
+        r'   /$$   ',
+        r' /$$$$   ',
+        r'|_  $$   ',
+        r'  | $$   ',
+        r'  | $$   ',
+        r'  | $$   ',
+        r' /$$$$$$ ',
+        r'|______/ ',
+
+    ],
+
+    "2": [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'|__/  \ $$ ',
+        r'  /$$$$$$/ ',
+        r' /$$____/  ',
+        r'| $$       ',
+        r'| $$$$$$$$ ',
+        r'|________/ ',
+
+    ],
+    "3": [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'|__/  \ $$ ',
+        r'   /$$$$$/ ',
+        r'  |___  $$ ',
+        r' /$$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+
+    ],
+    "4": [
+        r' /$$   /$$ ',
+        r'| $$  | $$ ',
+        r'| $$  | $$ ',
+        r'| $$$$$$$$ ',
+        r'|_____  $$ ',
+        r'      | $$ ',
+        r'      | $$ ',
+        r'      |__/ ',
+
+    ],
+    "5": [
+        r' /$$$$$$$  ',
+        r'| $$____/  ',
+        r'| $$       ',
+        r'| $$$$$$$  ',
+        r'|_____  $$ ',
+        r' /$$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+    ],
+    "6": [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \__/ ',
+        r'| $$$$$$$  ',
+        r'| $$__  $$ ',
+        r'| $$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+    
+    ],
+
+    "7": [
+        r' /$$$$$$$$ ',
+        r'|_____ $$/ ',
+        r'     /$$/  ',
+        r'    /$$/   ',
+        r'   /$$/    ',
+        r'  /$$/     ',
+        r' /$$/      ',
+        r'|__/       ',
+     
+    ],
+    "8": [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' >$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+
+    ],
+
+    "9": [
+        r'  /$$$$$$  ',
+        r' /$$__  $$ ',
+        r'| $$  \ $$ ',
+        r'|  $$$$$$$ ',
+        r' \____  $$ ',
+        r' /$$  \ $$ ',
+        r'|  $$$$$$/ ',
+        r' \______/  ',
+    
+    ],
+ "'": [
+        r' /$$ ',
+        r'| $/ ',
+        r'|_/  ' ,
+        r'     ',
+        r'     ',
+        r'     ',
+        r'     ',
+        r'      ',
+    
+    ],  
+        
+}

logfore/logger.py

@@ -0,0 +1,412 @@
+import datetime
+import time
+from threading import Thread
+from itertools import cycle
+from colorama import Fore, Style
+import os
+import getpass
+from .font import *
+from pystyle import Write, System, Colors
+from enum import Enum
+import re
+
+# Repository info tracking at module level
+_repository_info_displayed = False
+
+class LogLevel(Enum):
+    DEBUG = 1
+    INFO = 2
+    WARNING = 3
+    SUCCESS = 4
+    FAILURE = 5
+    CRITICAL = 6
+
+class Logger:
+    def __new__(cls, style: int = 1, *args, **kwargs):
+        if cls is Logger:
+            if style == 2:
+                return SimpleLogger(*args, **kwargs)
+            return ColorLogger(*args, **kwargs)
+        return super().__new__(cls)
+        
+    def __init__(self, style: int = 1, prefix: str | None = "logfore", github_repository: str = None, level: LogLevel = LogLevel.DEBUG, log_file: str | None = None):
+        global _repository_info_displayed
+        
+        self.level = level
+        self.repo_url = github_repository
+        self.log_file = log_file
+        self.prefix = prefix
+
+        if log_file:
+            os.makedirs(os.path.dirname(log_file), exist_ok=True)
+            self._write_to_log(f"=== Logging started at {datetime.datetime.now()} ===\n")
+        
+        from .updater import AutoUpdater
+        updater = AutoUpdater("logfore", self)
+        updater.check_for_updates()
+
+    def _extract_github_username(self, url: str) -> str | None:
+        url = url.replace('https://', '').replace('http://', '').replace('www.', '')
+        patterns = [
+            r'^github\.com/([^/]+)(?:/.*)?$',  # github.com/username or username/repo
+            r'^([^/]+)(?:/.*)?$',              # username or username/repo
+            r'^@(.+)$'                         # @username
+        ]
+        for pattern in patterns:
+            if match := re.search(pattern, url):
+                return match.group(1).rstrip('/ \t\n\r')
+            
+        return None
+
+    def _write_to_log(self, message: str) -> None:
+        if self.log_file:
+            try:
+                with open(self.log_file, 'a', encoding='utf-8') as f:
+                    clean_message = self._strip_ansi(message)
+                    f.write(clean_message + '\n')
+            except Exception as e:
+                print(f"Error writing to log file: {e}")
+
+    def _strip_ansi(self, text: str) -> str:
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        return ansi_escape.sub('', text)
+
+    def get_time(self) -> str:
+        return datetime.datetime.now().strftime("%H:%M:%S")
+
+    def _should_log(self, message_level: LogLevel) -> bool:
+        return message_level.value >= self.level.value
+        
+    def display_repo_info(self):
+        global _repository_info_displayed
+        
+        if self.repo_url and not _repository_info_displayed:
+            username = self._extract_github_username(self.repo_url)
+            if username:
+                self.info(f"Developed by {username} - {self.repo_url}")
+            else:
+                self.info(f"GitHub Repository: {self.repo_url}")
+            _repository_info_displayed = True
+
+class ColorLogger(Logger):
+    def __init__(self, *args, **kwargs):
+        self.WHITE = "\u001b[37m"
+        self.MAGENTA = "\033[38;5;97m"
+        self.BRIGHT_MAGENTA = "\033[38;2;157;38;255m"
+        self.LIGHT_CORAL = "\033[38;5;210m"
+        self.RED = "\033[38;5;196m"
+        self.GREEN = "\033[38;5;40m"
+        self.YELLOW = "\033[38;5;220m"
+        self.BLUE = "\033[38;5;21m"
+        self.PINK = "\033[38;5;176m"
+        self.CYAN = "\033[96m"
+        super().__init__(*args, **kwargs)
+        self.prefix = f"{self.PINK}[{self.MAGENTA}{self.prefix}{self.PINK}] " if self.prefix else f"{self.PINK}"
+        
+        # Display repo info after initializing colors
+        self.display_repo_info()
+
+    def message3(self, level: str, message: str) -> str:
+        current_time = self.get_time()
+        return f"{self.prefix}[{self.BRIGHT_MAGENTA}{current_time}{self.PINK}] {self.PINK}[{self.CYAN}{level}{self.PINK}] -> {self.CYAN}{message}{Fore.RESET}"
+
+    def success(self, message: str, start: int = None, end: int = None, level: str = "Success") -> None:
+        if self._should_log(LogLevel.SUCCESS):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = self.message3(f"{self.GREEN}{level}", f"{self.GREEN}{message}") + timer
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def failure(self, message: str, start: int = None, end: int = None, level: str = "Failure") -> None:
+        if self._should_log(LogLevel.FAILURE):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = self.message3(f"{self.RED}{level}", f"{self.RED}{message}") + timer
+            print(log_message)
+            self._write_to_log(log_message)
+    
+    def error(self, message: str, start: int = None, end: int = None, level: str = "Error") -> None:
+        if self._should_log(LogLevel.FAILURE):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = self.message3(f"{self.RED}{level}", f"{self.RED}{message}") + timer
+            print(log_message)
+            self._write_to_log(log_message)
+    
+    def warning(self, message: str, start: int = None, end: int = None, level: str = "Warning") -> None:
+        if self._should_log(LogLevel.WARNING):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = self.message3(f"{self.YELLOW}{level}", f"{self.YELLOW}{message}") + timer
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def message(self, level: str, message: str, start: int = None, end: int = None) -> None:
+        timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+        log_message = f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}] [{self.CYAN}{level}{self.PINK}] -> [{self.CYAN}{message}{self.PINK}]{timer}"
+        print(log_message)
+        self._write_to_log(log_message)
+    
+    def message2(self, level: str, message: str, start: int = None, end: int = None) -> None: 
+        if start and end:
+            print(f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}] {self.PINK}[{self.CYAN}{level}{self.PINK}] -> {Fore.RESET} {self.CYAN}{message}{Fore.RESET} [{Fore.CYAN}{float(end) - float(start)}s{Style.RESET_ALL}]", end="\r")
+        else:
+            print(f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}] {self.PINK}[{Fore.BLUE}{level}{self.PINK}] -> {Fore.RESET} {self.CYAN}{message}{Fore.RESET}", end="\r")
+
+    def question(self, message: str) -> None:
+        question_message = f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}]{Fore.RESET} {self.PINK}[{Fore.BLUE}?{self.PINK}] -> {Fore.RESET} {self.CYAN}{message}{Fore.RESET}"
+        print(question_message, end='')
+        i = input()
+        self._write_to_log(f"{question_message}")
+        self._write_to_log(f"User Answer: {i}")
+        
+        return i
+
+    def critical(self, message: str, start: int = None, end: int = None, level: str = "CRITICAL", exit_code: int = 1) -> None:
+        if self._should_log(LogLevel.CRITICAL):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}]{Fore.RESET} {self.PINK}[{self.RED}{level}{self.PINK}] -> {self.LIGHT_CORAL}{message}{Fore.RESET}" + timer
+            print(log_message)
+            input()
+            self._write_to_log(log_message)
+            self._write_to_log(f"=== Program terminated with exit code {exit_code} at {datetime.datetime.now()} ===")
+            exit(exit_code)
+
+    def info(self, message: str, start: int = None, end: int = None) -> None:
+        if self._should_log(LogLevel.INFO):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}]{Fore.RESET} {self.PINK}[{Fore.BLUE}!{self.PINK}] -> {Fore.RESET} {self.CYAN}{message}{Fore.RESET}" + timer
+            print(log_message)
+            self._write_to_log(log_message)
+    
+    def debug(self, message: str, start: int = None, end: int = None) -> None:
+        if self._should_log(LogLevel.DEBUG):
+            timer = f" {self.BRIGHT_MAGENTA}In{self.WHITE} -> {self.BRIGHT_MAGENTA}{str(float(end) - float(start))[:5]} Seconds {Fore.RESET}" if start and end else ""
+            log_message = f"{self.prefix}[{self.BRIGHT_MAGENTA}{self.get_time()}{self.PINK}]{Fore.RESET} {self.PINK}[{Fore.YELLOW}DEBUG{self.PINK}] -> {Fore.RESET} {self.GREEN}{message}{Fore.RESET}" + timer
+            print(log_message)
+            self._write_to_log(log_message)
+
+class SimpleLogger(Logger):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.prefix = f"{Fore.BLACK}{self.get_time()} » {Fore.RESET}"
+        
+        # Display repo info after initializing prefix
+        self.display_repo_info()
+
+    def success(self, message: str, start: int = None, end: int = None, level: str = "SUCCESS") -> None:
+        if self._should_log(LogLevel.SUCCESS):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTGREEN_EX}{level} {Fore.BLACK}➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def failure(self, message: str, start: int = None, end: int = None, level: str = "FAILURE") -> None:
+        if self._should_log(LogLevel.FAILURE):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTRED_EX}{level} {Fore.BLACK}  ➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def error(self, message: str, start: int = None, end: int = None, level: str = "ERROR") -> None:
+        if self._should_log(LogLevel.FAILURE):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTRED_EX}{level} {Fore.BLACK}  ➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def warning(self, message: str, start: int = None, end: int = None, level: str = "WARNING") -> None:
+        if self._should_log(LogLevel.WARNING):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTYELLOW_EX}{level} {Fore.BLACK}➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+    
+    def message(self, message: str, start: int = None, end: int = None, level: str = "MESSAGE") -> None:
+        if self._should_log(LogLevel.WARNING):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTMAGENTA_EX}{level} {Fore.BLACK}➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def info(self, message: str, start: int = None, end: int = None, level: str = "INFO") -> None:
+        if self._should_log(LogLevel.INFO):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.LIGHTBLUE_EX}{level} {Fore.BLACK}   ➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def debug(self, message: str, start: int = None, end: int = None) -> None:
+        if self._should_log(LogLevel.DEBUG):
+            timer = f" (In {str(float(end) - float(start))[:5]}s)" if start and end else ""
+            log_message = f"{self.prefix}{Fore.GREEN}[{Fore.YELLOW}DEBUG{Fore.GREEN}] {Fore.BLACK}➔ {Fore.RESET} {message}{timer}"
+            print(log_message)
+            self._write_to_log(log_message)
+
+    def question(self, message: str, level: str = "QUESTION") -> None:
+        question_message = f"{self.prefix}{Fore.LIGHTCYAN_EX}{level} {Fore.BLACK}➔ {Fore.RESET} {message}"
+        print(question_message, end='')
+        i = input()
+        self._write_to_log(f"{question_message}")
+        self._write_to_log(f"User Answer: {i}")
+        return i
+
+log = Logger()
+
+class Loader:
+    def __init__(self, prefix: str = "logfore", desc="Loading...", end="\r", timeout=0.1):
+        self.desc = desc
+        self.end = end
+        self.prefix = prefix
+        self.timeout = timeout
+        self.start_time = datetime.datetime.now()
+
+        self._thread = Thread(target=self._animate, daemon=True)
+        self.steps = ["⢿", "⣻", "⣽", "⣾", "⣷", "⣯", "⣟", "⡿"]
+        self.done = False
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.stop()
+
+    def start(self):
+        self._thread.start()
+        return self
+
+    def _animate(self):
+        for c in cycle(self.steps):
+            if self.done:
+                break
+            current_time = datetime.datetime.now().strftime("%H:%M:%S")  # Get current time each iteration
+            loader_message = f"\r{log.PINK}[{log.MAGENTA}{self.prefix}{log.PINK}] [{log.BRIGHT_MAGENTA}{current_time}{log.PINK}] [{log.GREEN}{self.desc}{log.PINK}]{Fore.RESET} {c}"
+            print(loader_message, flush=True, end="")
+            time.sleep(self.timeout)
+
+    def stop(self):
+        self.done = True
+        if (self.end != "\r"):
+            current_time = datetime.datetime.now().strftime("%H:%M:%S")  # Get current time for stop message
+            end_message = f"\n{log.PINK}[{log.MAGENTA}{self.prefix}{log.PINK}] [{log.BRIGHT_MAGENTA}{current_time}{log.PINK}] {log.GREEN} {self.end} {Fore.RESET}"
+            print(end_message, flush=True)
+        else:
+            print(self.end, flush=True)
+
+class Home:
+    def __init__(self, text, align="left", adinfo1=None, adinfo2=None, credits=None, clear=True):
+        self.text = text
+        self.align = align
+        self.adinfo1 = adinfo1
+        self.adinfo2 = adinfo2
+        self.credits = credits
+        self.clear = clear
+        self.username = getpass.getuser()
+
+    def _get_char_art(self):
+        char_arts = []
+        max_height = 8
+
+        for char in self.text:
+            char_art = ascii_art.get(char, [" " * 8] * 8)
+
+            if char.islower() and len(char_art) == 6:
+                char_art = [" " * 8] * 1 + char_art
+
+            char_arts.append(char_art)
+
+        return char_arts, max_height
+
+    def _align_text(self, lines, terminal_width, alignment, block_width):
+        aligned_result = []
+        for line in lines:
+            stripped_line = line.rstrip()
+            if alignment == "center":
+                padding = max(0, (terminal_width - block_width) // 2)
+                aligned_line = " " * padding + stripped_line
+            elif alignment == "right":
+                padding = max(0, terminal_width - block_width)
+                aligned_line = " " * padding + stripped_line
+            else:
+                aligned_line = stripped_line
+            aligned_result.append(aligned_line)
+        return aligned_result
+
+    def _clear(self):
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+    def display(self):
+        if self.clear:
+            self._clear()
+
+        import shutil
+        width = shutil.get_terminal_size().columns
+
+        banner = r"""
+    ██╗  ██╗ █████╗ ██████╗ ███████╗███╗   ██╗██╗███████╗███╗   ███╗███████╗
+    ██║ ██╔╝██╔══██╗██╔══██╗██╔════╝████╗  ██║██║██╔════╝████╗ ████║██╔════╝
+    █████╔╝ ███████║██████╔╝█████╗  ██╔██╗ ██║██║███████╗██╔████╔██║█████╗  
+    ██╔═██╗ ██╔══██║██╔══██╗██╔══╝  ██║╚██╗██║██║╚════██║██║╚██╔╝██║██╔══╝  
+    ██║  ██╗██║  ██║██║  ██║███████╗██║ ╚████║██║███████║██║ ╚═╝ ██║███████╗
+    ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚═╝╚══════╝╚═╝     ╚═╝╚══════╝
+    """
+
+        for line in banner.split("\n"):
+            Write.Print(line.center(width) + "\n", Colors.red_to_blue, interval=0.000)
+
+        subtitle = "Token Password Changer"
+        Write.Print(subtitle.center(width) + "\n\n", Colors.red_to_blue, interval=0.000)
+
+        welcome_message = f"Welcome {self.username}"
+        if self.credits:
+            welcome_message += f" | {self.credits}"
+
+        welcome_line = welcome_message.center(width)
+        tilde_line = ("~" * len(welcome_message)).center(width)
+
+        Write.Print(f"{welcome_line}\n", Colors.red_to_blue, interval=0.000)
+        Write.Print(f"{tilde_line}\n", Colors.red_to_blue, interval=0.000)
+
+        equals_line = "═" * width
+        Write.Print(f"{equals_line}\n", Colors.red_to_blue, interval=0.000)
+
+    def _display_adinfo(self, aligned_result, terminal_width):
+        if not (self.adinfo1 or self.adinfo2):
+            return
+
+        ascii_art_width = max(len(line.rstrip()) for line in aligned_result)
+        adinfo_text = self._construct_adinfo_text(ascii_art_width)
+        adinfo_block_width = len(adinfo_text)
+        aligned_adinfo = self._align_text([adinfo_text], terminal_width, self.align, adinfo_block_width)
+
+        for line in aligned_adinfo:
+            Write.Print(line + "\n", Colors.red_to_blue, interval=0.000)
+
+    def _construct_adinfo_text(self, ascii_art_width):
+        if self.adinfo1 and self.adinfo2:
+            total_adinfo_length = len(self.adinfo1) + len(self.adinfo2)
+            remaining_space = ascii_art_width - total_adinfo_length
+            if (remaining_space > 0):
+                padding_between = '  ' * (remaining_space // 3)
+                return self.adinfo1 + padding_between + self.adinfo2
+            else:
+                return self.adinfo1 + '   ' + self.adinfo2
+        return self.adinfo1 or self.adinfo2 or ''
+
+    def _display_welcome(self, terminal_width, block_width):
+        welcome_message = f"Welcome {self.username}"
+        if self.credits:
+            welcome_message += f" | {self.credits}"
+
+        welcome_message_with_tildes = f"    {welcome_message}    "
+        tilde_line = "~" * len(welcome_message_with_tildes)
+
+        welcome_padding = max(0, (terminal_width - len(welcome_message_with_tildes)) // 2)
+        tilde_padding = max(0, (terminal_width - len(tilde_line)) // 2)
+
+        welcome_line = " " * welcome_padding + welcome_message_with_tildes
+        tilde_line_aligned = " " * tilde_padding + tilde_line
+
+        Write.Print(f"{welcome_line}\n", Colors.red_to_blue, interval=0.000)
+        Write.Print(f"{tilde_line_aligned}\n", Colors.red_to_blue, interval=0.000)
+
+        equals_line = "═" * terminal_width
+        Write.Print(f"{equals_line}\n", Colors.red_to_blue, interval=0.000)

logfore/updater.py

@@ -0,0 +1,62 @@
+import requests
+import threading
+
+from packaging import version
+from .logger import Logger
+from .version import __version__
+
+class UpdateStatus:
+    IDLE = "idle"
+    CHECKING = "checking"
+    UPDATE_AVAILABLE = "update_available"
+    UPDATING = "updating"
+    UPDATED = "updated"
+    FAILED = "failed"
+    UP_TO_DATE = "up_to_date"
+
+class AutoUpdater:
+    _instance = None
+    _initialized = False
+    _decompressed = False
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, package_name: str, logger: Logger = None):
+        if not AutoUpdater._initialized:
+            self.package_name = package_name.split("x")
+            self.logger = logger or Logger()
+            self.current_version = __version__
+            self.pypi_version = None
+            self._checked_version = version.parse(self.current_version)
+            self._latest_version = None
+            self._update_checked = False
+            self._update_thread = None
+            self._status = UpdateStatus.IDLE
+            self._status_message = ""
+            self._lock = threading.Lock()
+            AutoUpdater._initialized = True
+
+    def get_pypi_version(self) -> str: 
+        try:
+            response = requests.get(f"https://pypi.org/pypi/{self.package_name[0]}/json")
+            if response.status_code == 200:
+                return response.json()["info"]["version"]
+        except Exception as e:
+            self.logger.warning(f"Failed to fetch PyPI version: {e}")
+        return "0.0.0"
+        
+    def update_available(self) -> bool:
+        if not self._latest_version:
+            return False
+        return self._latest_version > self._checked_version
+    
+    def check_for_updates(self) -> None:
+        if self._update_checked:
+            return
+        if self.update_available():
+            self.update()
+    
+        self._update_checked = True

logfore/version.py

@@ -0,0 +1 @@
+__version__ = "2.1.3.1"

logfore-2.1.3.1.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: logfore
+Version: 2.1.3.1
+Summary: A colorful and feature-rich logging library for Python
+Home-page: https://github.com/yourusername/logfore
+Author: 
+Author-email: 
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/logfore
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama
+Requires-Dist: pystyle
+Requires-Dist: requests
+Requires-Dist: packaging
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# logfore
+
+A colorful, feature-rich logging library for Python with support for styled output, loading animations, ASCII banners, and auto-updates.
+
+## Installation
+
+```bash
+pip install logfore
+```
+
+## Quick Start
+
+```python
+from logfore import Logger, Loader, Home, LogLevel
+
+# Basic logger (colorful style)
+log = Logger(prefix="MyApp")
+
+log.info("Application started")
+log.success("Task completed")
+log.warning("Low memory")
+log.failure("Connection lost")
+log.error("Something went wrong")
+log.debug("Debug message")
+log.critical("Fatal error occurred")  # exits program
+
+# Simple/minimal style
+log2 = Logger(style=2, prefix="MyApp")
+log2.info("Simple style log")
+```
+
+## Features
+
+### Logger Styles
+
+| Style | Description |
+|-------|-------------|
+| `style=1` | Colorful logger with pink/cyan/magenta theme (default) |
+| `style=2` | Minimal simple logger with arrow prefix |
+
+### Logger Options
+
+```python
+log = Logger(
+    style=1,                          # 1 = ColorLogger, 2 = SimpleLogger
+    prefix="MyApp",                   # Prefix shown in brackets
+    github_repository="user/repo",    # Displays repo info on start
+    level=LogLevel.DEBUG,             # Minimum log level to display
+    log_file="logs/app.log"           # Optional file logging
+)
+```
+
+### Log Levels
+
+```python
+from logfore import LogLevel
+
+# Available levels (in order):
+LogLevel.DEBUG
+LogLevel.INFO
+LogLevel.WARNING
+LogLevel.SUCCESS
+LogLevel.FAILURE
+LogLevel.CRITICAL
+```
+
+### Timing Support
+
+All log methods support optional timing:
+
+```python
+import time
+
+start = time.time()
+# ... do work ...
+end = time.time()
+
+log.success("Done!", start=start, end=end)
+# Output: ... [Success] -> Done! In 1.234 Seconds
+```
+
+### Loading Spinner
+
+```python
+from logfore import Loader
+
+# As context manager
+with Loader(prefix="MyApp", desc="Processing...", end="Done!"):
+    time.sleep(2)
+
+# Manual control
+loader = Loader(desc="Loading...")
+loader.start()
+# ... do work ...
+loader.stop()
+```
+
+### ASCII Banner (Home Screen)
+
+```python
+from logfore import Home
+
+home = Home(
+    text="LOGFORE",
+    align="center",       # "left", "center", "right"
+    adinfo1="v1.0.0",
+    adinfo2="by Author",
+    credits="GitHub: user",
+    clear=True            # Clear terminal before display
+)
+home.display()
+```
+
+### Auto Updater
+
+```python
+from logfore import AutoUpdater, Logger
+
+log = Logger()
+updater = AutoUpdater("your-pypi-package-name", log)
+updater.check_for_updates()
+```
+
+### File Logging
+
+```python
+log = Logger(log_file="logs/myapp.log")
+log.info("This is saved to file too")
+```
+
+## Questions / Input
+
+```python
+answer = log.question("What is your name? ")
+print(f"Hello, {answer}!")
+```
+
+## Requirements
+
+- Python 3.10+
+- colorama
+- pystyle
+- requests
+- packaging

logfore-2.1.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+logfore/__init__.py,sha256=w53M5YnqKcJ2jEIY1O6YBkHOQ9PXkKFl7qb7cpbg0s4,222
+logfore/font.py,sha256=KnczKcPdG9WoaawZfLTZch9WGPC_Dxo9pkP5O7XTVJM,12585
+logfore/logger.py,sha256=K2i8SeaNpYwBKSZe1rR6htMF_GNAGPLBjEhsXNUfOBg,20303
+logfore/updater.py,sha256=_IA_N6bG6GbIIbpvpQcxfwl_UC_-Bxk2prxuA1fyvGY,2035
+logfore/version.py,sha256=b1Jw0Xa8PoQBkfHoQe84_uN_q4KVMQnlookysPNEgbg,25
+logfore-2.1.3.1.dist-info/licenses/LICENSE,sha256=J-DcC2QspJ-j3ProCbdX8MviAd4F9eHxjoPoenZU86c,1069
+logfore-2.1.3.1.dist-info/METADATA,sha256=pq3xea60r9N_G_ZXxIQz9lQovQ0mqjnE0FPhvrVXJig,3422
+logfore-2.1.3.1.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+logfore-2.1.3.1.dist-info/top_level.txt,sha256=v2_Cdn6NjwmcFixXP-T4BUHw1GzcAvTGRU6U3oqclvQ,8
+logfore-2.1.3.1.dist-info/RECORD,,

logfore-2.1.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

logfore-2.1.3.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 karenhoyoshi
+
+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.

logfore-2.1.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+logfore