inspy-logger 3.0.dev2__tar.gz → 3.0.dev4__tar.gz

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 2.1
 Name: inspy-logger
-Version: 3.0.dev2
+Version: 3.0.dev4
 Summary: Colorable, scalable logger for CLI
 Home-page: https://github.com/Inspyre-Softworks/inSPy-Logger
 License: MIT
 Keywords: cli,color,logging,log,terminal,console,colorama,colorlog,rich
 Author: Taylor-Jayde Blackstone
 Author-email: tayjaybabee@gmail.com
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 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.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Logging
 Classifier: Topic :: Utilities

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/inspy_logger/Scripts/main.py

@@ -68,7 +68,7 @@ def get_version_info():
     table.add_row('Full Version Name', get_full_version_name())
 
     if pypi_info.update_available:
-        table.add_row('Update Available', f'[bold green]Yes[/bold green]')
+        table.add_row('Update Available', '[bold green]Yes[/bold green]')
         table.add_row('Latest Version', f'{pypi_info.new_version_available_num}')
 
     table.add_row('Python Executable Path', sys.executable)
@@ -80,10 +80,7 @@ def get_version_info():
 
 def main():
 
-    if parsed_args.subcommand == 'update':
-        return update()
-
-    return get_version_info()
+    return update() if parsed_args.subcommand == 'update' else get_version_info()
 
 
 

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/inspy_logger/__about__.py

@@ -11,9 +11,10 @@ Since:
     v2.1.1
 
 """
+from inspy_logger.version import parse_version
 
 __prog__ = 'inSPy-Logger'
-__version__ = '3.0-dev.1'
+__version__ = parse_version()
 __authors__ = [
         ('Inspyre-Softworks', 'https://inspyre.tech'),
         ('Taylor-Jayde Blackstone', '<t.blackstone@inspyre.tech')

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/inspy_logger/__init__.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import inspect
+import os
 import logging
 from rich.logging import RichHandler
 from inspy_logger.__about__ import __prog__ as PROG_NAME
@@ -38,11 +39,17 @@ class Logger:
     A Singleton class responsible for managing the logging mechanisms of the application.
     """
 
-    instances = {}
+    instances = {}  # A dictionary to hold instances of the Logger class.
 
     def __new__(cls, name, *args, **kwargs):
         """
         Creates or returns an existing instance of the Logger class for the provided name.
+
+        Args:
+            name (str): The name of the logger instance.
+
+        Returns:
+            Logger: An instance of the Logger class.
         """
 
         if name not in cls.instances:
@@ -52,15 +59,22 @@ class Logger:
         return cls.instances[name]
 
     def __init__(
-        self,
-        name,
-        console_level=DEFAULT_LOGGING_LEVEL,
-        file_level=logging.DEBUG,
-        filename="app.log",
-        parent=None,
+            self,
+            name,
+            console_level=DEFAULT_LOGGING_LEVEL,
+            file_level=logging.DEBUG,
+            filename="app.log",
+            parent=None,
     ):
         """
         Initializes a logger instance.
+
+        Args:
+            name (str): The name of the logger instance.
+            console_level (str, optional): The logging level for the console. Defaults to DEFAULT_LOGGING_LEVEL.
+            file_level (str, optional): The logging level for the file. Defaults to logging.DEBUG.
+            filename (str, optional): The name of the log file. Defaults to "app.log".
+            parent (Logger, optional): The parent logger instance. Defaults to None.
         """
 
         if not hasattr(self, "logger"):
@@ -91,10 +105,22 @@ class Logger:
 
     @property
     def device(self):
+        """
+        Returns the logger instance.
+
+        Returns:
+            Logger: The logger instance.
+        """
         return self.logger
 
     @property
     def name(self):
+        """
+        Returns the name of the logger instance.
+
+        Returns:
+            str: The name of the logger instance.
+        """
         return self.logger.name
 
     def set_up_console(self):
@@ -144,8 +170,7 @@ class Logger:
                 child.set_level(file_level=file_level)
 
     def get_child(self, name=None, console_level=None, file_level=None):
-        self.logger.debug("Getting child logger")
-        console_level = console_level or DEFAULT_LOGGING_LEVEL
+        console_level = console_level or self.__console_level
         caller_frame = inspect.stack()[1]
 
         if name is None:
@@ -159,7 +184,7 @@ class Logger:
             if child.logger.name == child_logger_name:
                 return child
 
-        child_logger = Logger(child_logger_name, console_level, file_level, parent=self)
+        child_logger = Logger(name=child_logger_name, console_level=console_level, file_level=file_level, parent=self)
         self.children.append(child_logger)
         return child_logger
 
@@ -180,6 +205,18 @@ class Logger:
         return self.parent
 
     def find_child_by_name(self, name: str, case_sensitive=True, exact_match=False):
+        """
+        Searches for a child logger by its name.
+
+        Args:
+            name (str): The name of the child logger to search for.
+            case_sensitive (bool, optional): Whether the search should be case sensitive. Defaults to True.
+            exact_match (bool, optional): Whether the search should only return exact matches. Defaults to False.
+
+        Returns:
+            list or Logger: If exact_match is True, returns the Logger instance if found, else returns an empty list.
+                            If exact_match is False, returns a list of Logger instances whose names contain the search term.
+        """
         self.logger.debug(f'Searching for child with name: {name}')
         results = []
 
@@ -195,6 +232,43 @@ class Logger:
 
         return results
 
+    def debug(self, message):
+            """
+            Logs a debug message.
+
+            Args:
+                message (str): The message to log.
+            """
+            self._log(logging.DEBUG, message, args=(), stacklevel=2)
+
+
+    def info(self, message):
+            """
+            Logs an info message.
+
+            Args:
+                message (str): The message to log.
+            """
+            self._log(logging.INFO, message, args=(), stacklevel=2)
+
+    def warning(self, message):
+        """
+        Logs a warning message.
+
+        Args:
+            message (str): The message to log.
+        """
+        self._log(logging.WARNING, message, args=(), stacklevel=2)
+
+    def error(self, message):
+        """
+        Logs an error message.
+
+        Args:
+            message (str): The message to log.
+        """
+        self._log(logging.ERROR, message, args=(), stacklevel=2)
+
     def __repr__(self):
         name = self.name
         hex_id = hex(id(self))
@@ -208,119 +282,58 @@ class Logger:
         if parent_part.endswith('|'):
             parent_part = str(parent_part[:-2])
 
-        return f'<Logger: {name} at {hex_id}{parent_part}>'
+        return f'<Logger: {name} w/ level {self.logger.level} at {hex_id}{parent_part}>'
 
+    @classmethod
+    def create_logger_for_caller(cls):
+        """
+        Creates a logger for the module that calls this method.
 
-found_level = find_variable_in_call_stack('INSPY_LOG_LEVEL', DEFAULT_LOGGING_LEVEL)
-
-
-LOG_DEVICE = Logger(PROG_NAME, found_level)
-MOD_LOG_DEVICE = LOG_DEVICE.get_child("log_engine", found_level)
-MOD_LOGGER = MOD_LOG_DEVICE.logger
-MOD_LOGGER.debug(f"Started logger for {__name__}.")
-
-add_child = LOG_DEVICE.get_child
-
-InspyLogger = Logger
-
-def _get_parent_logging_device():
-    """
-    Determines the parent logging device by inspecting the caller's log_device or parent_log_device attribute.
-
-    Returns:
-        Logger: The parent logging device.
-    """
-    MOD_LOGGER.debug("Determining parent logging device")
-    caller_frame = inspect.currentframe().f_back
-    caller_locals = caller_frame.f_locals
-
-    if "logger" in caller_locals:
-        return caller_locals["logger"]
-    elif "parent_log_device" in caller_locals:
-        return caller_locals["parent_log_device"]
-    else:
-        raise ValueError("Unable to determine the parent logging device.")
-
-
-class Loggable:
-    """
-    A metaclass to enhance classes with logging capabilities. Classes that inherit from
-    'Loggable' can instantly access a logger without manually setting it up. This logger
-    is derived from a parent logger, ensuring consistent logging behavior and hierarchy.
-
-    Attributes:
-        - log_device: The logger device associated with the instance of the class.
-    """
-
-    def __init__(self, parent_log_device=None, **kwargs):
-        self.parent_log_device = parent_log_device
-        self.__log_name = self.__class__.__name__
-        if self.parent_log_device is not None:
-            self.__log_device = self.parent_log_device.get_child(
-                self.__class__.__name__
-            )
+        Returns:
+            Logger: An instance of the Logger class for the calling module.
+        """
+        frame = inspect.currentframe().f_back
+        if module_path := cls._determine_module_path(frame):
+            return cls(module_path)
         else:
-            self.__log_device = _get_parent_logging_device().get_child(
-                self.__class__.__name__
-            )
-
-    @property
-    def log_device(self):
-        return self.__log_device
-
-    @log_device.setter
-    def log_device(self, new):
-        if not isinstance(new, Logger):
-            raise TypeError('log_device must be of type "Logger"')
-
-        self.__log_device = new
+            raise ValueError("Unable to determine module path for logger creation.")
 
-    def create_child_logger(self, name=None, override=False):
+    @staticmethod
+    def _determine_module_path(frame):
         """
-        Creates and returns a child logger of this object's logger.
+        Determines the in-project path of the module from the call frame.
 
-        Parameters:
-            name (str, optional): The name of the child logger.
-                If not provided, the name of the calling function is used.
-            override (bool, optional): A flag to override the membership check. Defaults to False.
+        Args:
+            frame:
+                The frame from which to determine the module path.
 
         Returns:
-            Logger: An instance of the Logger class that represents the child logger.
+            str:
+                The in-project path of the module.
         """
-        if not override:
-            self.__is_member__()
+        if module := inspect.getmodule(frame):
+            base_path = os.path.dirname(os.path.abspath(module.__file__))
+            relative_path = os.path.relpath(frame.f_code.co_filename, base_path)
+            return relative_path.replace(os.path.sep, '.').rstrip('.py')
+        return None
 
-        if name is None:
-            name = inspect.stack()[1][
-                3
-            ]  # Get the name of the calling function if no name is provided
-
-        return self.log_device.get_child(name)
-
-    def __is_member__(self):
+    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False, stacklevel=1):
         """
-        Checks whether the caller of this method is a member of the same class.
-
-        Raises:
-            PermissionError: If the caller of this method is not a member of the same class.
+        Low-level logging implementation, passing stacklevel to findCaller.
         """
-        log_device = self.log_device.get_child("__is_member__")
-        log = log_device.logger
+        if self.logger.isEnabledFor(level):
+            self.logger._log(level, msg, args, exc_info, extra, stack_info, stacklevel + 1)
 
-        current_frame = inspect.currentframe()
-        log.debug(f"Current frame: {current_frame}")
 
-        caller_frame = current_frame.f_back
-        log.debug(f"Caller frame: {caller_frame}")
+found_level = find_variable_in_call_stack('INSPY_LOG_LEVEL', DEFAULT_LOGGING_LEVEL)
+
+LOG_DEVICE = Logger(PROG_NAME, found_level)
+MOD_LOG_DEVICE = LOG_DEVICE.get_child("log_engine", found_level)
+MOD_LOGGER = MOD_LOG_DEVICE.logger
+MOD_LOGGER.debug(f"Started logger for {__name__}.")
 
-        caller_self = caller_frame.f_locals.get("self", None)
-        log.debug(f"Caller self: {caller_self}")
+add_child = LOG_DEVICE.get_child
 
-        log.debug("Checking if caller is a member of this class...")
-        if not isinstance(caller_self, self.__class__):
-            raise PermissionError(
-                "Access denied.\n"
-                f"Method can only be accessed by members of the same class. {caller_self.__class__.__name__} is not such a member"
-            )
+InspyLogger = Logger
 
-        log.debug(f"Access granted to {caller_self.__class__.__name__}")
+from inspy_logger.helpers.base_classes import Loggable

inspy_logger-3.0.dev4/inspy_logger/helpers/base_classes.py

@@ -0,0 +1,136 @@
+import inspect
+from inspy_logger import MOD_LOGGER, MOD_LOG_DEVICE, Logger
+
+import inspect
+
+
+class LoggableDescriptor:
+    """
+    Descriptor for accessing a logger specific to a class method.
+    """
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Accessing through the class, not an instance
+            return owner.class_logger
+
+        # Determine the calling method's name
+        stack = inspect.stack()
+        # Start from 1 to skip the current __get__ frame
+        for frame_record in stack[1:]:
+            if 'self' in frame_record.frame.f_locals:
+                if frame_record.frame.f_locals['self'] is instance:
+                    method_name = frame_record.function
+                    break
+        else:
+            raise Exception("Could not determine the calling method's name.")
+
+        # Get a child logger named after the class and method
+        return instance.log_device.get_child()
+
+
+def _get_parent_logging_device():
+    """
+    Determines the parent logging device by inspecting the caller's log_device or parent_log_device attribute.
+
+    Returns:
+        Logger: The parent logging device.
+    """
+    MOD_LOGGER.debug("Determining parent logging device")
+    caller_frame = inspect.currentframe().f_back
+    caller_locals = caller_frame.f_locals
+
+    if "logger" in caller_locals:
+        return caller_locals["logger"]
+    elif "parent_log_device" in caller_locals:
+        return caller_locals["parent_log_device"]
+    else:
+        raise ValueError("Unable to determine the parent logging device.")
+
+
+class Loggable:
+    """
+    A metaclass to enhance classes with logging capabilities. Classes that inherit from
+    'Loggable' can instantly access a logger without manually setting it up. This logger
+    is derived from a parent logger, ensuring consistent logging behavior and hierarchy.
+
+    Attributes:
+        - log_device: The logger device associated with the instance of the class.
+    """
+    method_logger = LoggableDescriptor()
+    class_logger = None
+
+    def __init__(self, parent_log_device=None, **kwargs):
+        self.parent_log_device = parent_log_device
+        self.__log_name = self.__class__.__name__
+        if self.parent_log_device is not None:
+            self.__log_device = self.parent_log_device.get_child(self.__log_name)
+        else:
+            self.__log_device = _get_parent_logging_device().get_child()
+
+        # Set up class-level logger if it's not already set
+        if self.__class__.class_logger is None:
+            self.__class__.class_logger = self.__log_device
+
+        self.method_logger = self.__class__.method_logger.logger
+
+    @property
+    def log_device(self):
+        return self.__log_device
+
+    @log_device.setter
+    def log_device(self, new):
+        if not isinstance(new, Logger):
+            raise TypeError('log_device must be of type "Logger"')
+
+        self.__log_device = new
+
+    def create_child_logger(self, name=None, override=False):
+        """
+        Creates and returns a child logger of this object's logger.
+
+        Parameters:
+            name (str, optional): The name of the child logger.
+                If not provided, the name of the calling function is used.
+            override (bool, optional): A flag to override the membership check. Defaults to False.
+
+        Returns:
+            Logger: An instance of the Logger class that represents the child logger.
+        """
+        if not override:
+            self.__is_member__()
+
+        if name is None:
+            name = inspect.stack()[1][
+                3
+            ]  # Get the name of the calling function if no name is provided
+        #print(inspect.stack()[1])
+        return self.log_device.get_child(name)
+
+    def __is_member__(self):
+        """
+        Checks whether the caller of this method is a member of the same class.
+
+        Raises:
+            PermissionError: If the caller of this method is not a member of the same class.
+        """
+        log_device = self.log_device.get_child("__is_member__")
+        log = log_device.logger
+
+        current_frame = inspect.currentframe()
+        log.debug(f"Current frame: {current_frame}")
+
+        caller_frame = current_frame.f_back
+        log.debug(f"Caller frame: {caller_frame}")
+
+        caller_self = caller_frame.f_locals.get("self", None)
+        log.debug(f"Caller self: {caller_self}")
+
+        log.debug("Checking if caller is a member of this class...")
+        if not isinstance(caller_self, self.__class__):
+            raise PermissionError(
+                "Access denied.\n"
+                f"Method can only be accessed by members of the same class. {caller_self.__class__.__name__} is not such a member"
+            )
+
+        log.debug(f"Access granted to {caller_self.__class__.__name__}")

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/inspy_logger/version.py

@@ -16,7 +16,7 @@ __VERSION__ = {
     'minor': 0,
     'patch': 0,
     'release': 'dev',
-    'release_num': 2
+    'release_num': 4
 }
 
 

{inspy_logger-3.0.dev2 → inspy_logger-3.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "inspy-logger"
-version = "3.0-dev.2"
+version = "3.0-dev.4"
 description = "Colorable, scalable logger for CLI"
 authors = ["Taylor-Jayde Blackstone <tayjaybabee@gmail.com>"]
 homepage = 'https://github.com/Inspyre-Softworks/inSPy-Logger'
@@ -28,7 +28,7 @@ classifiers = [
     ]
 
 [tool.poetry.dependencies]
-python = "^3.7"
+python = ">=3.9,<4.0"
 colorlog = "^6.7"
 setuptools-autover = "^1.0.2"
 luddite = "^1.0.1"
@@ -42,15 +42,22 @@ rich = "^13.5.2"
 
 [tool.poetry.dev-dependencies]
 ptipython = "^1.0.1"
-Sphinx = "^5.3.0"
-sphinxcontrib-napoleon = "^0.7"
-sphinx-rtd-theme = "^1.0.0"
 asciinema = "^2.2.0"
 bpython = "^0.23"
 
 [tool.poetry.scripts]
 inspy-logger-tool = "inspy_logger.Scripts.main:main"
 
+[tool.poetry.group.docs.dependencies]
+sphinx = "^7.2.6"
+sphinx-autodoc-typehints = "^1.25.2"
+sphinxcontrib-napoleon = "^0.7"
+sphinx-rtd-theme = "^2.0.0"
+sphinxcontrib-argdoc = "^0.1.3"
+autoclasstoc = "^1.6.0"
+sphinx-autodoc-annotation = "^1.0.post1"
+sphinxcontrib-autoprogram = "^0.1.8"
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"