inspy-logger 3.1.0.dev1__tar.gz → 3.1.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: inspy-logger
-Version: 3.1.0.dev1
+Version: 3.1.0.dev3
 Summary: Colorable, scalable logger for CLI
 Home-page: https://github.com/Inspyre-Softworks/inSPy-Logger
 License: MIT

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/__init__.py

@@ -56,6 +56,8 @@ CLIENT_PROG_NAME = determine_client_prog_name()
 
 INIT_LOG_LEVEL = determine_level(CLIENT_PROG_NAME)
 
+INTERACTIVE_SESSION = find_variable_in_call_stack('INSPY_INTERACTIVE_SESSION', default=False)
+
 
 def start_logger(override_block=True):
     """

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/common/__init__.py

@@ -70,7 +70,7 @@ LEVELS = list(LEVEL_MAP.values())
 """The list of level names."""
 
 
-DEFAULT_LOGGING_LEVEL = logging.DEBUG
+DEFAULT_LOGGING_LEVEL = logging.INFO
 """The default logging level."""
 
 

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/config/dirs.py

@@ -15,8 +15,7 @@ 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
+    appauthor=SOFTWARE_ORG
 )
 
 INSPY_LOGGER_LOG_FILE_NAME = 'app.log'
@@ -124,7 +123,7 @@ def get_log_file_path(
     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)
+            log_file_path = Path(user_log_path(appname=prog_name, appauthor=dev_name).joinpath(file_name))
         else:
             log_file_path = INSPY_LOGGER_LOG_DIR_PATH.joinpath(file_name)
 

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/constants.py

@@ -15,11 +15,14 @@ Description:
     
 
 """
+
+
 import logging
 
 DEFAULT_LOGGING_LEVEL = logging.DEBUG
 
 LEVEL_MAP = {
+    'internal': 5,
     'debug': logging.DEBUG,
     'info': logging.INFO,
     'warning': logging.WARNING,
@@ -28,3 +31,12 @@ LEVEL_MAP = {
     'fatal': logging.FATAL,
 }
 """A mapping of level names to their corresponding logging levels."""
+
+
+LEVELS = [level.upper() for level in LEVEL_MAP]
+
+INTERNAL = LEVEL_MAP['debug'] - 5
+
+
+INTERACTIVE_SESSION = __name__ != '__main__'
+"""A flag to indicate whether the session is interactive."""

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/engine/__init__.py

@@ -6,6 +6,7 @@ import sys
 from rich.logging import RichHandler
 
 from inspy_logger.config import DEFAULT_LOG_FILE_PATH
+from inspy_logger.constants import LEVELS, INTERACTIVE_SESSION, INTERNAL
 from inspy_logger.engine.handlers import BufferingHandler
 from inspy_logger.common import InspyLogger, DEFAULT_LOGGING_LEVEL
 from inspy_logger.helpers import translate_to_logging_level, CustomFormatter, get_level_name, RestrictedSetter
@@ -20,6 +21,8 @@ class Logger(InspyLogger):
     A Singleton class responsible for managing the logging mechanisms of the application.
     """
 
+    LEVELS = LEVELS
+    INTERACTIVE_SESSION = INTERACTIVE_SESSION
     instances = {}  # A dictionary to hold instances of the Logger class.
 
     # Set the file path for the log file.
@@ -52,6 +55,7 @@ class Logger(InspyLogger):
             file_path=DEFAULT_LOG_FILE_PATH.parent,
             no_file_logging=False,
             parent=None,
+            skip_interactive_check: bool=False
     ):
         """
         Initializes a logger instance.
@@ -93,8 +97,8 @@ class Logger(InspyLogger):
         self.__no_file_logging = None
         self.__file_path = None
 
+
         self.logger = logging.getLogger(name)
-        self.logger.debug('Debug message from logger')
         self.logger.setLevel(translate_to_logging_level(console_level))
 
         self.logger.propagate = False
@@ -103,9 +107,9 @@ class Logger(InspyLogger):
         if 'inSPy-Logger' in self.logger.name:
             self.buffering_handler = BufferingHandler()
             self.logger.addHandler(self.buffering_handler)
-            self.logger.debug('Initializing logger with buffering handler.')
+            self.internal('Initializing logger with buffering handler.')
         else:
-            self.logger.debug('Initializing  logger without buffering handler.')
+            self.internal('Initializing  logger without buffering handler.')
 
         self.no_file_logging = no_file_logging
 
@@ -167,6 +171,7 @@ class Logger(InspyLogger):
 
     @property
     def console_level_name(self):
+        self.internal('Test message')
         return get_level_name(self.console_level)
 
     @property
@@ -242,6 +247,10 @@ class Logger(InspyLogger):
     #             self.__file_path = old
     #             raise e
 
+    @property
+    def interactive_session(self):
+        return hasattr(sys, 'ps1') and sys.ps1
+
     @property
     def name(self):
         """
@@ -304,6 +313,22 @@ class Logger(InspyLogger):
 
                 return handler
 
+    def has_child(self, name):
+        """
+        Checks if the logger has a child with the specified name.
+
+        Args:
+            name (str):
+                The name of the child logger.
+
+        Returns:
+            bool:
+                True if the logger has a child with the specified name, else False.
+        """
+
+        return name in self.child_names
+
+
     @validate_type(str, Path, preferred_type=Path)
     def set_file_path(self, file_path):
         """
@@ -321,14 +346,12 @@ class Logger(InspyLogger):
             self.file_path = old
             raise
 
-
-
     def set_up_console(self):
         """
         Configures and attaches a console handler to the logger.
         """
 
-        self.logger.debug("Setting up console handler")
+        self.internal("Setting up console handler")
         console_handler = RichHandler(
             show_level=True, markup=True, rich_tracebacks=True, tracebacks_show_locals=True
         )
@@ -367,7 +390,7 @@ class Logger(InspyLogger):
             None
         """
 
-        self.logger.debug("Setting log levels")
+        self.internal("Setting log levels")
 
         # If we received a console level, update the console level.
         if console_level is not None:
@@ -419,25 +442,21 @@ class Logger(InspyLogger):
             InspyLogger:
                 The child logger with the specified name, console level, and file level.
         """
-        # Determine the console level and file level for the child logger.
-
-        # If the console level is not provided, use the console level of the parent logger
-        console_level = console_level or self.console_level
-
-        # If the file level is not provided, use the file level of the parent logger
-        file_level = file_level or self.file_level
-
         # Get the name of the calling function if no name is provided
         caller_frame = inspect.stack()[1]
 
         cl_name = self.__build_name_from_caller(caller_frame, name)
 
-        cl_name
+        if found_child := self.find_child_by_name(cl_name, exact_match=True):
+            return found_child
+
+        # Determine the console level and file level for the child logger.
 
-        found_child = self.find_child_by_name(cl_name, exact_match=True)
+        # If the console level is not provided, use the console level of the parent logger
+        console_level = console_level or self.console_level
 
-        if found_child:
-            return found_child
+        # If the file level is not provided, use the file level of the parent logger
+        file_level = file_level or self.file_level
 
         child_logger = Logger(name=cl_name, console_level=console_level, file_level=file_level, parent=self)
 
@@ -451,7 +470,7 @@ class Logger(InspyLogger):
         Fetches the names of all child loggers associated with this logger instance.
         """
 
-        self.logger.debug("Getting child logger names")
+        self.internal("Getting child logger names")
         return [child.logger.name for child in self.children]
 
     def get_parent(self) -> InspyLogger:
@@ -459,7 +478,7 @@ class Logger(InspyLogger):
         Fetches the parent logger associated with this logger instance.
         """
 
-        self.logger.debug("Getting parent logger")
+        self.internal("Getting parent logger")
         return self.parent
 
     def find_child_by_name(self, name: str, case_sensitive=True, exact_match=False) -> (List, InspyLogger):
@@ -481,7 +500,7 @@ class Logger(InspyLogger):
                             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}')
+        self.internal(f'Searching for child with name: {name}')
         results = []
 
         if not case_sensitive:
@@ -497,14 +516,17 @@ class Logger(InspyLogger):
         return results
 
     @count_invocations
-    def debug(self, message):
+    def debug(self, message, stack_level=3):
         """
         Logs a debug message.
 
         Args:
-          message (str): The message to log.
+            message (str): The message to log.
+
+            stack_level (int, optional):
+                The stacklevel to use when logging. Defaults to 3.
         """
-        self._log(logging.DEBUG, message, args=(), stacklevel=2)
+        self._log(logging.DEBUG, message, args=(), stacklevel=stack_level)
 
     @count_invocations
     def info(self, message):
@@ -516,6 +538,16 @@ class Logger(InspyLogger):
         """
         self._log(logging.INFO, message, args=(), stacklevel=2)
 
+    def internal(self, message, *args, **kwargs):
+        """
+        Logs an internal message.
+
+        Args:
+            message (str): The message to log.
+        """
+        if self.logger.isEnabledFor(INTERNAL):
+            self._log(INTERNAL, message, args=args, stacklevel=2)
+
     @count_invocations
     def warning(self, message):
         """
@@ -624,7 +656,7 @@ class Logger(InspyLogger):
         """
         Starts the logger.
         """
-        self.logger.warning('InspyLogger.start() is deprecated.')
+        self.warning('InspyLogger.start() is deprecated.')
         if not self.logger.handlers:
             self.set_up_handlers()
 
@@ -656,6 +688,11 @@ class Logger(InspyLogger):
         """
         Low-level logging implementation, passing stacklevel to findCaller.
         """
+        #caller_frame = inspect.currentframe().f_back
+        #print(caller_frame.f_code.co_name)
+        if INTERACTIVE_SESSION:
+            stacklevel -= 1
+
         if self.logger.isEnabledFor(level):
             self.logger._log(level, msg, args, exc_info, extra, stack_info, stacklevel + 1)
 

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/helpers/base_classes.py

@@ -2,7 +2,6 @@ import inspect
 from inspy_logger import LOG_DEVICE, Logger
 
 
-
 class LoggableDescriptor:
     """
     Descriptor for accessing a logger specific to a class method.
@@ -19,7 +18,7 @@ class LoggableDescriptor:
         for frame_record in stack[1:]:
             if 'self' in frame_record.frame.f_locals and frame_record.frame.f_locals['self'] is instance:
                 method_name = frame_record.function
-                print(method_name)
+
                 break
         else:
             raise Exception("Could not determine the calling method's name.")
@@ -72,6 +71,7 @@ class Loggable:
         """
         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:
@@ -106,14 +106,15 @@ class Loggable:
         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])
+            ]
+        if self.log_device.has_child(name):
+            return self.log_device.find_child_by_name(name)
+        if not override:
+            self.__is_member__()
+
         return self.log_device.get_child(name)
 
     def __is_member__(self):
@@ -123,8 +124,12 @@ class Loggable:
         Raises:
             PermissionError: If the caller of this method is not a member of the same class.
         """
+        print(self.log_device.children)
+        log_name = f'{self.log_device.name}.__is_member__'
+
+
         log_device = self.log_device.get_child("__is_member__")
-        log = log_device.logger
+        log = log_device
 
         current_frame = inspect.currentframe()
         log.debug(f"Current frame: {current_frame}")

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/helpers/decorators.py

@@ -27,6 +27,27 @@ __all__ = [
 ]
 
 
+def property_logging(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        if self.creating_logger:
+            return
+        if found := self.class_logger.find_child_by_name(func.__name__, exact_match=True):
+            log = found
+        else:
+            self.creating_logger = True
+            log = self.class_logger.add_child(func.__name__)
+            self.creating_logger = False
+
+        log.debug(f'Getting {func.__name__} from instance of {self.__class__.__name__}...', stack_level=4)
+        res = func(self, *args, **kwargs)
+        log.debug(f'Got {func.__name__} from instance of {self.__class__.__name__}: {res}', stack_level=4)
+
+        return res
+    return wrapper
+
+
+
 def method_alias(*alias_names: (str, list[str])):
     """
     A decorator that allows you to add aliases to a class's method.
@@ -162,7 +183,7 @@ def validate_type(*allowed_types, preferred_type=None, allowed_values=None, case
     def decorator(func):
         @wraps(func)
         def wrapper(self, value):
-            if not isinstance(value, allowed_types):
+            if not isinstance(value, tuple(allowed_types)):
                 allowed = ', '.join([t.__name__ for t in allowed_types])
                 raise TypeError(f"Value must be of type {allowed}, got type {type(value).__name__}")
 

inspy_logger-3.1.0.dev3/inspy_logger/tool/__init__.py

@@ -0,0 +1,4 @@
+import logging
+
+
+logging.addLevelName(5, 'INTERNAL')

inspy_logger-3.1.0.dev3/inspy_logger/types.py

@@ -0,0 +1,169 @@
+"""
+
+
+Author: 
+    Inspyre Softworks
+
+Project:
+    inSPy-Logger
+
+File: 
+    inspy_logger/types.py
+ 
+
+Description:
+    
+
+"""
+from inspy_logger.constants import LEVEL_MAP
+from inspy_logger.helpers import translate_to_logging_level
+from inspy_logger.helpers.decorators import validate_type
+
+
+class LogLevel:
+    """
+    A class for defining log levels for the logger.
+    """
+    LOG_LEVELS = {
+        'DEBUG',
+        'INFO',
+        'WARNING',
+        'ERROR',
+        'CRITICAL',
+    }
+
+    __allowed_values = LOG_LEVELS
+
+    __case_sensitive = None
+
+    def __init__(self, log_level: str = 'INFO', case_sensitive=False):
+        self.__level_name = None
+
+        self.case_sensitive = case_sensitive
+
+        levels = list(self.LOG_LEVELS)
+
+        if isinstance(log_level, str):
+            if not case_sensitive:
+                for level in levels:
+                    self.__allowed_values.add(level.lower())
+
+        elif isinstance(log_level, int):
+            self.level_name = self.from_int(log_level)
+
+        self.level_name = log_level
+
+    @property
+    def allowed_values(self):
+        return self.__allowed_values
+
+    @property
+    def case_sensitive(self):
+        return self.__case_sensitive
+
+    @case_sensitive.setter
+    @validate_type(bool)
+    def case_sensitive(self, case_sensitive: bool):
+        self.__case_sensitive = case_sensitive
+
+    @property
+    def level_name(self):
+        return self.__level_name
+
+    @level_name.setter
+    @validate_type(str, case_sensitive=False, allowed_values=LOG_LEVELS)
+    def level_name(self, new_level: str):
+        self.__level_name = new_level.upper()
+
+    @classmethod
+    def from_str(cls, level_string):
+        level = level_string.upper()
+        if level not in cls.LOG_LEVELS:
+            raise ValueError(f"Invalid log level: {level_string}, must be one of {cls.LOG_LEVELS}")
+
+        return cls(level)
+
+    @classmethod
+    def from_int(cls, level_integer):
+        for level in cls.LOG_LEVELS:
+            if translate_to_logging_level(level) == level_integer:
+                return cls(level)
+
+        raise ValueError(f"Invalid log level: {level_integer}, must be one of {cls.LOG_LEVELS}")
+
+    def as_int(self):
+        return translate_to_logging_level(self.level_name)
+
+    def upper(self):
+        return self.level_name.upper()
+
+    def lower(self):
+        return self.level_name.lower()
+
+    def __str__(self):
+        return self.level_name
+
+    def __int__(self):
+        return translate_to_logging_level(self.level_name)
+
+    @classmethod
+    def get_levels(cls):
+        return [cls.DEBUG, cls.INFO, cls.WARNING, cls.ERROR, cls.CRITICAL]
+
+
+class LogLevel(LogLevel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __convert_if_needed(self, other):
+        if not isinstance(other, LogLevel):
+            if isinstance(other, str):
+                other = self.from_str(other)
+            elif isinstance(other, int):
+                other = self.from_int(other)
+
+        return other
+
+    def __eq__(self, other):
+        other = self.__convert_if_needed(other)
+        return self.level_name == other.level_name
+
+    def __hash__(self):
+        return hash(self.level_name)
+
+    def __le__(self, other):
+        other = self.__convert_if_needed(other)
+        return self.as_int() <= other.as_int()
+
+
+    def __lt__(self, other):
+        other = self.__convert_if_needed(other)
+
+        return self.as_int() < other.as_int()
+
+
+    def __ge__(self, other):
+        other = self.__convert_if_needed(other)
+        return self.as_int() >= other.as_int()
+
+
+    def __gt__(self, other):
+        other = self.__convert_if_needed(other)
+        return self.as_int() > other.as_int()
+
+
+    def __repr__(self):
+        return f"LogLevel: {self.level_name} | {self.as_int()} at {hex(id(self))})"
+
+
+def assemble_log_levels():
+    _ = list(LogLevel.LOG_LEVELS)
+    levels = [level for level in _ if level.isupper()]
+
+    levels = sorted(levels, key=lambda x: LEVEL_MAP[x.lower()])
+
+    return {LogLevel(level) for level in levels}
+
+
+if 'LOG_LEVELS' not in globals():
+    LOG_LEVELS = assemble_log_levels()

inspy_logger-3.1.0.dev3/inspy_logger/version/VERSION.txt

@@ -0,0 +1 @@
+3.1.0-dev.3

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/inspy_logger/version/__init__.py

@@ -1,3 +1,4 @@
+import contextlib
 import requests
 from packaging import version as pkg_version
 import sys
@@ -159,17 +160,14 @@ class VersionParser:
 
     def print_version(self, skip_rich=False):
         if not skip_rich:
-            try:
+            with contextlib.suppress(ImportError):
                 self.__rich__()
                 return
-            except ImportError:
-                pass
-
         self._print_version()
 
     def _print_version(self):
         version_info = self.version_info
-        print()
+        print(version_info)
 
     def __str__(self):
         return self.version_str
@@ -222,9 +220,6 @@ class VersionParser:
         return self.version_info['release_num']
 
 
-print(__file__)
-
-
 def parse_version_file():
     with open(Path(__file__).parent.joinpath('VERSION.txt'), 'r') as f:
         return VersionParser(f.read().strip())

{inspy_logger-3.1.0.dev1 → inspy_logger-3.1.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "inspy-logger"
-version = "3.1.0-dev.1"
+version = "3.1.0-dev.3"
 description = "Colorable, scalable logger for CLI"
 authors = ["Taylor-Jayde Blackstone <tayjaybabee@gmail.com>"]
 homepage = 'https://github.com/Inspyre-Softworks/inSPy-Logger'

inspy_logger-3.1.0.dev1/inspy_logger/version/VERSION.txt

@@ -1 +0,0 @@
-3.1.0-dev.1