Python AHK – Python automation package – Automation made simple

Python is a beautiful programming language, anybody that is not convinced please read my python article to get convinced… But one thing is missing, a python automation module to help automating tasks like autohotkey. I wish there was a single python ahk module.

Python and AHK

I discovered autohotkey in 2007. It was rather simple to learn and I did program several scripts to help me in my everyday life at the computer in no time. As simple as it was too learn, I soon hit its limitations. Autohotkey was pretty annoying to pass variables in functions and process any variable or text was just a pain.

Fortunately, I found python in 2009. It was superior to autohotkey in all circumstance except that I had a rather hard time doing the very simplest automation. I did countless hours of research and testing. I even developed my own module PYHK to master python automation. The result are 5 modules that will make python automation simple. I will call those 5 modules the python automation package. From now on you will be able to automate any task in python.

Python automation package

  • SendKeysCtypes
  • PYHK
  • win32gui
  • pywinauto
  • mouse


SendKeysCtypes allows you to send keystrokes and shortcuts to any window. It is very powerful. SenkeysCtypes is a new and more stable version of SendKeys. I have had some small issues with SendKeys in the past which SendKeysCtypes solves. There is no documentation on SendKeysCtypes, but you can use the documentation from Rutherfurd for his module SendKeys.


PYHK helps you receive global hotkeys and trigger functions. PYHK is based on pyHook and makes hotkey registration very simple. The project is developed and hosted by See the PYHK end user documentation for help.


I use win32gui for simple window handling such as moving and resizing. I personally prefer win32gui for short, simple tasks. There is one problem with win32gui, there is no real help file. Fortunately, there are plenty of examples out there. Google is your friend.


I use pywinauto for more complex window tasks. An example would be if I had to access a menu within a program (like File-New). For the most part it is enough to simply use win32gui. Please refer to the pywinauto documentation for help. If you are starting out with python automation, I recommend you to just use pywinauto.


Mouse is a small module to control the mouse. This is the most robust way I have found so far. The version I use is an extension of a module I found at stackoverflow – ctypes mouse_event. You can find more info on mouse in my blog post – Control your mouse in python.

The python automation package should allow you to automate any task in python. Let me know if you have any questions. Happy coding! – Control your mouse in python

Automation of user inputs always requires to click several buttons or menus. I personally prefer to use to automate and control my mouse in python. It was posted in a forum entry on stackoverlow

The module as is works great. I did however miss some functionality: Clicking without moving the cursor. I extended to click without moving the cursor. I have noticed that very rarely you still see the cursor moving. This only happens if my computer is rather busy. I remember using PostMessage back in my old AHK days, but unfortunately I can not get it to work.

An other function I included is clicking relative coordinates. I often would rather click coordinates in a window without having to deal with where that window is actually at. On a side note, a great tool for relative coordinates especially with multiple monitors is my module python screen coordinates. It does all the conversion of coordinates and has a hit test to determine what screen you are on.

Do you know of other ways to control your mouse in python? Please share any method you know. I would really like to see a PostMessage example work. I know TableCrab has a working solution, but I didnt get a chance yet to look through all the code.

Here is my extended version of

import win32gui, win32api, win32con, ctypes

class Mouse:
    """It simulates the mouse"""
    MOUSEEVENTF_MOVE = 0x0001 # mouse move
    MOUSEEVENTF_LEFTDOWN = 0x0002 # left button down
    MOUSEEVENTF_LEFTUP = 0x0004 # left button up
    MOUSEEVENTF_RIGHTDOWN = 0x0008 # right button down
    MOUSEEVENTF_RIGHTUP = 0x0010 # right button up
    MOUSEEVENTF_MIDDLEDOWN = 0x0020 # middle button down
    MOUSEEVENTF_MIDDLEUP = 0x0040 # middle button up
    MOUSEEVENTF_WHEEL = 0x0800 # wheel button rolled
    MOUSEEVENTF_ABSOLUTE = 0x8000 # absolute move

    def _do_event(self, flags, x_pos, y_pos, data, extra_info):
        """generate a mouse event"""
        x_calc = 65536L * x_pos / ctypes.windll.user32.GetSystemMetrics(self.SM_CXSCREEN) + 1
        y_calc = 65536L * y_pos / ctypes.windll.user32.GetSystemMetrics(self.SM_CYSCREEN) + 1
        return ctypes.windll.user32.mouse_event(flags, x_calc, y_calc, data, extra_info)

    def _get_button_value(self, button_name, button_up=False):
        """convert the name of the button into the corresponding value"""
        buttons = 0
        if button_name.find("right") >= 0:
            buttons = self.MOUSEEVENTF_RIGHTDOWN
        if button_name.find("left") >= 0:
            buttons = buttons + self.MOUSEEVENTF_LEFTDOWN
        if button_name.find("middle") >= 0:
            buttons = buttons + self.MOUSEEVENTF_MIDDLEDOWN
        if button_up:
            buttons = buttons << 1
        return buttons

    def move_mouse(self, pos):
        """move the mouse to the specified coordinates"""
        (x, y) = pos
        old_pos = self.get_position()
        x =  x if (x != -1) else old_pos[0]
        y =  y if (y != -1) else old_pos[1]
        self._do_event(self.MOUSEEVENTF_MOVE + self.MOUSEEVENTF_ABSOLUTE, x, y, 0, 0)

    def press_button(self, pos=(-1, -1), button_name="left", button_up=False):
        """push a button of the mouse"""
        self._do_event(self.get_button_value(button_name, button_up), 0, 0, 0, 0)

    def click(self, pos=(-1, -1), button_name= "left"):
        """Click at the specified placed"""
##        self.move_mouse(pos)
        self._do_event(self._get_button_value(button_name, False)+self._get_button_value(button_name, True), 0, 0, 0, 0)

    def double_click (self, pos=(-1, -1), button_name="left"):
        """Double click at the specifed placed"""
        for i in xrange(2):
  , button_name)

    def get_position(self):
        """get mouse position"""
        return win32api.GetCursorPos()
#Added functions
    def invisible_click(self,pos=(-1, -1), button_name="left"):
        """Click in specified place without moving mouse"""
        xcur,ycur = win32gui.GetCursorPos()

    def invisible_click_rel(self,handle,pos, button_name="left"):
        """Click in window coordinates without moving mouse"""
        #get window info
        xleft, ytop, xright, ybottom = win32gui.GetWindowRect(handle)

        xcur,ycur = win32gui.GetCursorPos()


if __name__ == '__main__':
##    p = (210,260)
##    print win32gui.GetForegroundWindow()
##    mouse = Mouse()
##    mouse.invisible_click_rel(win32gui.GetForegroundWindow(),p)

I hope it helps you, please let me know about questions. Comments are always welcome! – Get google PageRank with python

I spend several hours trying to find a python script that would return google PageRank with a python script. There seems to be a script out there that was working in 2010 from Corey Goldberg. It is not working for me. I looked around for quite a bit till I found a python script on GitHub. The script is sponsored by Phurix and uses toolbar queries. I decided to republish it with a small modification:

#!/usr/bin/env python

# Google Pagerank Checksum Algorithm (Firefox Toolbar)
# Downloaded from
# Requires: Python >= 2.4

# Versions:
# 0.2 - Fixed a minor formatting bug
# 0.1 - Public release

# Settings

# Function definitions
def GetHash (query):
    SEED = "Mining PageRank is AGAINST GOOGLE'S TERMS OF SERVICE. Yes, I'm talking to you, scammer."
    Result = 0x01020345
    for i in range(len(query)) :
        Result ^= ord(SEED[i%len(SEED)]) ^ ord(query[i])
        Result = Result >> 23 | Result << 9
        Result &= 0xffffffff
    return '8%x' % Result

def GetPageRank (query):
    import httplib
    conn = httplib.HTTPConnection(prhost)
    hash = GetHash(query)
    path = prpath % (hash,query)
    conn.request("GET", path)
    response = conn.getresponse()
    data =
    return data.split(":")[-1]

if __name__ == "__main__" :
    print GetPageRank("")

I did modify the original script a tiny bit to only return the page rank as a string. That is it. I hope it helps you, let me know comments or questions and I will try to answer as good as I can.

Distributing icon images – base64 encoding and decoding in python with ImagePack

If you ever have to distribute code that has to access image files, you have probably come across the problem: How do you decode and encode image files such that you can distribute your code without attaching a plethora of files and folders to it.

One solution is the img2py module. I always had problems with the transparency of the icon files if I was to recreate them after encoding and decoding. I couldn’t find too much help online which is when I decided to give base64 encoding a try.

I got the original idea from stack overflow python – Endcoding image files with base 64. They showed me how base64 encode an icon image file:

with open("path/to/file.png", "rb") as f:
    data =
    print data.encode("base64")

This and some code I found on daniweb wxPython Custom Icon

# this is a base64 encoded icon image
ico1_b64 = \
# convert back to binary to save it
ico1 = base64.b64decode(ico1_b64)
fout = open("zzz77.ico","wb")

allowed me to put everything together to create a very neat python module I call ImagePack.

ImagePack allows you to automatically encode and decode icon image files. It decodes all icon files in your current directory and subdirectories and stores all necessary info in a python file You can than simply import ImageUNpack and run ImageUNpack.unpack() from within your code and all necessary folders and icons get created relative to the execution path of your code. Simple and beautiful – the way I like it!