jc-debug 1.0.2__tar.gz → 1.0.3__tar.gz

{jc_debug-1.0.2 → jc_debug-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jc-debug
-Version: 1.0.2
+Version: 1.0.3
 Summary: Makes debugging to the console both simpler and much more powerful.
 Author-email: Jeff Clough <jeff@cloughcottage.com>
 License: MIT License
@@ -42,8 +42,8 @@ Dynamic: license-file
 
 # debug
 
-This debug module a class named DebugChannel, instances of which are
-useful for adding temporary or conditional debug output to CLI scripts.
+This debug module a class named DebugChannel, instances of which are useful for
+adding temporary or conditional debug output to CLI scripts.
 
 The minimal boilerplate is pretty simple:
 
@@ -53,9 +53,9 @@ from debug import DebugChannel
 dc=DebugChannel(True)
 ```
 
-By default, DebugChannels are created disabled (the write no output), so
-the `True` above enables `dc` during its instantiation so it needn't be
-enabled later.
+By default, DebugChannels are created disabled (the write no output), so the
+`True` above enables `dc` during its instantiation so it needn't be enabled
+later.
 
 A more common way of handling this is ...
 
@@ -73,18 +73,18 @@ dc.enable(opt.debug)
 ...
 ```
 
-This enables the `dc` DebugChannel instance only if --debug is given on
-the script's command line.
+This enables the `dc` DebugChannel instance only if --debug is given on the
+script's command line.
 
 By default, output is sent to stdandard error and formatted as:
 
     '{label}: [{pid}] {basename}:{line}:{function}: {indent}{message}\n'
 
-There are several variables you can include in DebugChannel's output.
-See the DebugChannel docs below for a list.
+There are several variables you can include in DebugChannel's output. See the
+DebugChannel docs below for a list.
 
-So, for example, if you want to see how your variables are behaving in a
-loop, you might do something like this:
+So, for example, if you want to see how your variables are behaving in a loop,
+you might do something like this:
 
 ```python
 from debug import DebugChannel
@@ -96,15 +96,15 @@ dc=DebugChannel(
 
 dc("Entering loop ...").indent()
 for i in range(5):
-    dc(f"i={i}").indent()
+    dc(f"{i=}").indent()
     for j in range(3):
-        dc(f"j={j}")
+        dc(f"{j=}")
     dc.undent()("Done with j loop.")
 dc.undent()("Done with i loop.")
 ```
 
-That gives you this necely indented output. The indent() and undent()
-methods are one thing that makes DebugChannels so nice to work with.
+That gives you this necely indented output. The indent() and undent() methods
+are one thing that makes DebugChannels so nice to work with.
 
     DC:   8: Entering loop ...
     DC:  10:   i=0
@@ -134,8 +134,8 @@ methods are one thing that makes DebugChannels so nice to work with.
     DC:  13:   Done with j loop.
     DC:  14: Done with i loop.
 
-That's a simple example, but you might be starting to get an idea of
-how versatile DebugChannel instances can be.
+That's a simple example, but you might be starting to get an idea of how
+versatile DebugChannel instances can be.
 
 A DebugChannel can also be used as a function decorator:
 
@@ -163,9 +163,9 @@ example2("First test",3)
 example2("Second test",2)
 ```
 
-This causes entry into and exit from the decorated function to be
-recorded in the given DebugChannel's output. If you put that into a file
-named foo.py and then run "python3 -m foo", you'll get this:
+This causes entry into and exit from the decorated function to be recorded in
+the given DebugChannel's output. If you put that into a file named foo.py and
+then run "python3 -m foo", you'll get this:
 
 ```
 DC: __main__: example2('First test',3) ...
@@ -189,6 +189,55 @@ DC: example2:     example1(...) returns None after 23µs.
 DC: __main__: example2(...) returns None after 423ms.
 ```
 
+When outputting a data structure, it's nice to be a little structured about it.
+So if you send a list, tuple, dict, or set to a DebugChannel instance as the
+whole message, it will be formatted one item at a time in the output.
+
+```python
+from debug import DebugChannel
+
+dc=DebugChannel(True,fmt="{label}: {line:3}: {indent}{message}\n")
+
+l="this is a test".split()
+s=set(l)
+d=dict(zip('abcd',l))
+
+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:
+
+```python
+DC:  12: l:
+DC:  12: [
+DC:  12:     'this',
+DC:  12:     'is',
+DC:  12:     'a',
+DC:  12:     'test'
+DC:  12: ]
+DC:  13: s:
+DC:  13: {
+DC:  13:     'a',
+DC:  13:     'is',
+DC:  13:     'test',
+DC:  13:     'this'
+DC:  13: }
+DC:  14: d:
+DC:  14: {
+DC:  14:     'a': 'this',
+DC:  14:     'b': 'is',
+DC:  14:     'c': 'a',
+DC:  14:     'd': 'test'
+DC:  14: }
+```
+
+Notice sets are output in alphabetical order (according to their repr()
+values). Since sets are unordered by nature, this makes them easier to inspect
+visually without misrepresenting their contents.
+
 That's a very general start. See DebugChannel's class docs for more.
 
 <a id="debug.DebugChannel"></a>

{jc_debug-1.0.2 → jc_debug-1.0.3}/README.md

@@ -2,8 +2,8 @@
 
 # debug
 
-This debug module a class named DebugChannel, instances of which are
-useful for adding temporary or conditional debug output to CLI scripts.
+This debug module a class named DebugChannel, instances of which are useful for
+adding temporary or conditional debug output to CLI scripts.
 
 The minimal boilerplate is pretty simple:
 
@@ -13,9 +13,9 @@ from debug import DebugChannel
 dc=DebugChannel(True)
 ```
 
-By default, DebugChannels are created disabled (the write no output), so
-the `True` above enables `dc` during its instantiation so it needn't be
-enabled later.
+By default, DebugChannels are created disabled (the write no output), so the
+`True` above enables `dc` during its instantiation so it needn't be enabled
+later.
 
 A more common way of handling this is ...
 
@@ -33,18 +33,18 @@ dc.enable(opt.debug)
 ...
 ```
 
-This enables the `dc` DebugChannel instance only if --debug is given on
-the script's command line.
+This enables the `dc` DebugChannel instance only if --debug is given on the
+script's command line.
 
 By default, output is sent to stdandard error and formatted as:
 
     '{label}: [{pid}] {basename}:{line}:{function}: {indent}{message}\n'
 
-There are several variables you can include in DebugChannel's output.
-See the DebugChannel docs below for a list.
+There are several variables you can include in DebugChannel's output. See the
+DebugChannel docs below for a list.
 
-So, for example, if you want to see how your variables are behaving in a
-loop, you might do something like this:
+So, for example, if you want to see how your variables are behaving in a loop,
+you might do something like this:
 
 ```python
 from debug import DebugChannel
@@ -56,15 +56,15 @@ dc=DebugChannel(
 
 dc("Entering loop ...").indent()
 for i in range(5):
-    dc(f"i={i}").indent()
+    dc(f"{i=}").indent()
     for j in range(3):
-        dc(f"j={j}")
+        dc(f"{j=}")
     dc.undent()("Done with j loop.")
 dc.undent()("Done with i loop.")
 ```
 
-That gives you this necely indented output. The indent() and undent()
-methods are one thing that makes DebugChannels so nice to work with.
+That gives you this necely indented output. The indent() and undent() methods
+are one thing that makes DebugChannels so nice to work with.
 
     DC:   8: Entering loop ...
     DC:  10:   i=0
@@ -94,8 +94,8 @@ methods are one thing that makes DebugChannels so nice to work with.
     DC:  13:   Done with j loop.
     DC:  14: Done with i loop.
 
-That's a simple example, but you might be starting to get an idea of
-how versatile DebugChannel instances can be.
+That's a simple example, but you might be starting to get an idea of how
+versatile DebugChannel instances can be.
 
 A DebugChannel can also be used as a function decorator:
 
@@ -123,9 +123,9 @@ example2("First test",3)
 example2("Second test",2)
 ```
 
-This causes entry into and exit from the decorated function to be
-recorded in the given DebugChannel's output. If you put that into a file
-named foo.py and then run "python3 -m foo", you'll get this:
+This causes entry into and exit from the decorated function to be recorded in
+the given DebugChannel's output. If you put that into a file named foo.py and
+then run "python3 -m foo", you'll get this:
 
 ```
 DC: __main__: example2('First test',3) ...
@@ -149,6 +149,55 @@ DC: example2:     example1(...) returns None after 23µs.
 DC: __main__: example2(...) returns None after 423ms.
 ```
 
+When outputting a data structure, it's nice to be a little structured about it.
+So if you send a list, tuple, dict, or set to a DebugChannel instance as the
+whole message, it will be formatted one item at a time in the output.
+
+```python
+from debug import DebugChannel
+
+dc=DebugChannel(True,fmt="{label}: {line:3}: {indent}{message}\n")
+
+l="this is a test".split()
+s=set(l)
+d=dict(zip('abcd',l))
+
+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:
+
+```python
+DC:  12: l:
+DC:  12: [
+DC:  12:     'this',
+DC:  12:     'is',
+DC:  12:     'a',
+DC:  12:     'test'
+DC:  12: ]
+DC:  13: s:
+DC:  13: {
+DC:  13:     'a',
+DC:  13:     'is',
+DC:  13:     'test',
+DC:  13:     'this'
+DC:  13: }
+DC:  14: d:
+DC:  14: {
+DC:  14:     'a': 'this',
+DC:  14:     'b': 'is',
+DC:  14:     'c': 'a',
+DC:  14:     'd': 'test'
+DC:  14: }
+```
+
+Notice sets are output in alphabetical order (according to their repr()
+values). Since sets are unordered by nature, this makes them easier to inspect
+visually without misrepresenting their contents.
+
 That's a very general start. See DebugChannel's class docs for more.
 
 <a id="debug.DebugChannel"></a>

{jc_debug-1.0.2 → jc_debug-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jc-debug"
-version = "1.0.2"  # Consider using a proper versioning scheme
+version = "1.0.3"  # Consider using a proper versioning scheme
 authors = [
   { name="Jeff Clough", email="jeff@cloughcottage.com" },
 ]

{jc_debug-1.0.2 → jc_debug-1.0.3}/src/debug/__init__.py

@@ -155,7 +155,7 @@ __all__ = [
     "DebugChannel",
     "line_iter",
 ]
-__version__ = "1.0.2"
+__version__ = "1.0.3"
 
 import inspect, os, sys, traceback
 
@@ -547,16 +547,23 @@ class DebugChannel:
                     return self  # Return without writing any output.
 
             # Format our message and write it to the debug stream.
-            if isinstance(message, (list, tuple)):
+            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
                 self.stream.write(self.fmt.format(**locals()))
-                for message in messages:
-                    message = self.indstr + repr(message)
+                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
                 self.stream.write(self.fmt.format(**locals()))
@@ -564,8 +571,10 @@ class DebugChannel:
                 messages = dict(message)
                 message = "{"
                 self.stream.write(self.fmt.format(**locals()))
-                for k in messages.keys():
-                    message = f"{self.indstr}{k!r}: {messages[k]!r}"
+                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 = "}"
                 self.stream.write(self.fmt.format(**locals()))

{jc_debug-1.0.2 → jc_debug-1.0.3}/src/jc_debug.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jc-debug
-Version: 1.0.2
+Version: 1.0.3
 Summary: Makes debugging to the console both simpler and much more powerful.
 Author-email: Jeff Clough <jeff@cloughcottage.com>
 License: MIT License
@@ -42,8 +42,8 @@ Dynamic: license-file
 
 # debug
 
-This debug module a class named DebugChannel, instances of which are
-useful for adding temporary or conditional debug output to CLI scripts.
+This debug module a class named DebugChannel, instances of which are useful for
+adding temporary or conditional debug output to CLI scripts.
 
 The minimal boilerplate is pretty simple:
 
@@ -53,9 +53,9 @@ from debug import DebugChannel
 dc=DebugChannel(True)
 ```
 
-By default, DebugChannels are created disabled (the write no output), so
-the `True` above enables `dc` during its instantiation so it needn't be
-enabled later.
+By default, DebugChannels are created disabled (the write no output), so the
+`True` above enables `dc` during its instantiation so it needn't be enabled
+later.
 
 A more common way of handling this is ...
 
@@ -73,18 +73,18 @@ dc.enable(opt.debug)
 ...
 ```
 
-This enables the `dc` DebugChannel instance only if --debug is given on
-the script's command line.
+This enables the `dc` DebugChannel instance only if --debug is given on the
+script's command line.
 
 By default, output is sent to stdandard error and formatted as:
 
     '{label}: [{pid}] {basename}:{line}:{function}: {indent}{message}\n'
 
-There are several variables you can include in DebugChannel's output.
-See the DebugChannel docs below for a list.
+There are several variables you can include in DebugChannel's output. See the
+DebugChannel docs below for a list.
 
-So, for example, if you want to see how your variables are behaving in a
-loop, you might do something like this:
+So, for example, if you want to see how your variables are behaving in a loop,
+you might do something like this:
 
 ```python
 from debug import DebugChannel
@@ -96,15 +96,15 @@ dc=DebugChannel(
 
 dc("Entering loop ...").indent()
 for i in range(5):
-    dc(f"i={i}").indent()
+    dc(f"{i=}").indent()
     for j in range(3):
-        dc(f"j={j}")
+        dc(f"{j=}")
     dc.undent()("Done with j loop.")
 dc.undent()("Done with i loop.")
 ```
 
-That gives you this necely indented output. The indent() and undent()
-methods are one thing that makes DebugChannels so nice to work with.
+That gives you this necely indented output. The indent() and undent() methods
+are one thing that makes DebugChannels so nice to work with.
 
     DC:   8: Entering loop ...
     DC:  10:   i=0
@@ -134,8 +134,8 @@ methods are one thing that makes DebugChannels so nice to work with.
     DC:  13:   Done with j loop.
     DC:  14: Done with i loop.
 
-That's a simple example, but you might be starting to get an idea of
-how versatile DebugChannel instances can be.
+That's a simple example, but you might be starting to get an idea of how
+versatile DebugChannel instances can be.
 
 A DebugChannel can also be used as a function decorator:
 
@@ -163,9 +163,9 @@ example2("First test",3)
 example2("Second test",2)
 ```
 
-This causes entry into and exit from the decorated function to be
-recorded in the given DebugChannel's output. If you put that into a file
-named foo.py and then run "python3 -m foo", you'll get this:
+This causes entry into and exit from the decorated function to be recorded in
+the given DebugChannel's output. If you put that into a file named foo.py and
+then run "python3 -m foo", you'll get this:
 
 ```
 DC: __main__: example2('First test',3) ...
@@ -189,6 +189,55 @@ DC: example2:     example1(...) returns None after 23µs.
 DC: __main__: example2(...) returns None after 423ms.
 ```
 
+When outputting a data structure, it's nice to be a little structured about it.
+So if you send a list, tuple, dict, or set to a DebugChannel instance as the
+whole message, it will be formatted one item at a time in the output.
+
+```python
+from debug import DebugChannel
+
+dc=DebugChannel(True,fmt="{label}: {line:3}: {indent}{message}\n")
+
+l="this is a test".split()
+s=set(l)
+d=dict(zip('abcd',l))
+
+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:
+
+```python
+DC:  12: l:
+DC:  12: [
+DC:  12:     'this',
+DC:  12:     'is',
+DC:  12:     'a',
+DC:  12:     'test'
+DC:  12: ]
+DC:  13: s:
+DC:  13: {
+DC:  13:     'a',
+DC:  13:     'is',
+DC:  13:     'test',
+DC:  13:     'this'
+DC:  13: }
+DC:  14: d:
+DC:  14: {
+DC:  14:     'a': 'this',
+DC:  14:     'b': 'is',
+DC:  14:     'c': 'a',
+DC:  14:     'd': 'test'
+DC:  14: }
+```
+
+Notice sets are output in alphabetical order (according to their repr()
+values). Since sets are unordered by nature, this makes them easier to inspect
+visually without misrepresenting their contents.
+
 That's a very general start. See DebugChannel's class docs for more.
 
 <a id="debug.DebugChannel"></a>

{jc_debug-1.0.2 → jc_debug-1.0.3}/tests/test_operations.py

@@ -92,8 +92,8 @@ DC: test_basics:     Message 2
         dc(('a',2,True))
         assert outstr()=="""\
 DC: test_basics: (
-DC: test_basics:     'a'
-DC: test_basics:     2
+DC: test_basics:     'a',
+DC: test_basics:     2,
 DC: test_basics:     True
 DC: test_basics: )
 """
@@ -102,18 +102,28 @@ DC: test_basics: )
         dc(['a',2,True])
         assert outstr()=="""\
 DC: test_basics: [
-DC: test_basics:     'a'
-DC: test_basics:     2
+DC: test_basics:     'a',
+DC: test_basics:     2,
 DC: test_basics:     True
 DC: test_basics: ]
+"""
+
+        # Test set output.
+        dc(set(['a',2,True]))
+        assert outstr()=="""\
+DC: test_basics: {
+DC: test_basics:     'a',
+DC: test_basics:     2,
+DC: test_basics:     True
+DC: test_basics: }
 """
 
         # Test dictionary output.
         dc({'a':1,2:'b','c':True})
         assert outstr()=="""\
 DC: test_basics: {
-DC: test_basics:     'a': 1
-DC: test_basics:     2: 'b'
+DC: test_basics:     'a': 1,
+DC: test_basics:     2: 'b',
 DC: test_basics:     'c': True
 DC: test_basics: }
 """