5 reasons to try Resolver One

Disclaimer: I am a Resolver employee, have helped develop it and think it is extraordinarily cool.

• 1. It's an amazing combination of a spreadsheet application and an IronPython IDE.
• Resolver One shows a typical spreadsheet grid and a code box.
• Whatever you do with the grid is reflected in a generated code.
• In the code box you can write some code which manipulates the workbook object, all the changes are then displayed in the grid.
• Resolver One is now 1.0 !
  
• 2. You can create maintainable spreadsheets.
• Thanks to the two-ways synchronization a spreadsheet is actually a Python program.
• Thus, you can do everything that you can do with a program.
• Create modules, classes, methods.
  
• 3. It's probably the first time you can actually unit test your spreadsheet logic and furthermore do some refactoring on it!
• Once you split the logic into classes, you can easily test them using standard unit test tools.
  
• 4. Because now creating a spreadsheet is limited only by your imagination.
• Would you like to import/export a google spreadsheet?
• Maybe you'd prefer to load data from a database?
• You want to generate a chart?
• It's all limited only to IronPython capabilities.
  
• 5. It's easy to import your existing spreadsheet, script it with Python and export it back.

Are you convinced now?

Then go and grab a copy of Resolver One
Oh, and did I mention it's free for non-commercial use?

More resources:

resolversystems.com
resolverhacks.net

How to programmatically submit a POST form using IronPython

Sometimes you may want to download a web page that is a result of submitting a form that uses a POST method. The code below shows how to do that using IronPython.

1. prepare a request object, that is created for a given URI.
2. write the PARAMETERS string to the request stream.
3. retrieve the response and read from its stream.

URI = 'http://www.example.com'
PARAMETERS="lang=en&field1=1"

from System.Net import WebRequest
request = WebRequest.Create(URI)
request.ContentType = "application/x-www-form-urlencoded"
request.Method = "POST"

from System.Text import Encoding
bytes = Encoding.ASCII.GetBytes(PARAMETERS)
request.ContentLength = bytes.Length
reqStream = request.GetRequestStream()
reqStream.Write(bytes, 0, bytes.Length)
reqStream.Close()

response = request.GetResponse()
from System.IO import StreamReader
result = StreamReader(response.GetResponseStream()).ReadToEnd()
print result

How to download a web page using IronPython

Downloading a web page is a common programming task. Here are two snippets of code that show how to do it with IronPython. The code was tested on Windows and Mac (with Mono).

Using the WebClient class

from System.Net import WebClient
dataStream = WebClient().OpenRead('http://google.com')
from System.IO import StreamReader
reader = StreamReader(dataStream)
result = reader.ReadToEnd()
print result

Using the WebRequest and WebResponse classes

from System.Net import WebRequest
request = WebRequest.Create("http://google.com")
response = request.GetResponse()
responseStream = response.GetResponseStream()
from System.IO import StreamReader
result = StreamReader(responseStream).ReadToEnd()
print result

IronPython and Windows Forms talk

The presentation in html version

TabbedImages application

• We got some good feedback after the presentation.
• To my surprise there were many people already playing with IronPython.
• What's even more surprising, there were some people that have already used Windows Forms.
• Watch the tabbedimages application, I'm going to extend it with some interesting features.
• If you browse the sources for it, you'll find some simple tests in the MainTest.py.
• They exist because I'm afraid I'm not able to not do Test Driven Development.

PyCon 2007

The PyCon conference is really great.
So far I was at the following talks:

• Internationalization
• Parsing revisited
• Developing desktop applications with Dabo
• I didn't know that creating applications with wxPython is such a pain.
• The Dabo core is simply a layer above the wxPython.
• The application they used on the presentation was an image viewer.
• The API was really nice and in many cases reminded me a simplified version of WinForms API (where you uses strings instead of overused in .Net enumerations).
• wxPython (so Dabo as well) works on all important platforms (Windows, Linux, MacOS)
  

• WSGI - an introduction
• Because there are many different Python web frameworks, WSGI goal is to be able to integrate different layers of different applications.
• I'm still not sure how it could be used in the Ruby world and if there is any need for that.
  
• Writing parsers and compilers with PLY
• Recently, I'm working quite a lot with parsers and PLY is the main tool we use.
• It's very good, very efficient, very elegant
• You declare your grammar rules using docstrings
  
• Creating the WhatWhat project with TurboGears
• WhatWhat is a very simple project tracking tool that was implemented in 4 days using TurboGears.
• It seems that frameworks like TurboGears are becoming quite easy to learn and use.
• Not sure if as easy as Ruby on Rails, though.
  
• I'm still not convinced what could be the reason for me not to use Rails in web applications :)
  
• pyweek: making games in 7 days
• Creating games with Pygame on the GP2X
• SQLAlchemy
• Looks like a very powerful ORM tool for Python.
• Reminds me of Hibernate.
• There is a tool called Elixir which is a layer on top of SQLAlchemy and is more similar to the Ruby ActiveRecord.
• Migrations are only available as extensions.
• However, they are different than Ruby migrations. I didn't quite understand what is really the difference. I was told that Ruby migrations are dangerous because they do too many things for you (!?).
  
• It seems to me the above is one of the fundamental differences between Python and Ruby programmers.
  
• IronPython: Present and future
• That was definitely the best talk so far, IMO.
• Jim is doing a great work in Microsoft.
• My name even appeared at his slide :-)
• He wasn't able to read my name, though ;-)
• What's so difficult with my name? - Andrzej Krzywda
  
• There were screenshots of Michael's tutorial on IronPython and Windows Forms.
• Seo was mentioned, of course. He is the author of FePY - the Comunnity Edition of IronPython.
• The reason of this special edition is that MS can't easily apply patches that are sent by non-MS people.
• IronPython is supported by the MS Robotics project.
• Jim presented a small IP script where he used some MS Gaming API to create a simple 3d game.
• There is a growing support for IronPython in ASP.NET
• Embedding Little Languages in Python
• Little Languages is what the rest of the world calls Domain Specific Languages.
• The talk was about how to use Python to create such a DSL.
• The idea is the same as always with DSL:
• Firstly, you think of an ideal specification.
• You try to use the language features to fit to the spec.
• Python features that are helpful:
• Keyword args
• * args
• getattr, hasattr
• The speaker used _ convention in his code examples.
• I also prefer it, but it doesn't seem to be so popular in the Python community (it is in Ruby community).
  

Iron Python on Balloons

Have you ever wondered how to create a simple application that uses balloons to notify about some events? Below is the result of my spike on how I could use IronPython and Windows Forms to create such thing.



Basically, it should:

1. show an icon in the system tray

NotifyIcon is a class that allows you to display an icon in the system tray.


2. display a tooltip every n milliseconds

It was easily achieved by using the notifyIcon.ShowBalloonTip method and the Timer (and its Tick event) class.


3. have a context menu that allows you to exit the application

The ContextMenu class.

Just paste the code to the Main.py file, prepare a test.ico file and run it with:

ipy Main.py

import clr

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")
from System.Drawing import Icon
from System.Windows.Forms import (Application, ContextMenu, 
                                  MenuItem, NotifyIcon, Timer)


class Main(object):

    def __init__(self):
        self.initNotifyIcon()
        timer = Timer()
        timer.Interval = 60000
        timer.Tick += self.onTick
        timer.Start()
    

    def initNotifyIcon(self):
        self.notifyIcon = NotifyIcon()
        self.notifyIcon.Icon = Icon("test.ico")
        self.notifyIcon.Visible = True
        self.notifyIcon.ContextMenu = self.initContextMenu()

    
    def onTick(self, sender, event):
        self.notifyIcon.BalloonTipTitle = "Hello, I'm IronPython"
        self.notifyIcon.BalloonTipText = "Who are you?"
        self.notifyIcon.ShowBalloonTip(1000)

        
    def initContextMenu(self):
        contextMenu = ContextMenu()
        exitMenuItem = MenuItem("Exit")
        exitMenuItem.Click += self.onExit
        contextMenu.MenuItems.Add(exitMenuItem)
        return contextMenu
        

    def onExit(self, sender, event):
        self.notifyIcon.Visible = False
        Application.Exit()     
   
        
if __name__ == "__main__":
    main = Main()
    Application.Run()

Update:Marcin shows how to achieve the same with Groovy.

Creating GUI with IronPython, Groovy and JRuby

I was curious what are the differences between the following tools when it comes to creating a GUI desktop application:

• IronPython (with Windows Forms)
  
• Groovy (with Swing)
• JRuby (with Swing)
  

I prepared a simple example for each of them. The application shows a form with one button. This button when clicked changes its own text.

IronPython:
tested with 1.1a1 (1.1) on .NET 2.0.50727.42

• Native windows
  
• Possible to pass parameters in the constructor (form = Form(Text="test"))
• Nice += for event handlers
• As such a simple example it should work with Mono on Linux, however not sure about more complicated ones.
  

import clr
clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")
from System.Windows.Forms 
import Application, Button, Form
from System.Drawing import Size


form = Form(
    Text="Hello",
    Size=Size(200, 200)
)

button = Button(Text="OK!")

def onClick(event, handler):
    button.Text = "Pressed!"

button.Click += onClick
form.Controls.Add(button)

Application.Run(form)

Groovy:
tested with 1.0-RC-01
(Thanks to Marcin Domański for his help on this example)

• Cross-platform
• Elegant event handlers api (actionPerformed:click)
• Possible to pass parameters in the constructor (as in IronPython)
  

import javax.swing.JFrame
import javax.swing.JButton

def frame = new JFrame(
  title:"Hello",
  size:[200, 200],
  defaultCloseOperation:JFrame.EXIT_ON_CLOSE
)

def click = {
  event -> event.source.text = "Pressed!"
}

def button = new JButton(
  text:"OK!",
  actionPerformed:click
)

frame.add(button)
frame.show()

JRuby
tested with 0.9.2

• Cross-platform

• JRuby allows you to call Java code using the more Ruby-like underscore_method_naming and to refer to JavaBean properties as attributes.
• Event handlers using classes is not nice
  

require 'java'
include_class "javax.swing.JFrame"
include_class "javax.swing.JButton"
include_class "java.awt.event.ActionListener"

frame = JFrame.new("Hello")
frame.set_size(200,200)
frame.defaultCloseOperation = JFrame::EXIT_ON_CLOSE

button = JButton.new("OK!")

class ClickListener < ActionListener
  def actionPerformed(event)
    event.source.text = "Pressed!"
  end
end

button.add_action_listener(ClickListener.new)

frame.add(button)
frame.show

Update: There is a simpler Groovy version with SwingBuilder.