Category: IronPython

Tonight I was asked an interesting question regarding IronPython (well, Python) and how it handles the loose files when executing.  With languages like C#, everything is compiled into an assembly and you have namespaces in order to locate the classes.  However, in Python it is a little bit different.

With python, files can be either compiled into an assembly, or left loose within a directory depending on what you want to do.  If you have your files loose, then you will need to reference the different files (modulesclasses).  In the example below, I have a Customer class in a file called CustomerFile.py.  I then have a main method which creates the Customer and calls the method within a file called main.py.  The code for the files are here:

customerfile.py
class Customer(object):
  def PrintHello(self):
    print “Hello World!”

main.py
from customerfile import Customer
def main():
    print ‘Hello World’
    c = Customer()
    print ‘Created Customer’
    c.PrintHello()

if __name__ == “__main__”:
   print ‘Hello’
   main()

In order for the main file to know about the Customer File, we use the syntax – from import .  Here we say from the customerfile, import the Customer class at the top of the class. If we execute the file, everything is wrote out as expected.

IronPython-2.0B2>ipy.exe main.py
Hello
Hello World
Created Customer
Hello World!

It’s important that both files are located in a directory defined in the path search variable, by default it is the main directory and the Lib directory.

>>> import sys
>>> print sys.path
[‘.’, ‘…IronPython-2.0B2’, ‘…IronPython-2.0B2Lib’]

If for example, CustomerFile.py was moved into a directory called Customer within the main folder, we would need to add that to the path variable in order for IronPython to look in the directory for the file. The code below does this, note that before we can import os, we need to add a reference to the location of the standard library.

import sys
sys.path.append(“C:python25Lib”)
import os
sys.path.append(os.path.abspath(“Customer”))

Now, when we call the same code, IronPython will also search the Customer directory.  The path would now look something like this:

[‘.’, ‘IronPython-2.0B2’, ‘IronPython-2.0B2Lib’, ‘C:python25Lib’, ‘IronPython-2.0B2Customer’]

Not overly difficult, but I can see new users becoming confused by this.

In my previous post I talked about how to get started with IronPython, in this post I want to follow up with some very basic information about the actual language and some tips to enable you to start reading sample code. This post won’t make you an expert, but it should be enough to get you going.

One of the great things about IronPython and IronRuby is that there are already a huge amount of resources online about the language. A good starting point (apart form this post of course) is http://docs.python.org/ which contains the documentation for the Python language.  One problem with that approach is that there are minor differences different Python and IronPython.

Defining a variable

Defining a variable in IronPython seems a logical place to start.  The easiest way to play around with the language is by using the interactive console (ipy.exe).

To define a variable, you simply say = , for example:

>> x = 1

This creates a variable called x, of type integer (it has inferred the type) with the value of 1. As Python is a dynamic language, the way it handles variables is sightly different than you would expect compared to a static language like C#.  While Python is still a strongly typed language, it is perfectly legal to do this following:

>>> x = 1
>>> print x
1
>>> x = “Hello World”
>>> print x
Hello World
>>>

What happens is that within the first statement we create an integer object and assign it to x, in the second statement we create a string object and assign it to x, removing the reference to x. However, if we try and mix the types then it throws an exception, here we are trying to add an int to a string.

>>> x = “Hello World” + 1
Traceback (most recent call last):
  File , line unknown, in Initialize##24
TypeError: unsupported operand type(s) for +: ‘str’ and ‘int’

Python does know the type of the variable, it only uses it when it is actually required at runtime (late-binding) as far as I can tell.  For example, using the type function will return the correct type of the variable.

>>> print type(x)

So what does this mean while you are developing, well, it makes unit testing a lot easier as you don’t need to worry so much about getting an object of the extract type – it just needs to look like the type. Also, code is more generic as it doesn’t depend on the extract type.   However, you do run the risk of the type being wrong which is only found at runtime – but your automated tests will catch that right?

Creating a function

Now we can define variables, the next step is to define functions (methods). While Python is a dynamic language, it still has very strict language rules which must be followed, including it’s important on whitespace and tabbing unlike C#.

To define a method, we start with def, we then provide a name for our method, we add a number of parameters separated by commas, no need to include the type as Python will work it out for itself. Finally, we need to end the line with a colon :.  Next, we need to fill in the body of the method, the most important thing is to tab in to indicate the body, we can then write a number of lines of code, if the method should return a value then we can include that as the last line. To mark the end of the method, you have another carriage return.

Below we create a function called x, with the parameters y and z. In the method body, we just add the two and print them to the output (the console).

>>> def x(y, z):
…     print y + z
…

We can then simply call this method, notice that we can use both ints and strings and the correct action is taken.
>>> x(1,2)
3
>>> x(“Hello”, “World”)
HelloWorld

As we create the method, if we get something wrong then an error will be returned to alert us. Below I attempted to create a method but I forgot to include the colon at the end of the method.

>>> def x(y, z)
  File “”, line 1
    def x(y, z)
            ^
SyntaxError: unexpected token ‘‘

Similarly, if we do not indent the function body an error is returned.

>>> def x(y, x):
… print y + x
  File “”, line 2
    print y + x
    ^
IndentationError: expected an indented block

Below is just an example of how to return a value from a method.

>>> def x(y,x):
…     return y + x
…
>>> y = x(1,2)
>>> print y

Finally, python allows you to create functions within functions, which will have local scope. Great for code re-use and readability!

>>> def y():
…     def x(y, z):
…             print y + z
…     x(1,2)
…     x(“Hello”, “World”)
…
>>> y()
3
HelloWorld

Creating a Class

Creating a class is very similar to creating a function. The syntax is class ():  In the brackets, we can simply define all of the base classes.

>>> class MyClass(object):

We can then define function on the class in the same way, however one change is that we need to include self (similar to this in C#) as the first parameter of the method.
…     def PrintHello(self):
…             print “Hello!”
…     def Method2(self, x):
…             print “TWO TWO TWO”
…

To initialise the class, we simply say this:
>>> x = MyClass()

We can then call methods on it:

>>> x.PrintHello()
Hello!
>>> x.Method2(“Parameter”)
TWO TWO TWO

If we want to know all the methods on a class, we can do a dir.  Everything with a double underscore is an internal method. In the class we can define the actions to take when they get called.

>>> dir (x)
[‘Method2’, ‘PrintHello’, ‘__class__’, ‘__delattr__’, ‘__dict__’, ‘__doc__’, ‘__getattribute__’, ‘__hash__’, ‘__init__’, ‘__module__’, ‘__name__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__str__’, ‘__weakref__’]

For example:

>>> class InitClass:
…     def __init__(self):
…             print “Created”
…
>>> i = InitClass()
Created

Just to sum up, Python is a full featured language, I haven’t even touch onto some of the features of the language but hopefully it will provide you some insight into the code.

In my previous post, I discussed Visual Studio Integration, IronPython and how difficult it was to get started. However, I came across an application called IronPython Studio (Colin also pointed it out on the comments) which uses the Visual Studio 2008 Shell to provide a IronPython IDE. You can download the application from http://www.codeplex.com/IronPythonStudio.

On my first attempt to install the application, I was greeted with this error message:

—————————
Microsoft Visual Studio Shell Isolated
—————————
Cannot find one or more components. Please reinstall the application.
—————————
OK  
—————————

Turns out you need to have Microsoft Visual Studio 2008 Shell (isolated mode) Redistributable Package (http://www.microsoft.com/downloads/details.aspx?FamilyId=ACA38719-F449-4937-9BAC-45A9F8A73822&displaylang=en) installed which the installer doesn’t check for, this is a 384mb download.

Installing this, I found that it doesn’t actually install it – if I had actually read it correctly I would have read that it was just extracting.  I then had to go into the directory where I had extracted it to (C:VS 2008 Shell RedistIsolated Mode) and run the real installer (vs_shell_isolated.enu.exe).  I then uninstalled and reinstalled IP Studio without any problems.

Upon launching Iron Python Studio, I was greeted with a very familiar feel to Visual Studio. Going File > New > Project gave me the same options as was available in the VS 2008 SDK integration.

After creating a new Windows Application, it looks and feels the same as VS so you won’t have any trouble navigating around.  There is some intellisense (it didn’t like System.Windows…) and the syntax highlighting seems to work.

You can build and debug just as you would for Visual Studio 2008 and C#.  It is a good application to have around, however for now I think I will stick with ipy and notepad2. The fact you need the VS2008 Shell installed at 385mb is another fact which turns me against this.  It’s a shame they didn’t just release it as a VS Package which could plug straight into VS2008.

For the past week, I have been thinking about aims and target technology which I really want to learn more about, or dig even deeper into in some cases. One of those technologies is the DLR and the related dynamic languages. This post will just cover the very basics of getting started with one of the DLR languages – IronPython.  IronPython is about bring the Python language onto the DLR for use with the .Net framework.

1) Download

The first step to getting started is to actual download IronPython.  The project is hosted on CodePlex with all of the source code available, at the moment there are two main releases for IronPython, the first is 1.1.1 which is the latest 1x version and is built on top of the CLI.  The second is the latest 2.0 Beta 1 and is built on top of the DLR and is targeting Python v2.5

Download links:

1.1.1 – http://www.codeplex.com/IronPython/Release/ProjectReleases.aspx?ReleaseId=5141

2.0 Beta 1 – http://www.codeplex.com/IronPython/Release/ProjectReleases.aspx?ReleaseId=10266

For this series of posts, I will be focusing on 2.0 Beta 1.

2) Command Line

After you have downloaded the binaries as a zip file, extract it into its own directory.  You now have IronPython installed and setup – easy.  Within your extracted folder, you have everything you need to start using IronPython.

The main application is ipy.exe, this is the interactive command line for IronPython.  This allows you to execute IronPython code, as Python is a dynamic language there is no need to build the code as it can be executed on the fly.  This is great for experimenting with the language and trying out samples.

The other exe is ipyw.exe.  This is the same as ipy.exe, however runs windowless which allows you to execute a IronPython script without having to display the console.  For example, if we save the following code in a file called Hello.py in the same directory.

import clr
clr.AddReference(“System.Windows.Forms”)
import System.Windows.Forms as WinForms
WinForms.MessageBox.Show(“Hello”, “Hello World”)

And execute the file using ipyw with the following command.

>ipyw.exe Hello.py

The only thing displayed to the end user is the message box.

Other important files are the assembles, IronPython.dll, IronPython.Modules.dll and Microsoft.Scripting.dll.  From what I can tell, Microsoft.Scripting.dll is the core DLR code and it will be referred by the languages (IronRuby etc) and also hosters (Silverlight). IronPython.dll is the main assembly containing the language with Modules containing additional functionality and classes.  In Python, modules are useful utilities and ‘classes’ – for example PythonRegex.

3) Visual Studio Integration

At the moment, Visual Studio integration can be done via the SDK (http://www.microsoft.com/downloads/details.aspx?familyid=30402623-93ca-479a-867c-04dc45164f5b&displaylang=en), it looks like this is targeting IronPython 1.1.1. After installing the SDK, the IronPython integration is just a series of samples. After building the solution (IronPython.sln), you will have multiple assemblies but nothing actually which can be executed.  Well, in order to use these assemblies, you need to load them using the ‘Experimental Hive’, I always think this sounds like something from Resident Evil but this in fact is Visual Studio with a separate registry so you can destroy it without taking down your machine instance. The easiest way to do this is press F5, yet, while using the integration, I found it throw far too many exceptions and just be really difficult to use. Using Ctrl-F5 (Run without debugging).  This stopped Visual Studio kicking in saying something has gone wrong on every mouse click.

What the integration gives you is a Visual Studio project types for WinForms, ASP.net, Console Applications, WPF and Class library.  It also provides colorisation and intellisense (especial for the modem day developer) and a tool window which is similar to ipy.

I really hope this is involved in the near future, I’ve heard that the IronRuby team are working on integration so I guess its only time before this is officially released.

4) Executing stand-alone applications

When it comes to actually using IronPython as the basis for your own application you have a couple of routes and your requirements.  IronPython currently supports Silverlight and ASP.net (see point 5).  When it comes to WinFormsstandalone applications I can find three solutions which might work.  One is executing ipyw as shown in point 2.  Another solution is to host IronPython in a C# application, which I will discuss in a later post. The final solution is to use the Visual Studio Integration (point 3),  this includes the Visual Studio template which will compile the code into a single exe as static assemblies.

At present, not sure which is the ‘bestrecommend’ solution, had a quick chat with Michael Foord (who mentioned Static Assemblies) and it appears as if compiling your code into an assembly instead of loose py files is possible in 1.0 and 1.1 but not currently available in 2.0.

5) Silverlight and ASP.net

There has been a lot of talk about Silverlight and the DLR recently so I won’t go into details in this post.  It appears as if you just have your codebehind file as .py and Silverlight will do the rest for you (more or less).  Silverlight Quickstarts outlines how to do this – http://www.silverlight.net/Quickstarts/ProgramDlr.aspx

An area which hasn’t got as much attention is ASP.net futures (http://www.microsoft.com/downloads/details.aspx?FamilyId=A5189BCB-EF81-4C12-9733-E294D13A58E6&displaylang=en).  First, you need to create a new website (File > New > Website), you can then select IronPython from the language dropdown. You can then use IronPython as the code-behind language for your ASP.net web application.  While I didn’t have an in depth look, I tried to add a Click event to a button, but found I had to do everything manually – but it works.

6) Books and Resources

Michael Foord’s book IronPython in Action can be purchased as a early access ebook – http://www.manning.com/foord

Michael Foord’s Blog – http://www.voidspace.org.uk/python/weblog/index.shtml

Codeplex site – IronPython – Home and lots more resources listed here http://www.codeplex.com/IronPython/Wiki/View.aspx?title=News%20Feeds&referringTitle=Home

If you know any other really good resources for IronPython and the DLR, then please leave them in the comments.

I hope you have found this post useful to get you up and running using IronPython.