docs: Add complete Google-style docstrings to Logger module (#639) (#641)

Signed-off-by: Raja Rathour <imraja729@gmail.com>

Author: Raja-89

CHANGELOG.md

@@ -9,7 +9,7 @@ This changelog is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.
 ### Added
 
 - Add Google-style docstrings to `AccountInfo` class and its methods in `account_info.py`.
-
+- Added comprehensive Google-style docstrings to the `Logger` class and all utility functions in `src/hiero_sdk_python/logger/logger.py` (#639).
 - add AccountRecordsQuery class
 
 ### Changed

src/hiero_sdk_python/logger/logger.py

@@ -1,5 +1,9 @@
 """
 Simple logger module for the Hiero SDK.
+
+This module provides a custom wrapper around Python's standard logging module,
+adding support for custom log levels (TRACE, DISABLED) and simplifying log
+configuration within the SDK.
 """
 
 import logging
@@ -13,20 +17,23 @@
 _DISABLED_LEVEL = LogLevel.DISABLED.value
 _TRACE_LEVEL = LogLevel.TRACE.value
 logging.addLevelName(_DISABLED_LEVEL, "DISABLED")
-logging.addLevelName(_TRACE_LEVEL,   "TRACE")
+logging.addLevelName(_TRACE_LEVEL, "TRACE")
 
 class Logger:
     """
-    Custom logger that wraps Python's logging module
+    Custom logger that wraps Python's logging module for Hiero SDK use.
+
+    This class handles configuration, formatting, and logging operations across
+    various log levels, including custom SDK levels (TRACE, DISABLED).
     """
 
     def __init__(self, level: Optional[LogLevel] = None, name: Optional[str] = None) -> None:
         """
-        Constructor
+        Initializes the Logger instance for the Hiero SDK.
         
         Args:
-            level (LogLevel, optional): the current log level
-            name (str, optional): logger name, defaults to class name
+            level (LogLevel, optional): The current minimum log level. Defaults to TRACE.
+            name (str, optional): The logger name. Defaults to "hiero_sdk_python".
         """
 
         # Get logger name
@@ -49,7 +56,15 @@ def __init__(self, level: Optional[LogLevel] = None, name: Optional[str] = None)
         self.set_level(self.level)
 
     def set_level(self, level: Union[LogLevel, str]) -> "Logger":
-        """Set log level"""
+        """
+        Sets the current logging level for the SDK logger.
+
+        Args:
+            level (Union[LogLevel, str]): The new minimum log level. Can be a LogLevel enum or a string (e.g., "INFO").
+
+        Returns:
+            Logger: The current Logger instance (for chaining).
+        """
         if isinstance(level, str):
             level = LogLevel.from_string(level)
 
@@ -65,11 +80,24 @@ def set_level(self, level: Union[LogLevel, str]) -> "Logger":
         return self
 
     def get_level(self) -> LogLevel:
-        """Get current log level"""
+        """
+        Retrieves the current logging level set for the SDK logger.
+
+        Returns:
+            LogLevel: The current minimum logging level.
+        """
         return self.level
 
     def set_silent(self, is_silent: bool) -> "Logger":
-        """Enable/disable silent mode"""
+        """
+        Enables or disables silent mode (disabling all logging output).
+
+        Args:
+            is_silent (bool): If True, disables logging entirely. If False, logging is re-enabled.
+
+        Returns:
+            Logger: The current Logger instance (for chaining).
+        """
         if is_silent:
             self.internal_logger.disabled = True
         else:
@@ -78,7 +106,18 @@ def set_silent(self, is_silent: bool) -> "Logger":
         return self
 
     def _format_args(self, message: str, args: Sequence[object]) -> str:
-        """Format key-value pairs into string"""
+        """
+        Formats a message with optional key-value pairs into a clean string format.
+
+        Args:
+            message (str): The main log message.
+            args (Sequence[object]): A sequence of objects supplied as alternating
+                keys and values (e.g., "key1", value1, "key2", value2).
+
+        Returns:
+            str: The formatted log string, or just the original message if arguments
+                are not supplied correctly (not an even number).
+        """
         if not args or len(args) % 2 != 0:
             return message
         pairs = []
@@ -87,27 +126,59 @@ def _format_args(self, message: str, args: Sequence[object]) -> str:
         return f"{message}: {', '.join(pairs)}"
 
     def trace(self, message: str, *args: object) -> None:
-        """Log at TRACE level"""
+        """
+        Logs a message at the TRACE level (lowest verbosity).
+
+        Args:
+            message (str): The main log message.
+            *args (object): Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         if self.internal_logger.isEnabledFor(_TRACE_LEVEL):
             self.internal_logger.log(_TRACE_LEVEL, self._format_args(message, args))
 
     def debug(self, message: str, *args: object) -> None:
-        """Log at DEBUG level"""
+        """
+        Logs a message at the DEBUG level.
+
+        Args:
+            message (str): The main log message.
+            *args (object): Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         if self.internal_logger.isEnabledFor(LogLevel.DEBUG.value):
             self.internal_logger.debug(self._format_args(message, args))
 
     def info(self, message: str, *args: object) -> None:
-        """Log at INFO level"""
+        """
+        Logs a message at the INFO level.
+
+        Args:
+            message (str): The main log message.
+            *args (object): Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         if self.internal_logger.isEnabledFor(LogLevel.INFO.value):
             self.internal_logger.info(self._format_args(message, args))
 
     def warning(self, message: str, *args: object) -> None:
-        """Log at WARNING level"""
+        """
+        Logs a message at the WARNING level.
+
+        Args:
+            message (str): The main log message.
+            *args (object): Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         if self.internal_logger.isEnabledFor(LogLevel.WARNING.value):
             self.internal_logger.warning(self._format_args(message, args))
 
     def warn(self, message: str, *args) -> None:
-        """Legacy warn method replaced by warning"""
+        """
+        Legacy method for logging a message at the WARNING level.
+
+        This method is deprecated; use `Logger.warning()` instead.
+
+        Args:
+            message (str): The main log message.
+            *args: Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         warnings.warn(
             "Logger.warn() is deprecated; use Logger.warning()",
             category=FutureWarning,
@@ -117,14 +188,32 @@ def warn(self, message: str, *args) -> None:
         self.warning(message, *args)
 
     def error(self, message: str, *args: object) -> None:
-        """Log at ERROR level"""
+        """
+        Logs a message at the ERROR level.
+
+        Args:
+            message (str): The main log message.
+            *args (object): Optional key-value pairs (key, value, key, value, ...) to be appended to the message.
+        """
         if self.internal_logger.isEnabledFor(LogLevel.ERROR.value):
             self.internal_logger.error(self._format_args(message, args))
 
 def get_logger(
     level: Optional[LogLevel] = None,
-    name:  Optional[str]      = None,
+    name: Optional[str] = None,
 ) -> Logger:
+    """
+    Returns a configured Logger instance.
+
+    This function is provided for convenience and handles a legacy parameter order swap.
+
+    Args:
+        level (Optional[LogLevel]): The initial log level to set.
+        name (Optional[str]): The name of the logger instance.
+
+    Returns:
+        Logger: A new or existing configured Logger instance.
+    """
     # Legacy method: pass in name, level
     if isinstance(level, str) and isinstance(name, LogLevel):
         warnings.warn(