ArunRocks (Posts tagged 'python')

Mars Rover in Python and Haskell

2010-02-01T02:02:52+05:30

Last week I tried to do something which I've been planning for quite sometime. Porting a Python program into Haskell. In case you didn't know, Haskell is a purely functional programming language that's recently become a hot favourite. It has a lot of cutting edge ideas from the academic world esp laziness and strong typing. It has an interesting way to solve the 'multi-CPU problem'.

Mars Rover is a famous programming problem used by Thoughtworks in their recruitments. I first solved the problem in Python and later attempted to solve the same in Haskell. I cannot say that I ported it from Python because the approach I've used is completely different.

The Problem

A squad of robotic rovers are to be landed by NASA on a plateau on Mars.

This plateau, which is curiously rectangular, must be navigated by the rovers so that their on-board cameras can get a complete view of the surrounding terrain to send back to Earth.

A rover's position and location is represented by a combination of x and y co-ordinates and a letter representing one of the four cardinal compass points. The plateau is divided up into a grid to simplify navigation. An example position might be 0, 0, N, which means the rover is in the bottom left corner and facing North.

In order to control a rover , NASA sends a simple string of letters. The possible letters are 'L', 'R' and 'M'. 'L' and 'R' makes the rover spin 90 degrees left or right respectively, without moving from its current spot. 'M' means move forward one grid point, and maintain the same heading.

Assume that the square directly North from (x, y) is (x, y+1).

INPUT:

The first line of input is the upper-right coordinates of the plateau, the lower-left coordinates are assumed to be 0,0.

The rest of the input is information pertaining to the rovers that have been deployed. Each rover has two lines of input. The first line gives the rover's position, and the second line is a series of instructions telling the rover how to explore the plateau.

The position is made up of two integers and a letter separated by spaces, corresponding to the x and y co-ordinates and the rover's orientation.

Each rover will be finished sequentially, which means that the second rover won't start to move until the first one has finished moving.

OUTPUT

The output for each rover should be its final co-ordinates and heading.

INPUT AND OUTPUT

Test Input:

5 5
1 2 N
LMLMLMLMM
3 3 E
MMRMMRMRRM

Expected Output:

1 3 N
5 1 E

The Python solution

The Python solution is actually smaller than the problem itself. The readability isn't that great, but it is quite extensible. In fact, adding a new instruction like B(ackward) would need just one additional line. You can also extend the four cardinal directions to eight with minimal changes to the code.

    dirs = "NESW"                   # Notations for directions
    shifts=[(0,1),(1,0),(0,-1),(-1,0)] # delta vector for each direction
    # One letter function names corresponding to each robot instruction
    r = lambda x, y, a: (x, y, (a + 1) % 4)
    l = lambda x, y, a: (x, y, (a - 1 + 4) % 4)
    m = lambda x, y, a: (x + shifts[a][0], y + shifts[a][1], a)
    raw_input()                     # Ignore the grid size
    while 1:
        # parse initial position triplet
        x, y, dir = raw_input().split() 
        pos = (int(x),int(y),dirs.find(dir))
        # parse instructions
        instrns = raw_input().lower() 
        # Invoke the corresponding functions passing prev position
        for i in instrns: pos = eval('%s%s' % (i, str(pos)))
        print pos[0], pos[1], dirs[pos[2]]

The Haskell solution

I am a beginner in Haskell, so apologies for any bad coding practices. You might notice that rather than using Reflection as in the Python code, I have used Type-inference to invoke the correct function for each instruction. Yet again, this scales well while adding new instructions.

    import Data.List
    
    dirs = "NESW"
    
    shifts 0 = (0, 1)
    shifts 1 = (1, 0)
    shifts 2 = (0, -1)
    shifts 3 = (-1, 0)
    
    instrn (x, y, a) 'R' = (x, y, mod (a + 1) 4)
    instrn (x, y, a) 'L' = (x, y, mod (a - 1 + 4) 4)
    instrn (x, y, a) 'M' = (x+fst (shifts a), y+snd (shifts a), a)
    
    showpos (x, y, a) = show x ++ " " ++ show y ++ " " ++ [dirs !! a]
    finddir dirchar = 
        case elemIndex dirchar dirs of
          Nothing -> error "invalid direction"
          Just position -> position
    readpos line = (x, y, a)
            where a = finddir $ head $ drop 1 line3
                  [(y,line3)] = reads line2 :: [(Integer, String)]          
                  [(x,line2)] = reads line :: [(Integer, String)]
    
    robo = do
      posn <- getLine
      instrns <- getLine
      putStrLn (showpos (foldl instrn (readpos posn) instrns))
      robo
    
    main = do
      skip <- getLine               -- Skip reading the grid size
      robo

Key learnings

Since some of you might be interested in Haskell, I have tried to summarize my experience in Haskell programming

There are no loop constructs. So everything must be done using recursion!
Haskell I/O is very hard. This is because of my little knowledge of Monads. In fact, I solved the logic pretty quickly. It took me a while to figure out the input parsing.
Type inference catches a lot of errors. This is quite handy but error messages are sometimes confusing
I could have used Abstract Data Types for directions but it would have made the code lengthier

In short, programming in Haskell is a mind-bending exercise. Highly recommended!

PyCon India Talk 2009: Game Programming in Pyglet

2009-09-27T18:37:59+05:30

Thanks to everyone who enjoyed and commented on my talk today titled 'Accelerate Your Game Development with Pyglet'. I am happy to see so much enthusiasm within the python community for game development. This was my first lightning talk (and the first one for the day as well) and though, I slightly overshot the timelimit, it was a great experience.

The talk was about creating a simple casual game using Pyglet called 'FruitCatch'. The source code is really small and very readable. I also compared Pyglet with Pygame and why I prefer Pyglet (in certain situations:)). The demo showed the working game in the end.

You can download the game source code and presentation slides (PDF) here. I've shared this with the organisers as well, so it will be put up at the Pycon site as well

UPDATE: The video of the lightning talk is now available and has been added below:

Office Diff: An Open Source Diff for Office 2007 or 2003 documents

2009-07-21T11:27:37+05:30

This Saturday, I started working on something that many of my colleagues had complained about a long time ago. They work on reports all the time and most of these reports have small changes in each version. They are only interested in seeing what changed rather than read the entire report.

You might suggest a lot of 'diff' tools which can do the job in either Word or Textpad. The issue was that they were working with Excel spreadsheets rather than text files and I couldn't find any free or open source solution for them. So I ended up creating a new tool called Office Diff. Interestingly, it handles not just Excel, but also all the Office 2007 and 2003 file formats plus PDF and HTML formats as well. It features an intuitive GUI interface and is completely written in Python.

The next best thing was to open source it. I am using the BSD licence. I found sourceforge a good choice because they support Bazaar, my version control of choice at the moment.

Please visit Office Diff homepage for screenshots and check out the first release.

Workaround to Easy Install PIL on Windows

2008-08-30T23:13:54+05:30

This is a quick workaround for people who are using easy_install to install Python Imaging Library on Windows. Many people faced issues while doing this. I found a simple workaround for this.

You must have tried the following

C:> easy_install PIL
Searching for PIL
...
Finished processing dependencies for PIL
C:> python
Python 2.5.2 (r252:60911, Feb 21 2008, 13:11:45) [MSC v.1310 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import Image
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named Image

Now you will need to go to your site-packages directory (typically at C:\Python\Lib\site-packages) and change one line that starts with ./PIL-1.1.6-py2.5-win32.egg to simply ./PIL and change the sub-directory named similarly to PIL

Now your imports should work :smile:

V-day Special

2008-02-17T13:05:12+05:30

Here is a belated valentine's day greeting from both of us.

For all my readers, I recommend visiting the microsite I had made earlier. Now it is written entirely in web.py. Thanks to my new website host, A Small Orange, I can create and host python based applications. I agree that there is no need to design a new blog in python again, but it is a great way to learn a new (anti-) framework. Web.py applications are really small and easy to understand and therefore, has less bugs.

Guess what, Jeff Atwood owns an ASUS laptop model (W3J) that is similar to mine (F3J). He is full of praise about the decision. Considering I took at least 2 months (the standard duration for yours truly to zero into an buying decision) to arrive at the decision, it seems well worth now :).

Work Faster in Windows With Launchy and a few Python Scripts

2007-12-04T11:09:23+05:30

Launchy is a great productivity tool and a cool way to impress your friends. You can launch any application by pressing a hotkey (say Alt+Space) and the first few letters of the application for eg: typing 'gi' will display the GIMP icon and pressing Enter will launch GIMP. You can download Launchy from its website and its beta is pretty stable (and gorgeous) on my XP laptop too.

Using Launchy gets pretty addictive and soon you will hate using the Start menu or even Explorer on Windows for opening applications or files. So I took the red pill and started automating the following things with a little help from Python:

Launching Intranet applications inside Internet Explorer (even if Firefox is your default browser)
Bringing minimized or overlapped windows to the foreground

Some Necessary Evil

Don't get me wrong, I hate IE as much as you do. But the fact of life is that many web apps out there "Work best when viewed in IE" (TM). Even if you have launchy plugins to launch the web app, if your default browser is Firefox, it might show incorrectly. Here is the solution:

Install Python and Pywin32
Copy the following script to the Utilities directory (it will be in the path where you installed Launchy) and save it with a .pyw extension not a .py extension

ie.pyw:

    from win32com.client import Dispatch
    ie = Dispatch("InternetExplorer.Application")
    ie.Visible = True
    ie.Navigate(r"http://intranetapp/home")

In the above code replace the URL http://intranetapp/home with the URL of your choice.

Finally, open Launchy, right-click and say 'Rebuild Index'.

No more Alt-Tabbing around

If you are like me, you'll have a lot of windows open at the same time. I have tried increasing the task bar height and grouping similar windows feature in XP to manage them. But I always wish I could invoke commonly used open applications like my chat window in just a few keystrokes. Launchy doesn't index open programs by default, but with some python magic I can show you how to bring some commonly used windows to the foreground:

As before, install Python and Pywin32
Copy the following script to the Utilities directory (it will be in the path where you installed Launchy) and save it with a .pyw extension not a .py extension

windowfore.pyw:

    import sys
    from win32gui import GetWindowText, EnumWindows, ShowWindow, SetForegroundWindow
    from win32con import SW_RESTORE, SW_SHOW

    TITLE_MATCH = "Microsoft Excel - Expenses.xls"

    def listWindowsHandles():
        res = []
        def callback(hwnd, arg):
            res.append(hwnd)
        EnumWindows(callback, 0)
        return res

    def listWindowsNamesAndHnd():
        return [(hwnd, GetWindowText(hwnd)) for hwnd in listWindowsHandles()]

    def unminimizeWindow(a_hwnd):
        ShowWindow(a_hwnd, SW_RESTORE)
        SetForegroundWindow(a_hwnd)

    def finder1():
        for hwnd, title in listWindowsNamesAndHnd():
            if TITLE_MATCH in title:
                unminimizeWindow(hwnd)

    finder1()

In the above code change the string Microsoft Excel - Expenses.xls with the title the window you would like to summon.

Finally, open Launchy, right-click and say 'Rebuild Index'.

This works even if the window was minimized.

I hope, finally you can throw your mouse away. Ah... What a bliss!

Making Python Scripts Show Windows-friendly Errors/Stacktrace

2007-06-20T01:03:41+05:30

Most of us love to distribute our python programs to others once you have finished coding a neat little script. For Windows users we package it using Py2exe or cx_freeze. However, many of the end-users will not be happy with a black command window popping up, say, when an error is thrown.

Of course the alternative is to write a full blown GUI application using WXPython or PyFLTK. Even the latter, though quite lightweight, adds several megabytes to the distribution, when all you need is a simple message-box indicating an error or showing some informational text. Clearly, its an overkill for your throwaway python scripts.

This is the kind of problem I typically face and I have found a good solution. The answer is ctypes library which comes as a part of the standard distribution from Python 2.5 onwards. It simply calls the messagebox function from user32.dll (which is always present in a windows installation). With the main problem solved, what remained was to obtain the error text and stack trace.

Let's see how the code looks like:

    # Importing all the works for a native Win32 Message Box
    from ctypes import c_int, WINFUNCTYPE, windll
    from ctypes.wintypes import HWND, LPCSTR, UINT
    prototype = WINFUNCTYPE(c_int, HWND, LPCSTR, LPCSTR, UINT)
    paramflags = (1, "hwnd", 0), (1, "text", "Hi"), (1, "caption", None), (1, "flags", 0)
    MessageBox = prototype(("MessageBoxA", windll.user32), paramflags)

    # For printing the stack
    import sys
    import traceback
    from time import sleep

    def show_popup(text):
        print text
        MessageBox(text=text, caption="Sample App Says...")

    def mainloop():
        raise "Uff!"

    if __name__ == '__main__':
        try:
            mainloop()
        except:
            type, value, sys.last_traceback = sys.exc_info()
            lines = traceback.format_exception(type, value,sys.last_traceback)
            show_popup("Aiyooooo..... there has been an error!\n" +
                "Exception in user code:\n" +
                "".join(lines) +
                "===== Please mail a screenshot to arunvr@gmail.com ===="
                )
        finally:
            sleep(1) # show the console output for a second so that users can read it

EDIT: This is how it looks like in PyMail, one of my scripts-that-grew-into-an-app ;)

Windows+Python Integration Like Unix shell

2005-08-12T17:29:52+05:30

Remember how in UNIX how easy it was to run python scripts? Just type name of the script. No need to even type the extension .py

I got soon fed up with typing

C: > python foo.py

in windows. Digging up some Microsoft documentation, I soon found a way to simply type

C: > foo

and make it work. How? read on...

All you need is to create a batchfile, say 'startme.bat' with the two lines

ASSOC .py=PythonScript
FTYPE PythonScript=python.exe %1 %*
set PATHEXT=.py;%PATHEXT%

If you want this to be the default behaviour everywhere, put this in 'autoexec.bat'. But wait, we have a better way to do this. You can make 'startme.bat' work like '.bashrc' in UNIX by registry hack. Create a REG file, say 'cmd-changer.reg' with the contents:

REGEDIT4
[HKEY_LOCAL_MACHINE\Software\Microsoft\Command Processor]
"AutoRun"="startme.bat"

Now opening this file will merge it to the registry. Now 'startme.bat' will be run every time you open the command prompt say by typing 'cmd.exe' in the Run command box. Hope this helps!

Is Python Intellisense Possible in Emacs?

2005-06-14T20:07:17+05:30

Like the search for the Elixir of youth or philosopher's stone, I was looking for some kind of Intellisense feature for Python in Emacs which I have grown used to since my windows programming days. Yes I'm referring to the little drop down list that helps you auto complete class members. I'm also referring the tool-tip that appears which shows a functions signature when you are calling it. I know that PythonWin, my python editor of choice, already does this. But I intend to use Emacs as my IDE. It seems that you have two alternatives, both have issues as you will see:

py-complete - Not yet Windows ready?

Firstly py-complete seems to require Pymacs. Now, this was not very obvious. The idea of python helping in completion seems to be very cool and nearly worked without pymacs. Seems pymacs is not quite well supported in Windows. As soon as I read this I sort of gave up.

Semantic Flopped

Then, I installed CEDET 1.0 (beta 3) which gives you Semantic inspired by this post. It seemed to be a pain to install the whole thing until I discovered that you have to keep certain things in the load-path. Finally this is what I added to my .emacs file

;; Set up load path
(setq load-path (append (list (concat use-home "site/cedet/speedbar")
(concat use-home "site/cedet/common")) load-path))
(load-file "~/site/cedet/common/cedet.el") ;; Load CEDET
(semantic-load-enable-minimum-features)

Now as the post suggests, we have a fully working speedbar but auto-completion is pretty much weird. For eg: M-x semantic-analyze-possible-completions describes the scopes you are currently in.

Conclusion

Both approaches are really good though quite different. They haven't made use of the emacs tool-tip library either. Since this is a crucially lacking feature in Emacs, I might as well do a bit of R&D on this before giving up the dream.