jc-debug 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

debug/__init__.py

@@ -155,7 +155,7 @@ __all__ = [
     "DebugChannel",
     "line_iter",
 ]
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 
 import inspect, os, sys, traceback
 
@@ -397,7 +397,7 @@ class DebugChannel:
 
         return self.write(seq)
 
-    def __call__(self, arg, *args, **kwargs):
+    def __call__(self, *args, **kwargs):
         """If this DebugChannel instance is simply being called, this
         method is a very simple wrapper around the write(...) emthod. If
         it is being used as a function decorator, that function entry
@@ -406,6 +406,7 @@ class DebugChannel:
 
         lines = inspect.stack(context=2)[1].code_context
         if lines and any(l.lstrip().startswith("@") for l in lines):
+            arg=args[0]
             # We're being called as a decorator.
             def f(*args, **kwargs):
                 # Record how this function is being called.
@@ -453,7 +454,7 @@ class DebugChannel:
             return f
 
         # This DebugChannel instance is being called as if it were a function.
-        return self.write(arg)
+        return self.write(*args)
 
     def writeTraceback(self, exc):
         """Write the given exception with traceback information to our
@@ -463,11 +464,14 @@ class DebugChannel:
             for line in traceback.format_exception(exc):
                 self.write(line.rstrip())
 
-    def write(self, message):
+    def write(self, message, var=None):
         """If this debug instance is enabled, write the given message
-        using the our current format. In any case, return this
-        DebugChannel instance so further operations can be performed on
-        it. E.g.:
+        using the our current format. If the var argument is given and
+        message is of type list, tuple, set, or dict, then var is
+        treated as the caller's name for the `message` parameter.
+
+        In any case, return this DebugChannel instance so further
+        operations can be performed on it. E.g.:
 
         ```python
         debug=DebugChannel(opt.debug)
@@ -494,97 +498,106 @@ class DebugChannel:
         If message is a dictionary, each key/value pair is written out
         as "key: value" to its own log line."""
 
-        if self.enabled:
-            # Update our formatted date and time if necessary.
-            t = int(get_time())  # Let's truncate at whole seconds.
-            if self._t != t:
-                t = self.time_tupler(t)
-                self._t = t
-                self.date = strftime(self.date_fmt, t)
-                self.time = strftime(self.time_fmt, t)
-            # Set local variables for date and time so they're available for output.
-            date = self.date
-            time = self.time
-            # Find the first non-ignored stack frame whence we were called.
-            pathname, basename, line = None, None, None
-            for i, frame in enumerate(inspect.stack()):
-                # This is for debugging debug.py. It turns out Python 3.6 has a bug in
-                # inspect.stack() that can return outrageous values for frame.index.
-                # (So I'm asking for only one line of context, and I've stopped using the
-                # frame's untrustworthy index value.)
-                #       print(f"""{i}:
-                #   frame:        {frame.frame!r}
-                #   filename:     {frame.filename!r}
-                #   lineno:       {frame.lineno!r}
-                #   function:     {frame.function!r}
-                #   code_context: {frame.code_context!r}
-                #   index:        {frame.index!r}""")
-                p = os.path.normpath(frame.filename)
-                if p not in self.ignore:
+        if not self.enabled:
+            return self
+
+        # Update our formatted date and time if necessary.
+        t = int(get_time())  # Let's truncate at whole seconds.
+        if self._t != t:
+            t = self.time_tupler(t)
+            self._t = t
+            self.date = strftime(self.date_fmt, t)
+            self.time = strftime(self.time_fmt, t)
+        # Set local variables for date and time so they're available for output.
+        date = self.date
+        time = self.time
+        # Find the first non-ignored stack frame whence we were called. Bail out
+        # if the calling code is to be ignored for debugging purposes.
+        pathname, basename, line = None, None, None
+        for i, frame in enumerate(inspect.stack()):
+            # This is for debugging debug.py. It turns out Python 3.6 has a bug in
+            # inspect.stack() that can return outrageous values for frame.index.
+            # (So I'm asking for only one line of context, and I've stopped using the
+            # frame's untrustworthy index value.)
+            #       print(f"""{i}:
+            #   frame:        {frame.frame!r}
+            #   filename:     {frame.filename!r}
+            #   lineno:       {frame.lineno!r}
+            #   function:     {frame.function!r}
+            #   code_context: {frame.code_context!r}
+            #   index:        {frame.index!r}""")
+            p = os.path.normpath(frame.filename)
+            if p not in self.ignore:
+                break
+                if frame.function not in self.ignore[p]:
                     break
-                    if frame.function not in self.ignore[p]:
-                        break
-            # Set some local variables so they'll be available to our callback
-            # function and for formatting.
-            pid = self.pid
-            pathname = os.path.normpath(frame.filename)
-            basename = os.path.basename(pathname)
-            line = frame.lineno
-            function = frame.function
-            if str(function) == "<module>":
-                function = "__main__"
-            code = frame.code_context
-            if code:
-                code = code[0].rstrip()
+        # Set some local variables so they'll be available to our callback
+        # function and for formatting.
+        pid = self.pid
+        pathname = os.path.normpath(frame.filename)
+        basename = os.path.basename(pathname)
+        line = frame.lineno
+        function = frame.function
+        if str(function) == "<module>":
+            function = "__main__"
+        code = frame.code_context
+        if code:
+            code = code[0].rstrip()
+        else:
+            code = None
+        indent = self.indstr * self.indlev
+        label = self.label
+
+        # If our caller provided a callback function, call that now.
+        if self.callback:
+            if not self.callback(**locals()):
+                return self  # Return without writing any output.
+
+        # Format our message and write it to the debug stream.
+        if isinstance(message, (list, set, tuple)):
+            if isinstance(message, tuple):
+                left, right = "()"
+            elif isinstance(message, set):
+                left, right = "{}"
+                message=sorted(list(message),key=lambda val:repr(val))
             else:
-                code = None
-            indent = self.indstr * self.indlev
-            label = self.label
-
-            # If our caller provided a callback function, call that now.
-            if self.callback:
-                if not self.callback(**locals()):
-                    return self  # Return without writing any output.
-
-            # Format our message and write it to the debug stream.
-            sort=False
-            if isinstance(message, (list, set, tuple)):
-                if isinstance(message, tuple):
-                    left, right = "()"
-                elif isinstance(message, set):
-                    left, right = "{}"
-                    message=sorted(list(message),key=lambda val:repr(val))
-                else:
-                    left, right = "[]"
-                messages = message
-                message = left
+                left, right = "[]"
+            messages = message
+            if var:
+                message = f"{var} ({len(messages)}):"
                 self.stream.write(self.fmt.format(**locals()))
-                for i in range(len(messages)):
-                    m = messages[i]
-                    message = f"{self.indstr}{m!r}"
-                    if i<len(messages)-1:
-                        message+=','
-                    self.stream.write(self.fmt.format(**locals()))
-                message = right
+            message = left
+            self.stream.write(self.fmt.format(**locals()))
+            for i in range(len(messages)):
+                m = messages[i]
+                message = f"{self.indstr}{m!r}"
+                if i<len(messages)-1:
+                    message+=','
                 self.stream.write(self.fmt.format(**locals()))
-            elif isinstance(message, dict):
-                messages = dict(message)
-                message = "{"
+            message = right
+            self.stream.write(self.fmt.format(**locals()))
+        elif isinstance(message, dict):
+            messages = dict(message)
+            if var:
+                message = f"{var} ({len(messages)}):"
                 self.stream.write(self.fmt.format(**locals()))
-                for i,(k,v) in enumerate(messages.items()):
-                    message = f"{self.indstr}{k!r}: {v!r}"
-                    if i<len(messages)-1:
-                        message+=','
-                    self.stream.write(self.fmt.format(**locals()))
-                message = "}"
+            message = "{"
+            self.stream.write(self.fmt.format(**locals()))
+            for i,(k,v) in enumerate(messages.items()):
+                message = f"{self.indstr}{k!r}: {v!r}"
+                if i<len(messages)-1:
+                    message+=','
                 self.stream.write(self.fmt.format(**locals()))
-            elif isinstance(message, str) and os.linesep in message:
-                messages = message
-                for message in line_iter(messages):
-                    self.stream.write(self.fmt.format(**locals()))
-            else:
+            message = "}"
+            self.stream.write(self.fmt.format(**locals()))
+        elif isinstance(message, str) and os.linesep in message:
+            # Handle multiline strings here.
+            messages = message
+            for message in line_iter(messages):
                 self.stream.write(self.fmt.format(**locals()))
-            self.stream.flush()
+        else:
+            self.stream.write(self.fmt.format(**locals()))
+        self.stream.flush()
 
         # The caller can call other DebugChannel methods on our return value.
         return self

{jc_debug-1.0.3.dist-info → jc_debug-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jc-debug
-Version: 1.0.3
+Version: 1.0.4
 Summary: Makes debugging to the console both simpler and much more powerful.
 Author-email: Jeff Clough <jeff@cloughcottage.com>
 License: MIT License
@@ -202,13 +202,12 @@ l="this is a test".split()
 s=set(l)
 d=dict(zip('abcd',l))
 
-dc("l:")(l)
-dc("s:")(s)
-dc("d:")(d)
+dc(l,'l')
+dc(s,'s')
+dc(d,'d')
 ```
 
-Notice the idiom of using dc(...)'s output as the DebugChannel instance itself,
-allowing further manipulation in the same "breath." Here's the output:
+Notice the first parameter is a data structure, and the second is the name of that data structure. This idiom creates output like this:
 
 ```python
 DC:  12: l:
@@ -289,8 +288,8 @@ line number reported in its output are something helpful to the
 caller. For instance, the source line shouldn't be anything in this
 DebugChannel class.
 
-Use the ignoreModule() method to tell the DebugChannel object ignore
-other modules, and optionally, specific functions within that
+Use the ignoreModule() method to tell the DebugChannel object to
+ignore other modules, and optionally, specific functions within that
 module.
 
 <a id="debug.DebugChannel.__init__"></a>
@@ -506,11 +505,11 @@ supported.
 #### \_\_call\_\_
 
 ```python
-def __call__(arg, *args, **kwargs)
+def __call__(*args, **kwargs)
 ```
 
 If this DebugChannel instance is simply being called, this
-method is a very simple wrapper around the write(...) emthod. If
+method is a very simple wrapper around the write(...) method. If
 it is being used as a function decorator, that function entry
 and exit are recorded to the DebugChannel, and this becomes a
 more featuresome wrapper around the write(...) method.
@@ -531,13 +530,12 @@ output stream.
 #### write
 
 ```python
-def write(message)
+def write(message, var=None)
 ```
 
 If this debug instance is enabled, write the given message
-using the our current format. In any case, return this
-DebugChannel instance so further operations can be performed on
-it. E.g.:
+using the our current format. Return this DebugChannel instance
+so further operations can be performed on it. E.g.:
 
 ```python
 debug=DebugChannel(opt.debug)

jc_debug-1.0.4.dist-info/RECORD

@@ -0,0 +1,6 @@
+debug/__init__.py,sha256=Wf9H5YeflRQGniJN0mV25VFh-ziSRizTAq-fJ2Wo0vk,21914
+jc_debug-1.0.4.dist-info/licenses/LICENSE,sha256=q63VTXVTnH1QywnYTQQ1TgL2NE0XLV9pmNTxBh8TnSY,1068
+jc_debug-1.0.4.dist-info/METADATA,sha256=32QSBaZbOTa4PVeanxuYnK1m4-tukUv-7fHkNvI9nac,15976
+jc_debug-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jc_debug-1.0.4.dist-info/top_level.txt,sha256=mcOe8k8TNE9HfR15fLTnDFWyd3DViA-MH52TaEvPL4A,6
+jc_debug-1.0.4.dist-info/RECORD,,

jc_debug-1.0.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-debug/__init__.py,sha256=6vQdS1S3T0FrC9TkCqGdjfbxJgbGciO9-X7eZbhYA30,21660
-jc_debug-1.0.3.dist-info/licenses/LICENSE,sha256=q63VTXVTnH1QywnYTQQ1TgL2NE0XLV9pmNTxBh8TnSY,1068
-jc_debug-1.0.3.dist-info/METADATA,sha256=c2yH8INFBI7TtmDLyMt978_ZAKbX6SBLgRTCAPanmLQ,16002
-jc_debug-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jc_debug-1.0.3.dist-info/top_level.txt,sha256=mcOe8k8TNE9HfR15fLTnDFWyd3DViA-MH52TaEvPL4A,6
-jc_debug-1.0.3.dist-info/RECORD,,