nuclear 2.2.0__tar.gz → 2.2.3__tar.gz

{nuclear-2.2.0 → nuclear-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nuclear
-Version: 2.2.0
+Version: 2.2.3
 Summary: Declarative parser for command line interfaces
 Home-page: https://github.com/igrek51/nuclear
 Author: igrek51
@@ -136,13 +136,13 @@ with the following **modifiers**:
 - `.nodocs` to hide documentation for functions and classes
 - `.all` to include all available information
 
-You can chain modifiers, e.g. `wat.long.dunder / object`.
+You can chain modifiers, e.g. `wat.long.dunder.nodocs / object`.
 
 Call `wat()` to inspect `locals()` variables.
 
 Type `wat` in the interpreter to learn more about this object itself.
 
-## Use cases
+## Use Cases Examples
 
 ### Determine type
 In a dynamic typing language like Python, it's often hard to determine the type of an object. WAT Inspector can help you with that by showing the name of the type with the module it comes from.
@@ -162,12 +162,14 @@ type: django.contrib.auth.models.User
 parents: django.contrib.auth.models.AbstractUser, django.contrib.auth.base_user.AbstractBaseUser, django.contrib.auth.models.PermissionsMixin, django.db.models.base.Model, django.db.models.utils.AltersData
 ```
 
+Now that you've identified the actual type, you can put the type annotations in your code to reduce the confusion.
+
 ### Look up methods
 Listing methods, functions and looking up their signature is extremely beneficial to see how to use them.
 Plus, you can read their docstrings.
 
 ```python
-wat('stringy')
+wat / 'stringy'
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-string.png?raw=true)
@@ -176,13 +178,13 @@ wat('stringy')
 See the docstrings and the signature of a function or a method to see how to use it.
 
 ```python
-wat(str.split)
+wat / str.split
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-str-split.png?raw=true)
 
-### Look up variables
-Check what's inside, list the value of variables and their types to see what's really inside the inspected object.
+### Look up attributes
+List the attribues and their types to see what's really inside the inspected object.
 ```python
 wat / re.match('(\d)_(.*)', '1_title')
 ```
@@ -244,6 +246,13 @@ wat / __builtins__
 ### Look up local variables
 ```python
 wat()
+# or
+wat.locals
+```
+
+### Look up global variables
+```python
+wat.globals
 ```
 
 

{nuclear-2.2.0 → nuclear-2.2.3}/README.md

@@ -121,13 +121,13 @@ with the following **modifiers**:
 - `.nodocs` to hide documentation for functions and classes
 - `.all` to include all available information
 
-You can chain modifiers, e.g. `wat.long.dunder / object`.
+You can chain modifiers, e.g. `wat.long.dunder.nodocs / object`.
 
 Call `wat()` to inspect `locals()` variables.
 
 Type `wat` in the interpreter to learn more about this object itself.
 
-## Use cases
+## Use Cases Examples
 
 ### Determine type
 In a dynamic typing language like Python, it's often hard to determine the type of an object. WAT Inspector can help you with that by showing the name of the type with the module it comes from.
@@ -147,12 +147,14 @@ type: django.contrib.auth.models.User
 parents: django.contrib.auth.models.AbstractUser, django.contrib.auth.base_user.AbstractBaseUser, django.contrib.auth.models.PermissionsMixin, django.db.models.base.Model, django.db.models.utils.AltersData
 ```
 
+Now that you've identified the actual type, you can put the type annotations in your code to reduce the confusion.
+
 ### Look up methods
 Listing methods, functions and looking up their signature is extremely beneficial to see how to use them.
 Plus, you can read their docstrings.
 
 ```python
-wat('stringy')
+wat / 'stringy'
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-string.png?raw=true)
@@ -161,13 +163,13 @@ wat('stringy')
 See the docstrings and the signature of a function or a method to see how to use it.
 
 ```python
-wat(str.split)
+wat / str.split
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-str-split.png?raw=true)
 
-### Look up variables
-Check what's inside, list the value of variables and their types to see what's really inside the inspected object.
+### Look up attributes
+List the attribues and their types to see what's really inside the inspected object.
 ```python
 wat / re.match('(\d)_(.*)', '1_title')
 ```
@@ -229,6 +231,13 @@ wat / __builtins__
 ### Look up local variables
 ```python
 wat()
+# or
+wat.locals
+```
+
+### Look up global variables
+```python
+wat.globals
 ```
 
 

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/inspection/inspection.py

@@ -141,7 +141,7 @@ def _iter_attributes(obj: Any, config: InspectConfig) -> Iterable[InspectAttribu
 def _get_attribute_value(obj: Any, key: str) -> Any:
     try:
         return getattr(obj, key)
-    except AttributeError as e:
+    except BaseException as e:
         return e
 
 
@@ -171,8 +171,8 @@ def _get_callable_signature(name: str, obj: Any) -> Optional[str]:
 def _get_source_code(obj: Any) -> Optional[str]:
     try:
         return std_inspect.getsource(obj)
-    except (OSError, TypeError, IndentationError):
-        return None
+    except (OSError, TypeError, IndentationError) as e:
+        return f'failed to get source code: {type(e)}: {e}'
 
 
 def _get_doc(obj: Any, long: bool) -> Optional[str]:
@@ -244,9 +244,9 @@ def _format_dict_value(dic: Dict, indent: int) -> str:
         return f'{STYLE_YELLOW}{{}}{RESET}'
 
 
-def _format_list_value(l: List, indent: int) -> str:
+def _format_list_value(lst: List, indent: int) -> str:
     lines: List[str] = []
-    for value in l:
+    for value in lst:
         value_str = _format_value(value, indent)
         lines.append('    ' * indent + f'{value_str},')
     if lines:

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/sublog/context_error.py

@@ -22,7 +22,7 @@ class ContextError(RuntimeError):
             self.__cause__ = cause
 
     def __str__(self) -> str:
-        e: Exception = self
+        e: Optional[BaseException] = self
         layers = []
         while e is not None:
             if isinstance(e, ContextError):

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/sublog/exception.py

@@ -17,7 +17,7 @@ def exception_details(e: BaseException) -> str:
     traceback_str = ', '.join(traceback_lines)
     cause = _root_cause_type(e)
     error_msg = _error_message(e)
-    return f'{error_msg}: cause={cause}, traceback={traceback_str}'
+    return f'{error_msg}, cause={cause}, traceback={traceback_str}'
 
 
 def extended_exception_details(e: BaseException) -> Tuple[str, Dict]:

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/sublog/logging.py

@@ -1,31 +1,34 @@
 from contextlib import contextmanager
 from datetime import datetime, timezone
 import logging
+import json
 import os
 import sys
 import threading
-from typing import Dict, Any, Callable
-import json
+import time
+from typing import Dict, Any, Callable, List, Optional
 
 from colorama import init, Fore, Style
 
 from nuclear.sublog.context_error import ContextError
 from nuclear.sublog.exception import extended_exception_details
+from nuclear.utils.collections import filter_not_none
 from nuclear.utils.env import is_env_flag_enabled
 from nuclear.utils.strings import strip_ansi_colors
 
 LOG_FORMAT = f'{Style.DIM}[%(asctime)s]{Style.RESET_ALL} %(levelname)s %(message)s'
 LOG_DATE_FORMAT = r'%Y-%m-%d %H:%M:%S'
+LOG_DATE_FORMAT_UTC = r'%Y-%m-%d %H:%M:%SZ'
 ISO_DATE_FORMAT = r'%Y-%m-%dT%H:%M:%S.%fZ'
 LOGGING_LOGGER_NAME = 'nuclear.sublog'
-STRUCTURED_LOGGING = is_env_flag_enabled('STRUCTURED_LOGGING', 'false')
 
-log_level: str = os.environ.get('LOG_LEVEL', 'debug')
+log_level: str = os.environ.get('NUCLEAR_LOG_LEVEL', 'debug')
+log_level_show: bool = is_env_flag_enabled('NUCLEAR_LOG_LEVEL_SHOW', 'true')
+log_time_show: bool = is_env_flag_enabled('NUCLEAR_LOG_TIME', 'true')
 simultaneous_print_lock = threading.Lock()
 _logging_logger: logging.Logger = logging.getLogger(LOGGING_LOGGER_NAME)
-_log_state = {
-    'init': False,
-}
+_log_state = {'init': False}
+
 
 def init_logs():
     """Configure loggers: formatters, handlers and log levels"""
@@ -37,15 +40,15 @@ def init_logs():
     }
     if sys.version_info[1] >= 8:
         logging_kwargs['force'] = True
-    if not is_env_flag_enabled('STRUCTURED_LOGGING', 'false'):
+    if is_env_flag_enabled('NUCLEAR_STRUCTURED_LOGGING', 'false'):
+        logging_kwargs['datefmt'] = ISO_DATE_FORMAT
         logging.basicConfig(**logging_kwargs)
         for handler in logging.getLogger().handlers:
-            handler.setFormatter(ColoredFormatter(handler.formatter))
+            handler.setFormatter(StructuredFormatter())
     else:
-        logging_kwargs['datefmt'] = ISO_DATE_FORMAT
         logging.basicConfig(**logging_kwargs)
         for handler in logging.getLogger().handlers:
-            handler.setFormatter(StructuredFormatter(handler.formatter))
+            handler.setFormatter(ColoredFormatter())
 
     level = _get_logging_level(log_level)
     root_logger = logging.getLogger(LOGGING_LOGGER_NAME)
@@ -65,7 +68,7 @@ def get_logger(logger_name: str) -> logging.Logger:
 class ContextLogger:
     def __init__(self, ctx: Dict[str, Any]):
         self.ctx: Dict[str, Any] = ctx
-        self.structured_logging: bool = STRUCTURED_LOGGING
+        self.structured_logging: bool = is_env_flag_enabled('NUCLEAR_STRUCTURED_LOGGING', 'false')
         self.first_use = True
 
     def error(self, message: str, **ctx):
@@ -101,7 +104,7 @@ class ContextLogger:
             if display_context:
                 if message.endswith(':'):
                     message = message[:-1]
-                logger_func(f'{message}: {display_context}')
+                logger_func(f'{message}, {display_context}')
             else:
                 logger_func(message)
         
@@ -147,9 +150,8 @@ def add_context(context_name: str, log: bool = False, **ctx):
 
 
 class ColoredFormatter(logging.Formatter):
-    def __init__(self, plain_formatter):
+    def __init__(self):
         logging.Formatter.__init__(self)
-        self.plain_formatter = plain_formatter
 
     log_level_templates = {
         'CRITICAL': f'{Style.BRIGHT + Fore.RED}CRIT {Style.RESET_ALL}',
@@ -160,18 +162,30 @@ class ColoredFormatter(logging.Formatter):
     }
 
     def format(self, record: logging.LogRecord) -> str:
-        if record.levelname in self.log_level_templates:
-            record.levelname = self.log_level_templates[record.levelname].format(record.levelname)
-        line: str = self.plain_formatter.format(record)
+        part_levelname = self.log_level_templates.get(record.levelname, record.levelname) if log_level_show else None
+        part_message = record.msg
+        part_time = self.format_time()
+        parts: List[str] = filter_not_none([part_time, part_levelname, part_message])
+        line = ' '.join(parts)
         if not sys.stdout.isatty():
             line = strip_ansi_colors(line)
         return line
+    
+    @staticmethod
+    def format_time() -> Optional[str]:
+        if not log_time_show:
+            return None
+        now_tz = datetime.now().astimezone()
+        if time.timezone == 0:
+            time_formatted = now_tz.strftime(LOG_DATE_FORMAT_UTC)
+        else:
+            time_formatted = now_tz.strftime(LOG_DATE_FORMAT)
+        return f'{Style.DIM}[{time_formatted}]{Style.RESET_ALL}'
 
 
 class StructuredFormatter(logging.Formatter):
-    def __init__(self, plain_formatter):
+    def __init__(self):
         logging.Formatter.__init__(self)
-        self.plain_formatter = plain_formatter
 
     def format(self, record: logging.LogRecord) -> str:
         timestamp: float = record.created

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/utils/collections.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Iterable, TypeVar, List, Union
+from typing import Any, Callable, Iterable, TypeVar, List, Union, Optional
 
 T = TypeVar('T')
 
@@ -9,7 +9,7 @@ def chunks(lst: List[T], n: int) -> Iterable[List[T]]:
         yield lst[i:i + n]
 
 
-def deduplicate_latest(items: list[T], key: Callable[[T], Any]) -> list[T]:
+def deduplicate_latest(items: List[T], key: Callable[[T], Any]) -> List[T]:
     """Deduplicate items in the list by key. Keep the earliest items first, remove the latest duplicates"""
     ids = set()
     dedup_items: List[T] = []
@@ -21,7 +21,7 @@ def deduplicate_latest(items: list[T], key: Callable[[T], Any]) -> list[T]:
     return dedup_items
 
 
-def deduplicate_earliest(items: list[T], key: Callable[[T], Any]) -> list[T]:
+def deduplicate_earliest(items: List[T], key: Callable[[T], Any]) -> List[T]:
     """Deduplicate items in the list by key. Keep the latest items, remove the earliest duplicates"""
     ids = set()
     dedup_items: List[T] = []
@@ -42,3 +42,7 @@ def flatten(collection: Iterable[Union[T, List[T]]]) -> List[T]:
         else:
             flat.append(item)
     return flat
+
+
+def filter_not_none(items: List[Optional[T]]) -> List[T]:
+    return [item for item in items if item is not None]

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear/utils/time.py

@@ -14,6 +14,11 @@ def now() -> datetime:
     return datetime.now(timezone.utc)
 
 
+def now_tz() -> datetime:
+    """Return current datetime with local timezone set"""
+    return datetime.now().astimezone()
+
+
 def now_timestamp() -> int:
     return datetime_to_timestamp(now())
 

nuclear-2.2.3/nuclear/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.3"

{nuclear-2.2.0 → nuclear-2.2.3}/nuclear.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nuclear
-Version: 2.2.0
+Version: 2.2.3
 Summary: Declarative parser for command line interfaces
 Home-page: https://github.com/igrek51/nuclear
 Author: igrek51
@@ -136,13 +136,13 @@ with the following **modifiers**:
 - `.nodocs` to hide documentation for functions and classes
 - `.all` to include all available information
 
-You can chain modifiers, e.g. `wat.long.dunder / object`.
+You can chain modifiers, e.g. `wat.long.dunder.nodocs / object`.
 
 Call `wat()` to inspect `locals()` variables.
 
 Type `wat` in the interpreter to learn more about this object itself.
 
-## Use cases
+## Use Cases Examples
 
 ### Determine type
 In a dynamic typing language like Python, it's often hard to determine the type of an object. WAT Inspector can help you with that by showing the name of the type with the module it comes from.
@@ -162,12 +162,14 @@ type: django.contrib.auth.models.User
 parents: django.contrib.auth.models.AbstractUser, django.contrib.auth.base_user.AbstractBaseUser, django.contrib.auth.models.PermissionsMixin, django.db.models.base.Model, django.db.models.utils.AltersData
 ```
 
+Now that you've identified the actual type, you can put the type annotations in your code to reduce the confusion.
+
 ### Look up methods
 Listing methods, functions and looking up their signature is extremely beneficial to see how to use them.
 Plus, you can read their docstrings.
 
 ```python
-wat('stringy')
+wat / 'stringy'
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-string.png?raw=true)
@@ -176,13 +178,13 @@ wat('stringy')
 See the docstrings and the signature of a function or a method to see how to use it.
 
 ```python
-wat(str.split)
+wat / str.split
 ```
 
 ![](https://github.com/igrek51/nuclear/blob/master/docs/img/wat-str-split.png?raw=true)
 
-### Look up variables
-Check what's inside, list the value of variables and their types to see what's really inside the inspected object.
+### Look up attributes
+List the attribues and their types to see what's really inside the inspected object.
 ```python
 wat / re.match('(\d)_(.*)', '1_title')
 ```
@@ -244,6 +246,13 @@ wat / __builtins__
 ### Look up local variables
 ```python
 wat()
+# or
+wat.locals
+```
+
+### Look up global variables
+```python
+wat.globals
 ```
 
 

nuclear-2.2.0/nuclear/version.py

@@ -1 +0,0 @@
-__version__ = "2.2.0"