././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1751013430.2213545 redu_logger-1.0.5/0000777000000000000000000000000015027454066010756 5ustar00././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1751013430.1794367 redu_logger-1.0.5/PKG-INFO0000666000000000000000000001207515027454066012060 0ustar00Metadata-Version: 2.2 Name: redu_logger Version: 1.0.5 Summary: A Python module to log data in files locally or remotely for any application or script. Author: Ridwan Hossain Abid Classifier: Development Status :: 5 - Production/Stable Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Programming Language :: Python :: 3 Classifier: Operating System :: OS Independent Requires-Python: >=3.6 Description-Content-Type: text/markdown Requires-Dist: requests<3.0.0,>=2.32.3 Dynamic: author Dynamic: classifier Dynamic: description Dynamic: description-content-type Dynamic: requires-dist Dynamic: requires-python Dynamic: summary # redu_logger redu_logger.py is the main module file. This is a custom logger written in Python for use with Python applications and scripts. ## Features - Log any message to a specified file with log levels - Log both locally and remotely - Log to multiple files in local logging. A feature called Multi-Log - Application session tracking for logs to easily understand which log files are for a specified session ## Log Levels **Version of 'redu_logger.py' is 1.0.5 when writing this.** There are now a total of 6 log levels. But you can always add custom log levels yourself. 1. Info 2. Warning 3. Error 4. Critical 5. Debug 6. Connection ## Example Implementation ### Logging locally with Multi-Log disabled: ``` # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger # Initialize redu_logger with configurations local_log_path = "logs" local_log_file_name = "log" # Logging locally. Multi-Log Disabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=False, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` ### Logging locally with Multi-Log enabled: ``` # file1 # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger import subprocess import sys # Initialize redu_logger with configurations local_log_path = "logs/file1" local_log_file_name = "file1" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( is_main=True, local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") subprocess.run([sys.executable, "multi-log enabled (file2).py"]) if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` Notice here that the only thing changed is that a new argument `is_main` is set to True; the path of the `local_log_path`, `local_log_file_name`, and `local_multi_log` is set the True when initializing the logger. Now, for another file, only the initialization of the logger has to be changed for Multi-Log to work properly. For example: ``` # file2 # Example usage of redu_logger.py Version of the module is 1.0.5 # Codes... # Initialize redu_logger with configurations local_log_path = "logs/file2" local_log_file_name = "file2" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) # Codes... ``` Here, the argument `is_main` is not used. This is crucial for Multi-Log to work properly. There can only be one main file, which will run the other files internally, and in their initialization of the logger, `is_main` has to be set to **False**. But we didn't set it here because it is set to **False** by default. There is more to setting up Multi-Log properly. Look into the wiki to learn more. ### Logging remotely: I once logged remotely for my one script, but never had to then. That's why the support and the method of logging remotely are a bit complicated and manual. For remote logging to work, you need some sort of server. I used Flask, but I don't have the code on how I did that. So, until I decide to create a server script for remote logging, you have to make a server that can communicate with this module for remote logging. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1750867570.0 redu_logger-1.0.5/README.md0000666000000000000000000001062215027017162012226 0ustar00# redu_logger redu_logger.py is the main module file. This is a custom logger written in Python for use with Python applications and scripts. ## Features - Log any message to a specified file with log levels - Log both locally and remotely - Log to multiple files in local logging. A feature called Multi-Log - Application session tracking for logs to easily understand which log files are for a specified session ## Log Levels **Version of 'redu_logger.py' is 1.0.5 when writing this.** There are now a total of 6 log levels. But you can always add custom log levels yourself. 1. Info 2. Warning 3. Error 4. Critical 5. Debug 6. Connection ## Example Implementation ### Logging locally with Multi-Log disabled: ``` # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger # Initialize redu_logger with configurations local_log_path = "logs" local_log_file_name = "log" # Logging locally. Multi-Log Disabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=False, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` ### Logging locally with Multi-Log enabled: ``` # file1 # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger import subprocess import sys # Initialize redu_logger with configurations local_log_path = "logs/file1" local_log_file_name = "file1" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( is_main=True, local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") subprocess.run([sys.executable, "multi-log enabled (file2).py"]) if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` Notice here that the only thing changed is that a new argument `is_main` is set to True; the path of the `local_log_path`, `local_log_file_name`, and `local_multi_log` is set the True when initializing the logger. Now, for another file, only the initialization of the logger has to be changed for Multi-Log to work properly. For example: ``` # file2 # Example usage of redu_logger.py Version of the module is 1.0.5 # Codes... # Initialize redu_logger with configurations local_log_path = "logs/file2" local_log_file_name = "file2" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) # Codes... ``` Here, the argument `is_main` is not used. This is crucial for Multi-Log to work properly. There can only be one main file, which will run the other files internally, and in their initialization of the logger, `is_main` has to be set to **False**. But we didn't set it here because it is set to **False** by default. There is more to setting up Multi-Log properly. Look into the wiki to learn more. ### Logging remotely: I once logged remotely for my one script, but never had to then. That's why the support and the method of logging remotely are a bit complicated and manual. For remote logging to work, you need some sort of server. I used Flask, but I don't have the code on how I did that. So, until I decide to create a server script for remote logging, you have to make a server that can communicate with this module for remote logging. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1750928419.0 redu_logger-1.0.5/pyproject.toml0000666000000000000000000000013515027206043013657 0ustar00[build-system] requires = ["setuptools", "wheel"] build-backend = "setuptools.build_meta" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1751013430.0885592 redu_logger-1.0.5/redu_logger/0000777000000000000000000000000015027454066013254 5ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013411.0 redu_logger-1.0.5/redu_logger/__init__.py0000666000000000000000000000014115027454043015354 0ustar00from .redu_logger import RemoteLogger, __version__ __all__ = ["RemoteLogger", "__version__"] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1750778866.0 redu_logger-1.0.5/redu_logger/redu_logger.py0000666000000000000000000002664515026541762016140 0ustar00""" redu_logger.py: ReduLogger is a simple and easy-to-use logger for logging remotely to a server and locally to the machine. """ # Imports import os import requests import atexit from datetime import datetime from pathlib import Path from requests.auth import HTTPBasicAuth __version__ = "1.0.5" CURRENT_DIRECTORY = Path.cwd() class Utilities: @staticmethod def exists_path(path): """ Checks if the folder exists. If not, it creates the folder. :param path: The path to be checked. """ if not Path(path).exists(): Path(path).mkdir(parents=True, exist_ok=True) @staticmethod def exists_file(file_path): """ Checks if the file exists. If not, it creates the file. :param file_path: The path to the file to be checked. """ try: file_path = Path(file_path) if not file_path.parent.exists(): file_path.parent.mkdir(parents=True, exist_ok=True) file_path.touch(exist_ok=True) except Exception as e: print(f"Error ensuring file exists: {e}") @staticmethod def join_path_with_cwd(*paths): """ Join the given paths with the root directory. :param paths: Paths to join. :return: Joined path. """ joined_path = Path.joinpath(CURRENT_DIRECTORY, *paths) return str(joined_path) @staticmethod def generate_launch_id_path(log_path: Path): # Traverse up until we reach the "logs" folder for parent in [log_path] + list(log_path.parents): if parent.name == "logs": launch_id_path = str(parent) break else: launch_id_path = str(log_path) # Fallback to current path return launch_id_path class RemoteLogger: def __init__(self, local_logging: bool, remote_logging: bool, is_main: bool = False, disable_print : bool=False, server_url: str=None, auth: bool=False, username: str=None, password: str=None, local_log_file_name: str= "log", local_log_path: str= "logs", local_log_extension: str= "log", local_multi_log: bool=False ): """ Initialize RemoteLogger for logging remotely to a remote server and locally. Default log levels are: INFO, WARNING, ERROR, CRITICAL, DEBUG. :param local_logging: If true, log locally to the local machine. :param remote_logging: If true, log remotely to the server. :param disable_print: If true, disable printing locally. Default is false :param server_url: URL of the server to log remotely. :param auth: If true use HTTPBasicAuth to authenticate. Default is false. :param username: Username for authentication if enabled. :param password: Password for authentication if enabled. :param local_log_file_name: Name of the log file. Default is "logs". :param local_log_path: Path to save the log file. Default is "logs". :param local_log_extension: Extension of the log file. Default is "log". :param local_multi_log: If true, log to multiple files. Default is false. """ # Initialize Arguments self.is_main = is_main self.remote_logging = remote_logging self.disable_print = disable_print self.local_log_file_name = local_log_file_name # Initialize Local Logging # Initialize Local Log Counter self.log_counter_file = Utilities.join_path_with_cwd(local_log_path, "log_counter.txt") Utilities.exists_file(self.log_counter_file) try: # Try to read the log counter and increment it, with default value handling if file not found with open(self.log_counter_file, 'r+') as f: self.log_counter = int(f.read() or '1') # Use 1 if file is empty f.seek(0) f.write(str(self.log_counter + 1)) f.truncate() # Remove everything after the counter except FileNotFoundError: with open(self.log_counter_file, 'w') as f: self.log_counter = 1 f.write(str(self.log_counter + 1)) # Initialize Local Log Path ## WARNING: The local_log_path should be declared before Multi-Log Variables else it will crash self.local_log_path = local_log_path self.local_log_path = Path(Utilities.join_path_with_cwd(local_log_path)) Utilities.exists_path(self.local_log_path) # Multi-Log Variables self.local_multi_log = local_multi_log if self.local_multi_log: self.launch_id_path = Utilities.generate_launch_id_path(self.local_log_path) self.launch_id_file = os.path.join(self.launch_id_path, "launch_id.txt") # Only the main instances should handle the launch ID file """ Explanation of the code block: Programmatically assigns one launch ID to the main instance and reads it for non-main instances and writes the next used launch ID to the file. """ if self.is_main: try: # Increment the launch ID for main instances with open(self.launch_id_file, 'r+') as f: self.launch_id = int(f.read() or '1') # Use 1 if file is empty f.seek(0) f.write(str(self.launch_id + 1)) f.truncate() except FileNotFoundError: with open(self.launch_id_file, 'w') as f: self.launch_id = 1 f.write(str(self.launch_id + 1)) else: try: # Does not increment the launch ID for non-main instances with open(self.launch_id_file, 'r') as f: self.launch_id = int(f.read().strip() or '1') except FileNotFoundError: self.launch_id = 1 # Initialize Variables self.local_logging = local_logging self._local_log_extension = local_log_extension.replace(".", "").lower() # Remove dot self.local_log_extension = self._local_log_extension self.log_launch_id_name = f"_launchID-{self.launch_id}" if self.local_multi_log else "" self.local_log_file = Path.joinpath(self.local_log_path, f"{self.local_log_file_name}_{self.log_counter}{self.log_launch_id_name}.{self.local_log_extension}") # Initialize Remote Logging if self.remote_logging: # Initialize the remote logging variables only if remote logging is enabled self.server_url = server_url self.auth = auth if self.server_url and self.auth: self.username = username self.password = password # Register the exit function to log when the program finishes atexit.register(self._log_atexit) # Log the initialization self.info(f"Logger initialized. ReduLogger Version: {__version__}") self.info(f"Remote logging: {self.remote_logging}") self.info(f"Local logging: {self.local_logging}") def _log_atexit(self): """ Log an info level message when the logger exits, indicating safe exit. """ self.info("Logger exited safely.") def _log(self, level, message): """ Send a log with timestamp, level and message to the remote server. :param level: Level of the log. :param message: Message of the log. :raises requests.exceptions.RequestException: If there's an issue with the network connection or if the server can't be reached. """ log_data = { "timestamp": datetime.now().isoformat(), "level": level, "message": message } # Write log remotely if self.remote_logging and self.server_url: try: if self.auth: response = requests.post(self.server_url, json=log_data, auth=HTTPBasicAuth(self.username, self.password)) response.raise_for_status() else: response = requests.post(self.server_url, json=log_data) response.raise_for_status() except requests.exceptions.RequestException as e: print(f"Failed to write remote log to server: {e}") # Write log locally if self.local_logging: try: with open(self.local_log_file, 'a') as log_file: log_file.write(f"{log_data['timestamp']} - {log_data['level']}: {log_data['message']}\n") except Exception as e: print(f"Failed to write log locally: {e}") def info(self, message, print_message: bool = False): """ Send a log as INFO level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("INFO", message) if print_message and not self.disable_print: print(f"[INFO] {message}") def warning(self, message, print_message: bool = False): """ Send a log as WARNING level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("WARNING", message) if print_message and not self.disable_print: print(f"[WARNING] {message}") def error(self, message, print_message: bool = False): """ Send a log as ERROR level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("ERROR", message) if print_message and not self.disable_print: print(f"[ERROR] {message}") def critical(self, message, print_message: bool = False): """ Send a log as CRITICAL level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("CRITICAL", message) if print_message and not self.disable_print: print(f"[CRITICAL] {message}") def debug(self, message, print_message: bool = False): """ Send a log as DEBUG level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("DEBUG", message) if print_message and not self.disable_print: print(f"[DEBUG] {message}") def connection(self, message, print_message: bool = False): """ Send a log as CONNECTION level :param message: Message of the log :param print_message: Prints the message to the console if True. Default is False """ self._log("CONNECTION", message) if print_message and not self.disable_print: print(f"[CONNECTION] {message}") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1751013430.1448033 redu_logger-1.0.5/redu_logger.egg-info/0000777000000000000000000000000015027454066014746 5ustar00././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013429.0 redu_logger-1.0.5/redu_logger.egg-info/PKG-INFO0000666000000000000000000001207515027454065016047 0ustar00Metadata-Version: 2.2 Name: redu_logger Version: 1.0.5 Summary: A Python module to log data in files locally or remotely for any application or script. Author: Ridwan Hossain Abid Classifier: Development Status :: 5 - Production/Stable Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Programming Language :: Python :: 3 Classifier: Operating System :: OS Independent Requires-Python: >=3.6 Description-Content-Type: text/markdown Requires-Dist: requests<3.0.0,>=2.32.3 Dynamic: author Dynamic: classifier Dynamic: description Dynamic: description-content-type Dynamic: requires-dist Dynamic: requires-python Dynamic: summary # redu_logger redu_logger.py is the main module file. This is a custom logger written in Python for use with Python applications and scripts. ## Features - Log any message to a specified file with log levels - Log both locally and remotely - Log to multiple files in local logging. A feature called Multi-Log - Application session tracking for logs to easily understand which log files are for a specified session ## Log Levels **Version of 'redu_logger.py' is 1.0.5 when writing this.** There are now a total of 6 log levels. But you can always add custom log levels yourself. 1. Info 2. Warning 3. Error 4. Critical 5. Debug 6. Connection ## Example Implementation ### Logging locally with Multi-Log disabled: ``` # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger # Initialize redu_logger with configurations local_log_path = "logs" local_log_file_name = "log" # Logging locally. Multi-Log Disabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=False, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` ### Logging locally with Multi-Log enabled: ``` # file1 # Example usage of redu_logger.py Version of the module is 1.0.5 import redu_logger import subprocess import sys # Initialize redu_logger with configurations local_log_path = "logs/file1" local_log_file_name = "file1" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( is_main=True, local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) def main(): # Log some messages to demonstrate functionality logger.info("This is an info message.") logger.warning("This is a warning message.") logger.error("This is an error message.") logger.critical("This is a critical message.") logger.debug("This is a debug message.") logger.connection("This is a connection message.") subprocess.run([sys.executable, "multi-log enabled (file2).py"]) if __name__ == '__main__': main() # Calling it now will log the messages to the specified log file in the specified directory. ``` Notice here that the only thing changed is that a new argument `is_main` is set to True; the path of the `local_log_path`, `local_log_file_name`, and `local_multi_log` is set the True when initializing the logger. Now, for another file, only the initialization of the logger has to be changed for Multi-Log to work properly. For example: ``` # file2 # Example usage of redu_logger.py Version of the module is 1.0.5 # Codes... # Initialize redu_logger with configurations local_log_path = "logs/file2" local_log_file_name = "file2" # Logging locally. Multi-Log Enabled. logger = redu_logger.RemoteLogger( local_logging=True, remote_logging=False, local_log_path=local_log_path, local_log_file_name=local_log_file_name, local_multi_log=True, ) # Codes... ``` Here, the argument `is_main` is not used. This is crucial for Multi-Log to work properly. There can only be one main file, which will run the other files internally, and in their initialization of the logger, `is_main` has to be set to **False**. But we didn't set it here because it is set to **False** by default. There is more to setting up Multi-Log properly. Look into the wiki to learn more. ### Logging remotely: I once logged remotely for my one script, but never had to then. That's why the support and the method of logging remotely are a bit complicated and manual. For remote logging to work, you need some sort of server. I used Flask, but I don't have the code on how I did that. So, until I decide to create a server script for remote logging, you have to make a server that can communicate with this module for remote logging. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013430.0 redu_logger-1.0.5/redu_logger.egg-info/SOURCES.txt0000666000000000000000000000040215027454066016626 0ustar00README.md pyproject.toml setup.py redu_logger/__init__.py redu_logger/redu_logger.py redu_logger.egg-info/PKG-INFO redu_logger.egg-info/SOURCES.txt redu_logger.egg-info/dependency_links.txt redu_logger.egg-info/requires.txt redu_logger.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013429.0 redu_logger-1.0.5/redu_logger.egg-info/dependency_links.txt0000666000000000000000000000000115027454065021013 0ustar00 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013429.0 redu_logger-1.0.5/redu_logger.egg-info/requires.txt0000666000000000000000000000003015027454065017336 0ustar00requests<3.0.0,>=2.32.3 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013429.0 redu_logger-1.0.5/redu_logger.egg-info/top_level.txt0000666000000000000000000000001415027454065017472 0ustar00redu_logger ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1751013430.2213545 redu_logger-1.0.5/setup.cfg0000666000000000000000000000005215027454066012574 0ustar00[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1751013261.0 redu_logger-1.0.5/setup.py0000666000000000000000000000137615027453615012476 0ustar00from setuptools import setup, find_packages setup( name="redu_logger", version="1.0.5", author="Ridwan Hossain Abid", description="A Python module to log data in files locally or remotely for any application or script.", long_description=open("README.md", "r", encoding="utf-8").read(), long_description_content_type="text/markdown", packages=find_packages(), include_package_data=True, install_requires=['requests>=2.32.3,<3.0.0'], classifiers=[ "Development Status :: 5 - Production/Stable", "Topic :: Software Development :: Libraries :: Python Modules", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ], python_requires='>=3.6', )