pythonLogs 3.0.12__py3-none-any.whl

pythonLogs/.env.example

@@ -0,0 +1,17 @@
+LOG_LEVEL=DEBUG
+LOG_TIMEZONE=UTC
+LOG_ENCODING=UTF-8
+LOG_APPNAME=app
+LOG_FILENAME=app.log
+LOG_DIRECTORY=/app/logs
+LOG_DAYS_TO_KEEP=30
+LOG_STREAM_HANDLER=True
+LOG_SHOW_LOCATION=False
+LOG_DATE_FORMAT=%Y-%m-%dT%H:%M:%S
+
+# SizeRotatingLog
+LOG_MAX_FILE_SIZE_MB=10
+
+# TimedRotatingLog
+LOG_ROTATE_WHEN=midnight
+LOG_ROTATE_AT_UTC=True

pythonLogs/__init__.py

@@ -0,0 +1,55 @@
+import logging
+from importlib.metadata import version
+from typing import Literal, NamedTuple
+from .timed_rotating import TimedRotatingLog
+from .size_rotating import SizeRotatingLog
+from .basic_log import BasicLog
+
+
+__all__ = (
+    "BasicLog",
+    "TimedRotatingLog",
+    "SizeRotatingLog",
+)
+
+__title__ = "pythonLogs"
+__author__ = "Daniel Costa"
+__email__ = "danieldcsta@gmail.com>"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024-present ddc"
+_req_python_version = (3, 10, 0)
+
+
+try:
+    _version = tuple(int(x) for x in version(__title__).split("."))
+except ModuleNotFoundError:
+    _version = (0, 0, 0)
+
+
+class VersionInfo(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: Literal["alpha", "beta", "candidate", "final"]
+    serial: int
+
+
+__version__ = _version
+__version_info__: VersionInfo = VersionInfo(
+    major=__version__[0],
+    minor=__version__[1],
+    micro=__version__[2],
+    releaselevel="final",
+    serial=0
+)
+__req_python_version__: VersionInfo = VersionInfo(
+    major=_req_python_version[0],
+    minor=_req_python_version[1],
+    micro=_req_python_version[2],
+    releaselevel="final",
+    serial=0
+)
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+del logging, NamedTuple, Literal, VersionInfo, version, _version, _req_python_version

pythonLogs/basic_log.py

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+import logging
+from typing import Optional
+from pythonLogs.log_utils import get_format, get_level, get_timezone_function
+from pythonLogs.settings import LogSettings
+
+
+class BasicLog:
+    def __init__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        showlocation: Optional[bool] = None,
+    ):
+        _settings = LogSettings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.showlocation = showlocation or _settings.show_location
+
+    def init(self):
+        logger = logging.getLogger(self.appname)
+        logger.setLevel(self.level)
+        logging.Formatter.converter = get_timezone_function(self.timezone)
+        _format = get_format(self.showlocation, self.appname, self.timezone)
+        logging.basicConfig(datefmt=self.datefmt, encoding=self.encoding, format=_format)
+        return logger

pythonLogs/log_utils.py

@@ -0,0 +1,264 @@
+# -*- encoding: utf-8 -*-
+import errno
+import gzip
+import logging.handlers
+import os
+import shutil
+import sys
+import time
+from datetime import datetime, timedelta, timezone as dttz
+from time import struct_time
+from typing import Any, Callable
+import pytz
+
+
+def get_stream_handler(
+    level: int,
+    formatter: logging.Formatter,
+) -> logging.StreamHandler:
+
+    stream_hdlr = logging.StreamHandler()
+    stream_hdlr.setFormatter(formatter)
+    stream_hdlr.setLevel(level)
+    return stream_hdlr
+
+
+def get_logger_and_formatter(
+    name: str,
+    datefmt: str,
+    show_location: bool,
+    timezone: str,
+) -> [logging.Logger, logging.Formatter]:
+
+    logger = logging.getLogger(name)
+    for handler in logger.handlers[:]:
+        handler.close()
+        logger.removeHandler(handler)
+
+    formatt = get_format(show_location, name, timezone)
+    formatter = logging.Formatter(formatt, datefmt=datefmt)
+    formatter.converter = get_timezone_function(timezone)
+    return logger, formatter
+
+
+def check_filename_instance(filenames: list | tuple) -> None:
+    if not isinstance(filenames, list | tuple):
+        err_msg = f"Unable to parse filenames. Filename instance is not list or tuple. | {filenames}"
+        write_stderr(err_msg)
+        raise TypeError(err_msg)
+
+
+def check_directory_permissions(directory_path: str) -> None:
+    if os.path.isdir(directory_path) and not os.access(directory_path, os.W_OK | os.X_OK):
+        err_msg = f"Unable to access directory | {directory_path}"
+        write_stderr(err_msg)
+        raise PermissionError(err_msg)
+
+    try:
+        if not os.path.isdir(directory_path):
+            os.makedirs(directory_path, mode=0o755, exist_ok=True)
+    except PermissionError as e:
+        err_msg = f"Unable to create directory | {directory_path}"
+        write_stderr(f"{err_msg} | {repr(e)}")
+        raise PermissionError(err_msg)
+
+
+def remove_old_logs(logs_dir: str, days_to_keep: int) -> None:
+    files_list = list_files(logs_dir, ends_with=".gz")
+    for file in files_list:
+        try:
+            if is_older_than_x_days(file, days_to_keep):
+                delete_file(file)
+        except Exception as e:
+            write_stderr(f"Unable to delete {days_to_keep} days old logs | {file} | {repr(e)}")
+
+
+def list_files(directory: str, ends_with: str) -> tuple:
+    """
+    List all files in the given directory
+        and returns them in a list sorted by creation time in ascending order
+    :param directory:
+    :param ends_with:
+    :return: tuple
+    """
+
+    try:
+        result: list = []
+        if os.path.isdir(directory):
+            result: list = [os.path.join(directory, f) for f in os.listdir(directory) if f.lower().endswith(ends_with)]
+            result.sort(key=os.path.getmtime)
+        return tuple(result)
+    except Exception as e:
+        write_stderr(repr(e))
+        raise e
+
+
+def delete_file(path: str) -> bool:
+    """
+    Remove the given file and returns True if the file was successfully removed
+    :param path:
+    :return: True
+    """
+    try:
+        if os.path.isfile(path):
+            os.remove(path)
+        elif os.path.exists(path):
+            shutil.rmtree(path)
+        else:
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), path)
+    except OSError as e:
+        write_stderr(repr(e))
+        raise e
+    return True
+
+
+def is_older_than_x_days(path: str, days: int) -> bool:
+    """
+    Check if a file or directory is older than the specified number of days
+    :param path:
+    :param days:
+    :return:
+    """
+
+    if not os.path.exists(path):
+        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), path)
+
+    try:
+        if int(days) in (0, 1):
+            cutoff_time = datetime.today()
+        else:
+            cutoff_time = datetime.today() - timedelta(days=int(days))
+    except ValueError as e:
+        write_stderr(repr(e))
+        raise e
+
+    file_timestamp = os.stat(path).st_mtime
+    file_time = datetime.fromtimestamp(file_timestamp)
+
+    if file_time < cutoff_time:
+        return True
+    return False
+
+
+def write_stderr(msg: str) -> None:
+    """
+    Write msg to stderr
+    :param msg:
+    :return: None
+    """
+
+    obj = datetime.now(dttz.utc)
+    dt = obj.astimezone(pytz.timezone(os.getenv("LOG_TIMEZONE", "UTC")))
+    dt_timezone = dt.strftime("%Y-%m-%dT%H:%M:%S.%f:%z")
+    sys.stderr.write(f"[{dt_timezone}]:[ERROR]:{msg}\n")
+
+
+def get_level(level: str) -> logging:
+    """
+    Get logging level
+    :param level:
+    :return: level
+    """
+
+    if not isinstance(level, str):
+        write_stderr(f"Unable to get log level. Setting default level to: 'INFO' ({logging.INFO})")
+        return logging.INFO
+
+    match level.lower():
+        case "debug":
+            return logging.DEBUG
+        case "warning" | "warn":
+            return logging.WARNING
+        case "error":
+            return logging.ERROR
+        case "critical" | "crit":
+            return logging.CRITICAL
+        case _:
+            return logging.INFO
+
+
+def get_log_path(directory: str, filename: str) -> str:
+    """
+    Get log file path
+    :param directory:
+    :param filename:
+    :return: path as str
+    """
+
+    log_file_path = str(os.path.join(directory, filename))
+    err_message = f"Unable to open log file for writing | {log_file_path}"
+
+    try:
+        open(log_file_path, "a+").close()
+    except PermissionError as e:
+        write_stderr(f"{err_message} | {repr(e)}")
+        raise PermissionError(err_message)
+    except FileNotFoundError as e:
+        write_stderr(f"{err_message} | {repr(e)}")
+        raise FileNotFoundError(err_message)
+    except OSError as e:
+        write_stderr(f"{err_message} | {repr(e)}")
+        raise e
+
+    return log_file_path
+
+
+def get_format(show_location: bool, name: str, timezone: str) -> str:
+    _debug_fmt = ""
+    _logger_name = ""
+
+    if name:
+        _logger_name = f"[{name}]:"
+
+    if show_location:
+        _debug_fmt = "[%(filename)s:%(funcName)s:%(lineno)d]:"
+
+    if timezone == "localtime":
+        utc_offset = time.strftime("%z")
+    else:
+        utc_offset = datetime.now(pytz.timezone(timezone)).strftime("%z")
+
+    fmt = f"[%(asctime)s.%(msecs)03d{utc_offset}]:[%(levelname)s]:{_logger_name}{_debug_fmt}%(message)s"
+    return fmt
+
+
+def gzip_file_with_sufix(file_path, sufix) -> str | None:
+    """
+    gzip file
+    :param file_path:
+    :param sufix:
+    :return: bool
+    """
+
+    if os.path.isfile(file_path):
+        sfname, sext = os.path.splitext(file_path)
+        renamed_dst = f"{sfname}_{sufix}{sext}.gz"
+
+        try:
+            with open(file_path, "rb") as fin:
+                with gzip.open(renamed_dst, "wb") as fout:
+                    fout.writelines(fin)
+        except Exception as e:
+            write_stderr(f"Unable to gzip log file | {file_path} | {repr(e)}")
+            raise e
+
+        try:
+            delete_file(file_path)
+        except OSError as e:
+            write_stderr(f"Unable to delete source log file | {file_path} | {repr(e)}")
+            raise e
+
+        return renamed_dst
+
+
+def get_timezone_function(
+    time_zone: str,
+) -> Callable[[float | None, Any], struct_time] | Callable[[Any], struct_time]:
+
+    match time_zone.lower():
+        case "utc":
+            return time.gmtime
+        case "localtime":
+            return time.localtime
+        case _:
+            return lambda *args: datetime.now(tz=pytz.timezone(time_zone)).timetuple()

pythonLogs/settings.py

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+from enum import Enum
+from dotenv import load_dotenv
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+
+
+class LogLevel(str, Enum):
+    """log levels"""
+
+    CRITICAL = "CRITICAL"
+    CRIT = "CRIT"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    WARN = "WARN"
+    INFO = "INFO"
+    DEBUG = "DEBUG"
+
+
+class LogSettings(BaseSettings):
+    """If any ENV variable is omitted, it falls back to default values here"""
+
+    load_dotenv()
+
+    level: Optional[LogLevel] = Field(default=LogLevel.INFO)
+    appname: Optional[str] = Field(default="app")
+    directory: Optional[str] = Field(default="/app/logs")
+    filename: Optional[str] = Field(default="app.log")
+    encoding: Optional[str] = Field(default="UTF-8")
+    date_format: Optional[str] = Field(default="%Y-%m-%dT%H:%M:%S")
+    days_to_keep: Optional[int] = Field(default=30)
+    timezone: Optional[str] = Field(default="UTC")
+    stream_handler: Optional[bool] = Field(default=True)
+    show_location: Optional[bool] = Field(default=False)
+
+    # SizeRotatingLog
+    max_file_size_mb: Optional[int] = Field(default=10)
+
+    # TimedRotatingLog
+    rotate_when: Optional[str] = Field(default="midnight")
+    rotate_at_utc: Optional[bool] = Field(default=True)
+    rotate_file_sufix: Optional[str] = Field(default="%Y%m%d")
+
+    model_config = SettingsConfigDict(env_prefix="LOG_", env_file=".env", extra="allow")

pythonLogs/size_rotating.py

@@ -0,0 +1,105 @@
+# -*- encoding: utf-8 -*-
+import logging.handlers
+import os
+from typing import Optional
+from pythonLogs.log_utils import (
+    check_directory_permissions,
+    check_filename_instance,
+    get_level,
+    get_log_path,
+    get_logger_and_formatter,
+    get_stream_handler,
+    gzip_file_with_sufix,
+    list_files,
+    remove_old_logs,
+    write_stderr,
+)
+from pythonLogs.settings import LogSettings
+
+
+class SizeRotatingLog:
+    def __init__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        directory: Optional[str] = None,
+        filenames: Optional[list | tuple] = None,
+        maxmbytes: Optional[int] = None,
+        daystokeep: Optional[int] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        streamhandler: Optional[bool] = None,
+        showlocation: Optional[bool] = None,
+    ):
+        _settings = LogSettings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.directory = directory or _settings.directory
+        self.filenames = filenames or (_settings.filename,)
+        self.maxmbytes = maxmbytes or _settings.max_file_size_mb
+        self.daystokeep = daystokeep or _settings.days_to_keep
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.streamhandler = streamhandler or _settings.stream_handler
+        self.showlocation = showlocation or _settings.show_location
+
+    def init(self):
+        check_filename_instance(self.filenames)
+        check_directory_permissions(self.directory)
+
+        logger, formatter = get_logger_and_formatter(self.appname, self.datefmt, self.showlocation, self.timezone)
+        logger.setLevel(self.level)
+
+        for file in self.filenames:
+            log_file_path = get_log_path(self.directory, file)
+
+            file_handler = logging.handlers.RotatingFileHandler(
+                filename=log_file_path,
+                mode="a",
+                maxBytes=self.maxmbytes * 1024 * 1024,
+                backupCount=self.daystokeep,
+                encoding=self.encoding,
+                delay=False,
+                errors=None,
+            )
+            file_handler.rotator = GZipRotatorSize(self.directory, self.daystokeep)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(self.level)
+            logger.addHandler(file_handler)
+
+        if self.streamhandler:
+            stream_hdlr = get_stream_handler(self.level, formatter)
+            logger.addHandler(stream_hdlr)
+
+        return logger
+
+
+class GZipRotatorSize:
+    def __init__(self, dir_logs: str, daystokeep: int):
+        self.directory = dir_logs
+        self.daystokeep = daystokeep
+
+    def __call__(self, source: str, dest: str) -> None:
+        remove_old_logs(self.directory, self.daystokeep)
+        if os.path.isfile(source) and os.stat(source).st_size > 0:
+            source_filename, _ = os.path.basename(source).split(".")
+            new_file_number = self._get_new_file_number(self.directory, source_filename)
+            if os.path.isfile(source):
+                gzip_file_with_sufix(source, new_file_number)
+
+    @staticmethod
+    def _get_new_file_number(directory, source_filename):
+        new_file_number = 1
+        previous_gz_files = list_files(directory, ends_with=".gz")
+        for gz_file in previous_gz_files:
+            if source_filename in gz_file:
+                try:
+                    oldest_file_name = gz_file.split(".")[0].split("_")
+                    if len(oldest_file_name) > 1:
+                        new_file_number = int(oldest_file_name[1]) + 1
+                except ValueError as e:
+                    write_stderr(f"Unable to get previous gz log file number | {gz_file} | {repr(e)}")
+                    raise
+        return new_file_number

pythonLogs/timed_rotating.py

@@ -0,0 +1,94 @@
+# -*- encoding: utf-8 -*-
+import logging.handlers
+import os
+from typing import Optional
+from pythonLogs.log_utils import (
+    check_directory_permissions,
+    check_filename_instance,
+    get_level,
+    get_log_path,
+    get_logger_and_formatter,
+    get_stream_handler,
+    gzip_file_with_sufix,
+    remove_old_logs,
+)
+from pythonLogs.settings import LogSettings
+
+
+class TimedRotatingLog:
+    """
+    Current 'rotating_when' events supported for TimedRotatingLogs:
+        midnight - roll over at midnight
+        W{0-6} - roll over on a certain day; 0 - Monday
+    """
+
+    def __init__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        directory: Optional[str] = None,
+        filenames: Optional[list | tuple] = None,
+        when: Optional[str] = None,
+        sufix: Optional[str] = None,
+        daystokeep: Optional[int] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        streamhandler: Optional[bool] = None,
+        showlocation: Optional[bool] = None,
+        rotateatutc: Optional[bool] = None,
+    ):
+        _settings = LogSettings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.directory = directory or _settings.directory
+        self.filenames = filenames or (_settings.filename,)
+        self.when = when or _settings.rotate_when
+        self.sufix = sufix or _settings.rotate_file_sufix
+        self.daystokeep = daystokeep or _settings.days_to_keep
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.streamhandler = streamhandler or _settings.stream_handler
+        self.showlocation = showlocation or _settings.show_location
+        self.rotateatutc = rotateatutc or _settings.rotate_at_utc
+
+    def init(self):
+        check_filename_instance(self.filenames)
+        check_directory_permissions(self.directory)
+
+        logger, formatter = get_logger_and_formatter(self.appname, self.datefmt, self.showlocation, self.timezone)
+        logger.setLevel(self.level)
+
+        for file in self.filenames:
+            log_file_path = get_log_path(self.directory, file)
+
+            file_handler = logging.handlers.TimedRotatingFileHandler(
+                filename=log_file_path,
+                encoding=self.encoding,
+                when=self.when,
+                utc=self.rotateatutc,
+                backupCount=self.daystokeep,
+            )
+            file_handler.suffix = self.sufix
+            file_handler.rotator = GZipRotatorTimed(self.directory, self.daystokeep)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(self.level)
+            logger.addHandler(file_handler)
+
+        if self.streamhandler:
+            stream_hdlr = get_stream_handler(self.level, formatter)
+            logger.addHandler(stream_hdlr)
+
+        return logger
+
+
+class GZipRotatorTimed:
+    def __init__(self, dir_logs: str, days_to_keep: int):
+        self.dir = dir_logs
+        self.days_to_keep = days_to_keep
+
+    def __call__(self, source: str, dest: str) -> None:
+        remove_old_logs(self.dir, self.days_to_keep)
+        sufix = os.path.splitext(dest)[1].replace(".", "")
+        gzip_file_with_sufix(source, sufix)

pythonlogs-3.0.12.dist-info/LICENSE

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

pythonlogs-3.0.12.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.1
+Name: pythonLogs
+Version: 3.0.12
+Summary: Easy logs with rotations
+Home-page: https://pypi.org/project/pythonLogs
+License: MIT
+Keywords: python3,python-3,python,log,logging,logger,logutils,log-utils,pythonLogs
+Author: Daniel Costa
+Author-email: danieldcsta@gmail.com
+Maintainer: Daniel Costa
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+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
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: pydantic-settings (>=2.7.1,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: pytz (>=2024.2,<2025.0)
+Project-URL: Repository, https://github.com/ddc/pythonLogs
+Description-Content-Type: text/markdown
+
+# Easy logs with rotations
+
+[![Donate](https://img.shields.io/badge/Donate-PayPal-brightgreen.svg?style=plastic)](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)
+[![License](https://img.shields.io/pypi/l/pythonLogs)](https://github.com/ddc/pythonLogs/blob/main/LICENSE)
+[![PyPi](https://img.shields.io/pypi/v/pythonLogs.svg)](https://pypi.python.org/pypi/pythonLogs)
+[![PyPI Downloads](https://static.pepy.tech/badge/pythonLogs)](https://pepy.tech/projects/pythonLogs)
+[![codecov](https://codecov.io/gh/ddc/pythonLogs/graph/badge.svg?token=QsjwsmYzgD)](https://codecov.io/gh/ddc/pythonLogs)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Build Status](https://img.shields.io/endpoint.svg?url=https%3A//actions-badge.atrox.dev/ddc/pythonLogs/badge?ref=main&label=build&logo=none)](https://actions-badge.atrox.dev/ddc/pythonLogs/goto?ref=main)
+[![Python](https://img.shields.io/pypi/pyversions/pythonLogs.svg)](https://www.python.org)
+
+
+
+# Logs
++ Parameters for all classes are declared as OPTIONAL 
++ If any [.env](./pythonLogs/.env.example) variable is omitted, it falls back to default values here: [settings.py](pythonLogs/settings.py)
++ Function arguments will overwrite any env variable
++ Timezone parameter can also accept `localtime`, default to `UTC`
+  + This parameter is only to display the timezone datetime inside the log file
+  + For timed rotation, only UTC and localtime are supported, meaning it will rotate at UTC or localtime
+    + env variable to change between UTC and localtime is `LOG_ROTATE_AT_UTC` and default to True
++ Streamhandler parameter will add stream handler along with file handler
++ Showlocation parameter will show the filename and the line number where the message originated
+
+
+
+
+# Install
+```shell
+pip install pythonLogs
+```
+
+
+
+# BasicLog
++ Setup Logging
+     + This is just a basic log, it does not use any file
+```python
+from pythonLogs import BasicLog
+logger = BasicLog(
+    level="debug",
+    name="app",
+    timezone="America/Sao_Paulo",
+    showlocation=False,
+).init()
+logger.warning("This is a warning example")
+```
+#### Example of output
+`[2024-10-08T19:08:56.918-0300]:[WARNING]:[app]:This is a warning example`
+
+
+
+
+
+# SizeRotatingLog
++ Setup Logging
+    + Logs will rotate based on the file size using the `maxmbytes` variable
+    + Rotated logs will have a sequence number starting from 1: `app.log_1.gz, app.log_2.gz`
+    + Logs will be deleted based on the `daystokeep` variable, defaults to 30
+```python
+from pythonLogs import SizeRotatingLog
+logger = SizeRotatingLog(
+    level="debug",
+    name="app",
+    directory="/app/logs",
+    filenames=["main.log", "app1.log"],
+    maxmbytes=5,
+    daystokeep=7,
+    timezone="America/Chicago",
+    streamhandler=True,
+    showlocation=False
+).init()
+logger.warning("This is a warning example")
+```
+#### Example of output
+`[2024-10-08T19:08:56.918-0500]:[WARNING]:[app]:This is a warning example`
+
+
+
+
+
+# TimedRotatingLog
++ Setup Logging
+    + Logs will rotate based on `when` variable to a `.gz` file, defaults to `midnight`
+    + Rotated log will have the sufix variable on its name: `app_20240816.log.gz`
+    + Logs will be deleted based on the `daystokeep` variable, defaults to 30
+    + Current 'when' events supported:
+        + midnight — roll over at midnight
+        + W{0-6} - roll over on a certain day; 0 - Monday
+```python
+from pythonLogs import TimedRotatingLog
+logger = TimedRotatingLog(
+    level="debug",
+    name="app",
+    directory="/app/logs",
+    filenames=["main.log", "app2.log"],
+    when="midnight",
+    daystokeep=7,
+    timezone="UTC",
+    streamhandler=True,
+    showlocation=False
+).init()
+logger.warning("This is a warning example")
+```
+#### Example of output
+`[2024-10-08T19:08:56.918-0000]:[WARNING]:[app]:This is a warning example`
+
+
+
+
+
+## Env Variables (Optional)
+```
+LOG_LEVEL=DEBUG
+LOG_TIMEZONE=America/Chicago
+LOG_ENCODING=UTF-8
+LOG_APPNAME=app
+LOG_FILENAME=app.log
+LOG_DIRECTORY=/app/logs
+LOG_DAYS_TO_KEEP=30
+LOG_STREAM_HANDLER=True
+LOG_SHOW_LOCATION=False
+LOG_DATE_FORMAT=%Y-%m-%dT%H:%M:%S
+
+# SizeRotatingLog
+LOG_MAX_FILE_SIZE_MB=10
+
+# TimedRotatingLog
+LOG_ROTATE_WHEN=midnight
+LOG_ROTATE_AT_UTC=True
+```
+
+
+
+
+# Source Code
+### Build
+```shell
+poetry build -f wheel
+```
+
+
+
+# Run Tests and Get Coverage Report using Poe
+```shell
+poetry update --with test
+poe tests
+```
+
+
+
+# License
+Released under the [MIT License](LICENSE)
+
+
+
+
+# Buy me a cup of coffee
++ [GitHub Sponsor](https://github.com/sponsors/ddc)
++ [ko-fi](https://ko-fi.com/ddcsta)
++ [Paypal](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)
+

pythonlogs-3.0.12.dist-info/RECORD

@@ -0,0 +1,11 @@
+pythonLogs/.env.example,sha256=PKCAXeBtgyXXJgr96grR4Uyql87-59mUw0KXkf_dCGY,326
+pythonLogs/__init__.py,sha256=6LJlbq-Mw0gDgGbtZUMOYkjLqPk1vN7n4hCOAMyDHRo,1301
+pythonLogs/basic_log.py,sha256=f41CdpK7BSolxXCcSgecHCqIzymFUAXYKA7dSTulyvw,1229
+pythonLogs/log_utils.py,sha256=UDkYgqHK0v7EzZudWa3sslcLF9eYPoZ9ZfMZVZVt9fw,7413
+pythonLogs/settings.py,sha256=k9DrTfNaDcnGfG8k-czkGtuBKe7SxQjziABaGzB9GT0,1459
+pythonLogs/size_rotating.py,sha256=kf1Za1OSyxN9Bge81dNF620WtaiG2g9moqTIiRkI_Yk,3980
+pythonLogs/timed_rotating.py,sha256=4SHTsWrPM7yiqIJVM9PPf67N1aJlWhCunwGz3ygWD-w,3399
+pythonlogs-3.0.12.dist-info/LICENSE,sha256=3fEBeO1ARuqTVV1QJzrGVVmXZz_okGweH0a-MeA0Qpc,1068
+pythonlogs-3.0.12.dist-info/METADATA,sha256=VvJX2ZFRatoMdGMW7FOxX7X-ZMICuHRHbe0qi8h_tbo,5849
+pythonlogs-3.0.12.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pythonlogs-3.0.12.dist-info/RECORD,,

pythonlogs-3.0.12.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any