DEV Community: Alex Bender

Python debugger aliases

Alex Bender — Thu, 12 Nov 2020 10:41:56 +0000

Hello all! In this note I'd like to collect some useful aliases which you can use in your .pdbrc file which you can place to your HOME folder or current dir.

So let's start from docstring of pdb module:

The debugger supports aliases, which can save typing. And
aliases can have parameters (see the alias help entry) which
allows one a certain level of adaptability to the context
under examination.

So what is an alias after all?

 alias [name [command]]

    Create an alias called _name_ that executes _command_. The 
command must not be enclosed in quotes. Replaceable 
parameters can be indicated by %1, %2, and so on, while %* is 
replaced by all the parameters. If no command is given, the 
current alias for name is shown. If no arguments are given, 
all aliases are listed.

    Aliases may be nested and can contain anything that can 
be legally typed at the pdb prompt. Note that internal pdb 
commands can be overridden by aliases. Such a command is then
 hidden until the alias is removed. Aliasing is recursively
 applied to the first word of the command line; all other 
words in the line are left alone.

Pretty simple, right?
Yet so powerful. Next in documentation we ca see two examples:

# Print instance variables (usage "pi classInst")
alias pi for k in %1.__dict__.keys(): print("%1.",k,"=",%1.__dict__[k])
# Print instance variables in self
alias ps pi self

The second one shows that aliases could be recursively applied to the first word of the command line meaning that alias ps pi self will be expanded further. Each alias handled in Pdb.precmd method which accepts one argument -- line:

...
        args = line.split()
        while args[0] in self.aliases:
            line = self.aliases[args[0]]
...

So what does first alias do?
Let's take a look. Write some code to provide a context to our tests.

class Spam():
    """Run Away! Run Away!"""
    def __init__(self, ham):
        self.ham = ham

    def egg(self):
        print(self.ham)


spam = Spam('ham')
spam.egg()

Run this file with pdb3 command, see the (Pdb) prompt and enter l which stands for list:

pdb3 /tmp/spam.py 
> /tmp/spam.py(1)<module>()
-> class Spam():
(Pdb) l
  1  -> class Spam():
  2         """Run Away! Run Away!"""
  3         def __init__(self, ham):
  4             self.ham = ham
  5     
  6         def egg(self):
  7             print(self.ham)
  8     
  9     
 10     spam = Spam('ham')
 11     spam.egg()
(Pdb)

Then enter n two times, so we will be here:

(Pdb) l
  6         def egg(self):
  7             print(self.ham)
  8     
  9     
 10     spam = Spam('ham')
 11  -> spam.egg()
[EOF]
(Pdb)

Now let's create an alias:

(Pdb) alias for k in %1.__dict__.keys(): print("{}.{} = {}".format(%1, k, %1.__dict__[k]))

It's a slightly changed version of the alias from the documentation.
Now let's use it:

(Pdb) pi spam
<__main__.Spam object at 0x7effec0f3358>.ham = ham
(Pdb)

Hmm.. not much...
Let's try this:

(Pdb) pi Spam
<class '__main__.Spam'>.__module__ = __main__
<class '__main__.Spam'>.__doc__ = Run Away! Run Away!
<class '__main__.Spam'>.__init__ = <function Spam.__init__ at 0x7fd414c622f0>
<class '__main__.Spam'>.egg = <function Spam.egg at 0x7fd414c62268>
<class '__main__.Spam'>.__dict__ = <attribute '__dict__' of 'Spam' objects>
<class '__main__.Spam'>.__weakref__ = <attribute '__weakref__' of 'Spam' objects>

Yeah, much better!
Now let's try ps spam:

(Pdb) ps spam
*** NameError: name 'self' is not defined

What do we have here is an usage of the alias out of context.
Let's check alias again to refresh it in mind:

(Pdb) alias ps
ps = pi self

And alias pi

(Pdb) alias pi
pi = for k in %1.__dict__.keys(): print("{}.{} = {}".format(%1, k, %1.__dict__[k]))

So pi accepts one argument: %1, and ps tries to pass self to that alias and fails because self is not in context. Let's define it and try again:

(Pdb) self = Spam
(Pdb) ps
<class '__main__.Spam'>.__module__ = __main__
<class '__main__.Spam'>.__doc__ = Run Away! Run Away!
<class '__main__.Spam'>.__init__ = <function Spam.__init__ at 0x7fdbc40f1e18>
<class '__main__.Spam'>.egg = <function Spam.egg at 0x7fdbc40f1d90>
<class '__main__.Spam'>.__dict__ = <attribute '__dict__' of 'Spam' objects>
<class '__main__.Spam'>.__weakref__ = <attribute '__weakref__' of 'Spam' objects>

We cheated a bit here. As described in the documentation aliases are treated as commands typed directly into the prompt meaning that all needed ingredients must be prepared to digest. You can treat aliases as functions which accepts n variables which would be taken from locals or globals.
And where variable self is usually defined? In the class methods.
Let's restart our session with restart command (You can check all available commands typing help into prompt).
You don't need worry about lost progress because restart will handle everything automatically: all breakpoints and defined aliases will be there at your service.

(Pdb) restart
Restarting /tmp/spam.py with arguments:
    /tmp/spam.py
> /tmp/spam.py(1)<module>()
-> class Spam():
(Pdb) l
  1  -> class Spam():
  2         """Run Away! Run Away!"""
  3         def __init__(self, ham):
  4             self.ham = ham
  5     
  6         def egg(self):
  7             print(self.ham)
  8     
  9     
 10     spam = Spam('ham')
 11     spam.egg()
(Pdb) b 7
Breakpoint 1 at /tmp/spam.py:7
(Pdb) c
> /tmp/spam.py(7)egg()
-> print(self.ham)

Now let's restart, list code, put breakpoint at line 7 and continue execution.
We end up at line 7 as we supposed to.
Let's check ps:

(Pdb) ps
<__main__.Spam object at 0x7fc94d49cef0>.ham = ham

We do not get errors because self is already defined.

That was short demo of aliases usage in pdb.

Be aware that aliases are executed in the current context so they can clutter with your variables:

  6 B->     def egg(self):
  7             print(self.ham)
(Pdb) aaa=1
(Pdb) bbb=2
(Pdb) alias clutter aaa=bbb
(Pdb) locals()['aaa'], locals()['bbb']
(1,2)
(Pdb) clutter
(Pdb) locals()['aaa'], locals()['bbb']
(2,2)

After executing clutter alias variable aaa got new value. So be sure to use variable names which are unique, prefix them with ___ as an example.

And I've got some more to share:

kf = __tmp = dir(%1); __filter = [k for k in __tmp if '%2' in k]; print(__filter); del __tmp; del __filter
pi = for k in %1.__dict__.keys(): print("{}.{} = {}".format(%1, k, %1.__dict__[k]))
ps = pi self
source = import inspect; print(inspect.getsource(%1))

Please share your snippets if you have anything useful, let's learn together. Debugging is pretty important skill to master so do not hesitate to read documentation on Pdb and source code.
Thanks for reading!

The Critical Engineer

Alex Bender — Sat, 21 Mar 2020 20:13:13 +0000

Who is The Critical Engineer? And what is critical engineering at all?
I found this site, I don't remember when and how. But it still sits in my mind. Another way to see world. The group of engineers and artists gathered once and wrote that manifesto out of 10 (zero based) items: here is the beginning.

0. The Critical Engineer considers Engineering to be the most transformative language of our time, shaping the way we move, communicate and think. It is the work of the Critical Engineer to study and exploit this language, exposing its influence.

https://criticalengineering.org/

Common Voice

Alex Bender — Fri, 20 Mar 2020 22:07:03 +0000

For some reason clicking by "write a post" wiped my story, so here would be short one instead:
I want to share some interesting places I found here and there, maybe they could be interesting for someone else.

Take a look at "Common Voice". The aim of the project is to build a dataset of voices, you can help donating your sample of voice or validating existing one.

https://voice.mozilla.org/en

To be continued...

V is new black

Alex Bender — Mon, 29 Jul 2019 09:54:48 +0000

I've been writing about the new language called V, it's pretty interesting and promising. But my draft post got overwritten by new empty post. And I don't remember much what I've wrote there. That's why here is a link.

Just take a look, it won't take long: https://vlang.io/

What do you think about it?

New feature suggestion: map

Alex Bender — Fri, 20 Jul 2018 04:44:05 +0000

Hello guys!
Dev.to is so cool that I can't stop thinking about it.
So today I'd like to introduce you to the new feature suggestion: The Social Networking Map!
I think that programming is about communicating with each other and it's always interesting to know what area your mesh is covering, so here is the proposal:

Add new section to settings page with a map of globe, where 3 different type of connections could be viewed:

who is following you
who are you following
and (probably) network of tags

Giving that it is possible to easily convert that numbers (following\followers) into the beautiful map.

There are different possible suited types of map, to name some of it:

To display connections: Faux-3D Arcs: http://bl.ocks.org/dwtkns/4973620
To display density: https://beta.observablehq.com/@mbostock/d3-choropleth

Color of the lines could be taken from the user's color preference.

Thanks!

Settings is not an article

Alex Bender — Wed, 18 Jul 2018 12:40:47 +0000

I'm trying to edit and save my profile -- getting error that:

1 error prohibited this article from being saved:

I understand that settings are build on top of Articles/post engine, but it's little bit weird.
Also, I'm getting this message because Employer url is not a valid URL.
I've entered . Indeed this is not valid URL. I suppose that validator didn't allow that data because there is no protocol name. But, is it so important here? Are there many ftp based employer urls? or any of Uniform Resource Identifier (URI) Schemes.
I can bet my boots that there are not.
So may be it would be more convenient for users to fill in their employer urls without scheme, assuming http(s) by default?

P.S.: About the slashes

Solving the Cretan maze

Alex Bender — Tue, 17 Jul 2018 09:33:37 +0000

So let's play the game

Recently Leonora Der published great piece of work: Solve the Cretan maze.
That challenge is really interesting because It doesn't require you to write a lot of code, but is still interesting to solve and think about it. Additional thanks for the design: simple and great.
So I've decided to implement basic interface for that game, of course written in Python.
My first intention was to write something like that:

...
class MazeRunner():

    def __init__(self, username, password):
        # For BasicHTTPAuth
        self.username = username
        self.password = password

    def create_maze(self):
        """POST - /api/mazes

        Will let you start the maze
        """

    def start_loop(self):
        ...
...

And I even did that. Wrote a dozen methods, mostly non implemented yet but they are just stubs, you know. It covered all API provided. A few days later I've started to dig around pdb, then its parent bdb, and then back to pdb. I've noticed something interesting: here is a piece of source code for the Pdb class, file Lib/pdb.py

...

line_prefix = '\n-> '   # Probably a better default

class Pdb(bdb.Bdb, cmd.Cmd):

    _previous_sigint_handler = None

...

wait, what was that? That second parent class. It is cmd. So as usual, Python standard lib has solved a big part of my problems. I started to read docs on this module: cmd. It appears that I've been already using this interface for more than half of decade without even noticing that: Python debuggers like pdb, ipdb, pudb.. this common REPL appears everywhere.

>>> import pdb
>>> pdb.set_trace()
--Return--
> <stdin>(1)<module>()->None
(Pdb) ?

Documented commands (type help <topic>):
========================================
EOF    bt         cont      enable  jump  pp       run      unt   
a      c          continue  exit    l     q        s        until 
alias  cl         d         h       list  quit     step     up    
args   clear      debug     help    n     r        tbreak   w     
b      commands   disable   ignore  next  restart  u        whatis
break  condition  down      j       p     return   unalias  where 

Miscellaneous help topics:
==========================
exec  pdb

Undocumented commands:
======================
retval  rv

(Pdb)

Let's write something useful

What do we want to solve (what do we need?)

Implement all API calls
Document them all
Make it clear for the user what to do (document it again and provide help)

For implementing cmd interface we have to know something:

the main function is cmdloop.

From the documentation:

Cmd.cmdloop(intro=None)

Repeatedly issue a prompt, accept input,
parse an initial prefix off the received input,
and dispatch to action methods, passing them the
remainder of the line as argument.

command handlers are methods called do_<command-name>

An interpreter instance will recognize a command name foo if and only
if it has a method do_foo()

for providing help for this command we have to implement help_<command-name> method
standard do_help method calls all help_* methods.
there are pre- and post- handlers for commands: precmd and postcmd methods.


Cmd.precmd(line)

    Hook method executed just before the command line line is interpreted, but
after the input prompt is generated and issued. This method is a stub in Cmd;
it exists to be overridden by subclasses. The return value is used as
the command which will be executed by the onecmd() method; the precmd()
implementation may re-write the command or simply return line unchanged.

Cmd.postcmd(stop, line)

    Hook method executed just after a command dispatch is finished.
This method is a stub in Cmd; it exists to be overridden by subclasses.
line is the command line which was executed, and stop is a flag which
indicates whether execution will be terminated after the call to postcmd();
this will be the return value of the onecmd() method. The return value of
this method will be used as the new value for the internal flag which
corresponds to stop; returning false will cause interpretation to continue.

Ok, so enough talking

Since I prefer using Python over other languages I'm going to change the name of my cmd class to MazeCrawler because snakes does not run, yeah? But still, it's little bit boring. I'm gonna go little bit further and rename it to (with regards to It's always sunny in Philadelphia) : MazeKroller

import cmd                                                                                                                                                                                                   

class MazeKroller(cmd.Cmd):
    """Interface for walking through the maze

    https://coding-challanges.herokuapp.com/challanges/maze
    """                                                                                                                                                  

    intro = "Welcome to Maze shell. Type `?' or `help' to list commands.\n"
    prompt = '~ '  # Because it's a snake!

For now we have only one method -- it is init. And we have to implement rest of the REST.
We need to be able to:

create the maze,
navigate through it
and pick up the coins to win (actually to get out from the maze). Also a couple of methods should be implemented for usability: get info and give up. Here is the stubs for it:

class MazeKroller(cmd.Cmd):
    """Interface for crawling through the maze

    https://coding-challanges.herokuapp.com/challanges/maze
    """
    intro = "Welcome to Maze shell. Type `?' or `help' to list commands.\n"
    prompt = "~ "

    def do_init(self, user, password):
        """Credentials for BasicHTTPAuth."""
        self.user = user
        self.password = password

    def do_create_maze(self, size):
        """Create a new maze.
        Now you have 3600 seconds to escape.

        POST /api/mazes\n"""

    def do_info(self, maze_id):
        """Get some general data about your maze

        GET - /api/mazes/{id}\n""" 

    def do_get_cells(self, maze_id):
        """See the cells around you.

        GET - /api/mazes/{id}/steps\n"""

    def do_get_coin(self):
        """Pick up a coin.

        POST - /api/mazes/{id}/coins\n"""

    def do_giveup(self):
        """Gives up the game.

        DELETE /api/mazes/{id}\n"""

So here we have a basic class for our MazeKroller.
This class does nothing right now, but could be instantiated with

MazeKroller().cmdloop()

Play around little bit with it and in the next post I will provide you with implementation of that methods.

Stay tuned!

Makefile with help message

Alex Bender — Fri, 29 Jun 2018 13:33:23 +0000

The Makefile

The idea is pretty simple: Add comment to each target from Makefile
Here is the clean target from makefile:

clean:
    rm -f *.o

Help message here is redundant but in sake of completeness let's add it:

clean: ## Clean directory
    rm -f *.o

Now we need filter out all docstrings: here is the command for that:

ag '^[a-zA-Z_-]+:.*?## .*$$' --nofilename Makefile \
| sort \
| awk 'BEGIN{FS=": ## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

Here I'm using silver-searcher aka ag.
Seems complicated, yeah? So what does that command do?

filters out lines basing on this regular expression: '^[a-zA-Z_-]+:.*?## .*$$', namely any string like "target_name: ##doc string".
sorts output with command sort
formats output with awk command BEGIN{FS=": ## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}

Let's look at that command. What do we have?

BEGIN{FS=": ## "}
{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}

From the documentation: A BEGIN rule is executed once only, before the first input record is read. So it simply reads input and sets the Field separator to ": ##" to split input on two parts: before and after the FS.

Second part just prints filtered output with formatting and colors.

One more thing -- we have to define default target to be executed when make command launched without arguments:
.DEFAULT_GOAL := help
Now we are ready.

Here is what we have as a result:

Save that gist into Makefile and run make command in your terminal from the folder with Makefile. If everything is ok you will get formatted and colored output: all targets defined in Makefile:

$ make
clean                          Clean directory
help                           Help target

Dependencies

But aware that awk and silver-searcher are required for that snippet to work.
(Btw, ag could be replaced with grep, if needed with some modifications I guess.)

And remember -- documentation's important!

Doubled welcome email

Alex Bender — Fri, 29 Jun 2018 09:05:37 +0000

Problem description:

I've changed my primary email address here and got the "Welcome to dev.to" email.
Again.
Because I'm already registered user.

Proposition

Changing email should not trigger procedure of sending welcome email. Instead user should be notified about that change.