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

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

@@ -1,25 +1,25 @@
 Metadata-Version: 2.1
 Name: inspy-logger
-Version: 3.0.dev2
+Version: 3.0.dev3
 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.dev3}/inspy_logger/__init__.py

@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
 import inspect
+import os
 import logging
 from rich.logging import RichHandler
 from inspy_logger.__about__ import __prog__ as PROG_NAME
 from inspy_logger.helpers import find_variable_in_call_stack
 
+
 # Let's set up some constants.
 LEVEL_MAP = [
     ('debug', logging.DEBUG),
@@ -144,8 +146,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 +160,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
 
@@ -195,6 +196,19 @@ class Logger:
 
         return results
 
+    def debug(self, message):
+        self.logger.debug(message)
+
+    def info(self, message):
+        self.logger.info(message)
+
+    def warning(self, message):
+        self.logger.warning(message)
+
+    def error(self, message):
+        self.logger.error(message)
+
+
     def __repr__(self):
         name = self.name
         hex_id = hex(id(self))
@@ -208,119 +222,59 @@ class Logger:
         if parent_part.endswith('|'):
             parent_part = str(parent_part[:-2])
 
-        return f'<Logger: {name} at {hex_id}{parent_part}>'
-
-
-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
+        return f'<Logger: {name} w/ level {self.logger.level} at {hex_id}{parent_part}>'
 
-    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.")
 
+    @classmethod
+    def create_logger_for_caller(cls):
+        """
+        Creates a logger for the module that calls this method.
 
-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
+        #print(frame)
+        #print(dir(frame))
+        #print(dir(inspect.getmodule(frame)))
+        #print(inspect.getmodule(frame).__name__)
+        module_path = cls._determine_module_path(frame)
+        if module_path:
+            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__()
+        module = inspect.getmodule(frame)
+        if module:
+            base_path = os.path.dirname(os.path.abspath(module.__file__))
+            relative_path = os.path.relpath(frame.f_code.co_filename, base_path)
+            module_path = relative_path.replace(os.path.sep, '.').rstrip('.py')
+            return module_path
+        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):
-        """
-        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
+found_level = find_variable_in_call_stack('INSPY_LOG_LEVEL', DEFAULT_LOGGING_LEVEL)
 
-        current_frame = inspect.currentframe()
-        log.debug(f"Current frame: {current_frame}")
 
-        caller_frame = current_frame.f_back
-        log.debug(f"Caller frame: {caller_frame}")
+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.dev3/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.dev3}/inspy_logger/version.py

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "inspy-logger"
-version = "3.0-dev.2"
+version = "3.0-dev.3"
 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"