inspy-logger 3.0.3__tar.gz → 3.1.0.dev1__tar.gz

{inspy_logger-3.0.3 → inspy_logger-3.1.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: inspy-logger
-Version: 3.0.3
+Version: 3.1.0.dev1
 Summary: Colorable, scalable logger for CLI
 Home-page: https://github.com/Inspyre-Softworks/inSPy-Logger
 License: MIT
@@ -26,11 +26,13 @@ Classifier: Topic :: System :: Logging
 Classifier: Topic :: Utilities
 Requires-Dist: appdirs (>=1.4.4,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
-Requires-Dist: colorlog (>=6.7,<7.0)
+Requires-Dist: colorlog (>=6.8.2,<7.0.0)
 Requires-Dist: humanize (>=4.4.0,<5.0.0)
-Requires-Dist: luddite (>=1.0.1,<2.0.0)
-Requires-Dist: packaging (>=21.0,<22.0)
-Requires-Dist: python-box (>=6.1.0,<7.0.0)
+Requires-Dist: luddite (>=1.0.4,<2.0.0)
+Requires-Dist: packaging (>=24.0,<25.0)
+Requires-Dist: platformdirs (>=4.2.0,<5.0.0)
+Requires-Dist: pypattyrn (>=1.2,<2.0)
+Requires-Dist: python-box (>=7.1.1,<8.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: rich (>=13.7.0,<14.0.0)
 Requires-Dist: setuptools-autover (>=1.0.2,<2.0.0)

{inspy_logger-3.0.3 → inspy_logger-3.1.0.dev1}/inspy_logger/Scripts/main.py

@@ -16,6 +16,8 @@ from argparse import ArgumentParser
 from inspy_logger.helpers.debug.environment import fetch_system_info
 from inspy_logger.version import parse_version, PyPiVersionInfo
 
+
+
 # ---- SET UP PARSER --------------------------------
 
 parser = ArgumentParser('inspy-logger-version', description='Displays version information for inspy-logger.')
@@ -37,7 +39,7 @@ update_parser.add_argument('-p', '--pre-release', action='store_true', help='Whe
 debug_parser = subparsers.add_parser('debug', help='Fetches a collection of  environment information to help debug inspy-logger.')
 
 debug_parser.add_argument('-C', '--copy-to-clipboard', action='store_true', help='Copies the debug information to the clipboard.')
-debug_parser.add_argument('-P', '--print', action='store_true', help='Prints the debug information to the console.', default=True)
+debug_parser.add_argument('-P', '--print', action='store_true', help='Prints the debug information to the console.')
 
 # ---- FORMAT FLAGS --------------------------------
 
@@ -60,39 +62,35 @@ else:
     INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK = False
 
 
+def debug(args = parsed_args):
+    if args.markdown:
+        fmt = 'markdown'
+    elif args.json:
+        fmt = 'json'
+    else:
+        fmt = 'text'
+
+    fetch_system_info(copy_to_clipboard=args.copy_to_clipboard, format_type=fmt, print_to_console=args.print)
+
+
+
 def main():
 
-    version = PyPiVersionInfo()
+    version = PyPiVersionInfo(INCLUDE_PRE_RELEASE_FOR_UPDATE_CHECK)
 
     ACTIONS = {
         'default': version.print_version_info,
         'update': version.update,
-        'debug': fetch_system_info,
+        'debug': debug,
 
     }
 
     if parsed_args.subcommand is None:
         parsed_args.subcommand = 'default'
 
-    if parsed_args.subcommand == 'debug':
-
-        if (
-            parsed_args.markdown
-            or not parsed_args.json
-            and not parsed_args.text
-        ):
-            fmt = 'markdown'
-        elif parsed_args.json:
-            fmt = 'json'
-        else:
-            fmt = 'text'
-
-        fetch_system_info(copy_to_clipboard=parsed_args.copy_to_clipboard, format_type=fmt, print_to_console=parsed_args.print)
-
-
-
+    # Run the action.
+    ACTIONS[parsed_args.subcommand]()
 
-    return parsed_args
 
 if __name__ == '__main__':
     main()

{inspy_logger-3.0.3 → inspy_logger-3.1.0.dev1}/inspy_logger/__about__.py

@@ -11,7 +11,6 @@ Since:
     v2.1.1
 
 """
-from typing import List, Tuple
 
 from inspy_logger.version import parse_version
 

inspy_logger-3.1.0.dev1/inspy_logger/__init__.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import contextlib
+import sys
+import inspect
+import logging
+from pypattyrn.behavioral.null import Null
+from inspy_logger.common import PROG_NAME as ISL_PROG_NAME, DEFAULT_LOGGING_LEVEL, DEFAULT_LOG_FILE_PATH, LEVELS
+from inspy_logger.helpers import find_variable_in_call_stack, check_preemptive_level_set, find_argument_parser, determine_start_block, determine_level
+
+from inspy_logger.helpers import (
+    translate_to_logging_level,
+    clean_module_name,
+    CustomFormatter,
+    determine_client_prog_name,
+    determine_log_file_path
+)
+
+# Existing log record factory
+old_factory = logging.getLogRecordFactory()
+
+
+def record_factory(*args, **kwargs):
+    record = old_factory(*args, **kwargs)
+    # Set the file_name attribute to the name of the file where the log is called
+    frame = inspect.stack()[1]
+    record.file_name = frame.filename
+    return record
+
+
+logging.setLogRecordFactory(record_factory)
+
+
+from inspy_logger.engine import Logger
+
+__all__ = [
+    "clean_module_name",
+    "CustomFormatter",
+    "DEFAULT_LOGGING_LEVEL",
+    "determine_level",
+    "InspyLogger",
+    "LOG_DEVICE",
+    "Logger",
+    "ISL_PROG_NAME",
+    "translate_to_logging_level",
+]
+
+BLOCKED = determine_start_block()
+
+LOG_FILE = determine_log_file_path()
+
+LOG_DEVICE = None if BLOCKED else Logger(ISL_PROG_NAME)
+
+MODULE_OBJ = sys.modules[__name__]
+
+CLIENT_PROG_NAME = determine_client_prog_name()
+
+INIT_LOG_LEVEL = determine_level(CLIENT_PROG_NAME)
+
+
+def start_logger(override_block=True):
+    """
+    Starts the logger.
+
+    Parameters:
+        override_block (Union[bool, None], optional):
+            A flag to override the block on the logger. Defaults to True.
+
+    Note:
+        You only need to run this function if you have blocked the logger from starting automatically.
+
+    Returns:
+
+    """
+    global LOG_DEVICE
+    global CLIENT_PROG_NAME
+    global INIT_LOG_LEVEL
+
+    if not BLOCKED or override_block:
+        LOG_DEVICE = Logger(ISL_PROG_NAME)
+        LOG_DEVICE.set_level(INIT_LOG_LEVEL)
+
+        if CLIENT_PROG_NAME:
+
+            prog_logger = Logger(
+                CLIENT_PROG_NAME,
+                LOG_DEVICE.console_level,
+                LOG_DEVICE.file_level,
+                file_name=DEFAULT_LOG_FILE_PATH.name,
+                file_path=DEFAULT_LOG_FILE_PATH.parent
+            )
+            __all__.append('PROG_LOGGER')
+
+        LOG_DEVICE.replay_and_setup_handlers()
+    elif CLIENT_PROG_NAME:
+        prog_logger = Null()
+
+    with contextlib.suppress(NameError):
+        global PROG_LOGGER
+
+        PROG_LOGGER = prog_logger
+
+        if isinstance(PROG_LOGGER, Null):
+            from rich import print
+            print("The logger has been blocked from starting. To start the logger, run `start_logger()`.")
+        
+
+InspyLogger = Logger
+
+
+def _get_loggable():
+    from inspy_logger.helpers.base_classes import Loggable
+    import bisect
+    # Add the `Loggable` class to `__all__` in alphabetical order.
+    bisect.insort(__all__, 'Loggable')
+
+    return Loggable
+
+
+Loggable = _get_loggable()
+
+
+start_logger(override_block=False)
+
+
+deprecation_warning_deliveries = 0
+
+
+def getLogger(*args, **kwargs):
+    global deprecation_warning_deliveries
+
+    if deprecation_warning_deliveries < 5:
+        LOG_DEVICE.warning('The `getLogger` function is deprecated. Use `InspyLogger` instead.')
+        deprecation_warning_deliveries += 1
+
+    return InspyLogger(*args, **kwargs)

inspy_logger-3.1.0.dev1/inspy_logger/common/__init__.py

@@ -0,0 +1,78 @@
+"""
+Defines the logging configuration and constants used within the inSPy-Logger project. It includes the mapping of log
+levels, default settings, and the `InspyLogger` class which is a central part of the logging framework.
+
+Constants:
+    PROG_NAME (str):
+        The program name, imported from the project's `__about__` module.
+
+    PROG_VERSION (str):
+        The program version, imported from the project's `__about__` module.
+
+    LEVEL_MAP (dict):
+        A dictionary mapping string representations of logging levels to their corresponding logging module constants.
+
+    LEVELS (list):
+        A list of available logging levels derived from `LEVEL_MAP`.
+
+    DEFAULT_LOGGING_LEVEL (logging level):
+        The default logging level used throughout the project.
+
+    DEFAULT_LOG_FILE_PATH (path):
+        The default path where log files are stored, defined in `inspy_logger.common.dirs`.
+
+Classes:
+    InspyLogger:
+        A placeholder for the logging class used in the inSPy-Logger project.
+
+Dependencies:
+    - logging:
+        Used to define the logging levels and to be used in the `InspyLogger` class for actual logging.
+
+    - inspy_logger.__about__:
+        Provides metadata like program name and version, which are used in logging for contextual information.
+
+    - inspy_logger.common.dirs:
+        Provides common directory paths used in the logger, including the default log file path.
+
+Example Usage:
+    # This example shows how to access and use the constants defined in this module
+    >>> from inspy_logger.common.logging_config import DEFAULT_LOGGING_LEVEL, LEVEL_MAP
+    >>> print(DEFAULT_LOGGING_LEVEL)
+    DEBUG
+    >>> print(LEVEL_MAP['error'])
+    40
+
+    # Example of how `InspyLogger` might be used in the future (assuming further implementation)
+    >>> logger = InspyLogger()
+    >>> logger.log(level='error', message='This is an error message')
+
+"""
+
+import logging
+
+from inspy_logger.__about__ import __PROG__ as PROG_NAME, __VERSION__ as PROG_VERSION
+from inspy_logger.config.dirs import DEFAULT_LOG_FILE_PATH
+from inspy_logger.constants import LEVEL_MAP
+
+__all__ = [
+    "PROG_NAME",
+    "PROG_VERSION",
+    "LEVEL_MAP",
+    "LEVELS",
+    "DEFAULT_LOGGING_LEVEL",
+    "DEFAULT_LOG_FILE_PATH",
+    "InspyLogger"
+]
+
+
+LEVELS = list(LEVEL_MAP.values())
+"""The list of level names."""
+
+
+DEFAULT_LOGGING_LEVEL = logging.DEBUG
+"""The default logging level."""
+
+
+class InspyLogger:
+    pass

{inspy_logger-3.0.3 → inspy_logger-3.1.0.dev1}/inspy_logger/common/meta.py

@@ -1,10 +1,15 @@
 __all__ = [
+    'SOFTWARE_ORG',
+    'SOFTWARE_ORG_URL',
     'AUTHORS',
+    'PROG_NAME',
     'RELEASE_MAP',
     'URLS',
     'VERSION'
 ]
 
+PROG_NAME = 'inSPy-Logger'
+
 URLS = dict(
     developer_url='https://inspyre.tech',
     docs_url='https://inspyre-toolbox.readthedocs.io/en/latest',
@@ -19,6 +24,8 @@ AUTHORS = [
 ]
 """The authors of the project."""
 
+SOFTWARE_ORG, SOFTWARE_ORG_URL = AUTHORS[0]
+
 RELEASE_MAP = {
     'dev': 'Development Build',
     'alpha': 'Alpha Build',

inspy_logger-3.1.0.dev1/inspy_logger/config/__init__.py

@@ -0,0 +1,18 @@
+"""
+
+
+Author: 
+    Inspyre Softworks
+
+Project:
+    inSPy-Logger
+
+File: 
+    inspy_logger/config/__init__.py
+ 
+
+Description:
+    
+
+"""
+from inspy_logger.config.dirs import DEFAULT_LOG_FILE_PATH

inspy_logger-3.1.0.dev1/inspy_logger/config/dirs.py

@@ -0,0 +1,134 @@
+from platformdirs import user_log_path
+from pathlib import Path
+from inspy_logger.common.meta import *
+from inspy_logger.helpers import (
+    find_valid_vars_in_call_stack,
+    VALID_LOG_FILE_VARS,
+    VALID_PROG_NAME_VARS,
+    determine_log_file_path,
+    determine_client_prog_name,
+    VALID_DEV_NAME_VARS
+)
+
+from typing import Optional, Union
+
+
+INSPY_LOGGER_LOG_DIR_PATH = user_log_path(
+    appname=PROG_NAME or find_valid_vars_in_call_stack(VALID_PROG_NAME_VARS),
+    appauthor=SOFTWARE_ORG,
+    ensure_exists=True
+)
+
+INSPY_LOGGER_LOG_FILE_NAME = 'app.log'
+
+INSPY_LOGGER_LOG_FILE_PATH = INSPY_LOGGER_LOG_DIR_PATH.joinpath(INSPY_LOGGER_LOG_FILE_NAME)
+
+
+# def get_log_file_path(
+#         log_file_path: Union[str, Path] = None,
+#         prog_name: str = None,
+#         dev_name: str = None
+# ) -> Path:
+#     """
+#     Get the path to the log file.
+#
+#     Parameters:
+#         log_file_path (str, Path, optional):
+#                The path to the log file.
+#
+#         prog_name (str):
+#             The name of the program to be logged.
+#
+#         dev_name (str):
+#             The name of the developer of the app to be logged.
+#
+#     Note:
+#         The `log_file_name` is simply the name of the file to be logged to, not the full path.
+#
+#     Returns:
+#         Path:
+#             The path to the log file.
+#     """
+#     print(f'Found log-file path: {FOUND_LOG_FILE_VARS}')
+#     log_file_path = log_file_path or FOUND_LOG_FILE_VARS
+#     log_file_path = Path(log_file_path) if log_file_path else None
+#
+#     if not log_file_path:
+#         if not prog_name:
+#             prog_name = determine_client_prog_name()
+#             print(f'Found prog-name: {prog_name}')
+#         if prog_name and not dev_name:
+#             dev_name = find_valid_vars_in_call_stack(VALID_DEV_NAME_VARS.valid_vars)
+#
+#             if dev_name:
+#                 print(f'Found dev-name: {dev_name}')
+#
+#
+#
+#
+#     #if not log_file_path.suffix and log_file_path.is_dir() and INSPY_LOGGER_LOG_FILE_NAME:
+#     #    log_file_path = log_file_path.joinpath(INSPY_LOGGER_LOG_FILE_NAME)
+#
+#     if all(arg is None for arg in [
+#         log_file_path,
+#         prog_name,
+#         dev_name
+#     ]):
+#         return INSPY_LOGGER_LOG_FILE_PATH
+#
+#     return log_file_path
+
+
+def get_log_file_path(
+        log_file_path: Union[str, Path] = None,
+        prog_name: str = None,
+        dev_name: str = None
+) -> Path:
+    """
+    Get the path to the log file.
+
+    Parameters:
+        log_file_path (str, Path, optional):
+               The path to the log file.
+
+        prog_name (str):
+            The name of the program to be logged.
+
+        dev_name (str):
+            The name of the developer of the app to be logged.
+
+    Note:
+        The `log_file_name` is simply the name of the file to be logged to, not the full path.
+
+    Returns:
+        Path:
+            The path to the log file.
+    """
+    log_file_path = Path(log_file_path) if isinstance(log_file_path, str) else log_file_path
+
+    if log_file_path:
+        return log_file_path
+
+    log_file_path = find_valid_vars_in_call_stack(VALID_LOG_FILE_VARS)
+
+    if log_file_path:
+        log_file_path = Path(log_file_path)
+        return log_file_path
+
+    if not prog_name:
+        prog_name = determine_client_prog_name()
+
+    if not dev_name and prog_name:
+        dev_name = find_valid_vars_in_call_stack(VALID_DEV_NAME_VARS.valid_vars)
+
+    if prog_name:
+        file_name = f"{prog_name}.log"
+        if dev_name:
+            log_file_path = Path(user_log_path(appname=prog_name, appauthor=dev_name, ensure_exists=True)).joinpath(file_name)
+        else:
+            log_file_path = INSPY_LOGGER_LOG_DIR_PATH.joinpath(file_name)
+
+    return log_file_path or INSPY_LOGGER_LOG_FILE_PATH
+
+
+DEFAULT_LOG_FILE_PATH = get_log_file_path()

inspy_logger-3.1.0.dev1/inspy_logger/config/levels.py

@@ -0,0 +1,29 @@
+"""
+
+
+Author: 
+    Inspyre Softworks
+
+Project:
+    inSPy-Logger
+
+File: 
+    inspy_logger/config/levels.py
+ 
+
+Description:
+    
+
+"""
+import logging
+
+
+LEVEL_MAP = {
+    'debug': logging.DEBUG,
+    'info': logging.INFO,
+    'warning': logging.WARNING,
+    'error': logging.ERROR,
+    'critical': logging.CRITICAL,
+    'fatal': logging.FATAL,
+}
+"""A mapping of level names to their corresponding logging levels."""

inspy_logger-3.1.0.dev1/inspy_logger/constants.py

@@ -0,0 +1,30 @@
+"""
+
+
+Author: 
+    Inspyre Softworks
+
+Project:
+    inSPy-Logger
+
+File: 
+    inspy_logger/constants.py
+ 
+
+Description:
+    
+
+"""
+import logging
+
+DEFAULT_LOGGING_LEVEL = logging.DEBUG
+
+LEVEL_MAP = {
+    'debug': logging.DEBUG,
+    'info': logging.INFO,
+    'warning': logging.WARNING,
+    'error': logging.ERROR,
+    'critical': logging.CRITICAL,
+    'fatal': logging.FATAL,
+}
+"""A mapping of level names to their corresponding logging levels."""