Merging -r 1192 from lp:ipython.

tools/toollib.py

@@ -0,0 +1,55 b''
+"""Various utilities common to IPython release and maintenance tools.
+"""
+# Library imports
+import os
+import sys
+
+from distutils.dir_util import remove_tree
+
+# Useful shorthands
+pjoin = os.path.join
+cd = os.chdir
+
+# Utility functions
+def c(cmd):
+    """Run system command, raise SystemExit if it returns an error."""
+    print "$",cmd
+    #stat = os.system(cmd)
+    stat = 0  # Uncomment this and comment previous to run in debug mode
+    if stat:
+        raise SystemExit("Command %s failed with code: %s" % (cmd, stat))
+
+
+def get_ipdir():
+    """Get IPython directory from command line, or assume it's the one above."""
+
+    # Initialize arguments and check location
+    try:
+        ipdir = sys.argv[1]
+    except IndexError:
+        ipdir = '..'
+
+    ipdir = os.path.abspath(ipdir)
+
+    cd(ipdir)
+    if not os.path.isdir('IPython') and os.path.isfile('setup.py'):
+        raise SystemExit('Invalid ipython directory: %s' % ipdir)
+    return ipdir
+
+
+def compile_tree():
+    """Compile all Python files below current directory."""
+    vstr = '.'.join(map(str,sys.version_info[:2]))
+    stat = os.system('python %s/lib/python%s/compileall.py .' %
+                     (sys.prefix,vstr))
+    if stat:
+        msg = '*** ERROR: Some Python files in tree do NOT compile! ***\n'
+        msg += 'See messages above for the actual file that produced it.\n'
+        raise SystemExit(msg)
+
+
+def version_info():
+    """Return bzr version info as a dict."""
+    out = os.popen('bzr version-info')
+    pairs = (l.split(':',1) for l in out)
+    return dict(((k,v.strip()) for (k,v) in pairs)) 

setupbase.py

@@ -1,321 +1,321 b''
 # encoding: utf-8
 
 """
 This module defines the things that are used in setup.py for building IPython
 
 This includes:
 
     * The basic arguments to setup
     * Functions for finding things like packages, package data, etc.
     * A function for checking dependencies.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import os, sys
 
 from glob import glob
 
 from setupext import install_data_ext
 
 #-------------------------------------------------------------------------------
 # Useful globals and utility functions
 #-------------------------------------------------------------------------------
 
 # A few handy globals
 isfile = os.path.isfile
 pjoin = os.path.join
 
 def oscmd(s):
     print ">", s
     os.system(s)
 
 # A little utility we'll need below, since glob() does NOT allow you to do
 # exclusion on multiple endings!
 def file_doesnt_endwith(test,endings):
     """Return true if test is a file and its name does NOT end with any
     of the strings listed in endings."""
     if not isfile(test):
         return False
     for e in endings:
         if test.endswith(e):
             return False
     return True
 
 #---------------------------------------------------------------------------
 # Basic project information
 #---------------------------------------------------------------------------
 
-# Release.py contains version, authors, license, url, keywords, etc.
+# release.py contains version, authors, license, url, keywords, etc.
 execfile(pjoin('IPython','core','release.py'))
 
 # Create a dict with the basic information
 # This dict is eventually passed to setup after additional keys are added.
 setup_args = dict(
       name             = name,
       version          = version,
       description      = description,
       long_description = long_description,
       author           = author,
       author_email     = author_email,
       url              = url,
       download_url     = download_url,
       license          = license,
       platforms        = platforms,
       keywords         = keywords,
       cmdclass         = {'install_data': install_data_ext},
       )
 
 
 #---------------------------------------------------------------------------
 # Find packages
 #---------------------------------------------------------------------------
 
 def add_package(packages,pname,config=False,tests=False,scripts=False,
                 others=None):
     """
     Add a package to the list of packages, including certain subpackages.
     """
     packages.append('.'.join(['IPython',pname]))
     if config:
         packages.append('.'.join(['IPython',pname,'config']))
     if tests:
         packages.append('.'.join(['IPython',pname,'tests']))
     if scripts:
         packages.append('.'.join(['IPython',pname,'scripts']))
     if others is not None:
         for o in others:
             packages.append('.'.join(['IPython',pname,o]))
 
 def find_packages():
     """
     Find all of IPython's packages.
     """
     packages = ['IPython']
     add_package(packages, 'config', tests=True)
     add_package(packages, 'config.userconfig')
     add_package(packages, 'core', tests=True)
     add_package(packages, 'deathrow', tests=True)
     add_package(packages , 'extensions')
     add_package(packages, 'external')
     add_package(packages, 'frontend', tests=True)
     # Don't include the cocoa frontend for now as it is not stable
     if sys.platform == 'darwin' and False:
         add_package(packages, 'frontend.cocoa', tests=True, others=['plugin'])
         add_package(packages, 'frontend.cocoa.examples')
         add_package(packages, 'frontend.cocoa.examples.IPython1Sandbox')
         add_package(packages, 'frontend.cocoa.examples.IPython1Sandbox.English.lproj')
     add_package(packages, 'frontend.process')
     add_package(packages, 'frontend.wx')
     add_package(packages, 'gui')
     add_package(packages, 'gui.wx')
     add_package(packages, 'kernel', config=True, tests=True, scripts=True)
     add_package(packages, 'kernel.core', config=True, tests=True)
     add_package(packages, 'lib', tests=True)
     add_package(packages, 'quarantine', tests=True)
     add_package(packages, 'scripts')
     add_package(packages, 'testing', tests=True)
     add_package(packages, 'testing.plugin', tests=False)
     add_package(packages, 'utils', tests=True)
     return packages
 
 #---------------------------------------------------------------------------
 # Find package data
 #---------------------------------------------------------------------------
 
 def find_package_data():
     """
     Find IPython's package_data.
     """
     # This is not enough for these things to appear in an sdist.
     # We need to muck with the MANIFEST to get this to work
     package_data = {
         'IPython.config.userconfig' : ['*'],
         'IPython.testing' : ['*.txt']
     }
     return package_data
 
 
 #---------------------------------------------------------------------------
 # Find data files
 #---------------------------------------------------------------------------
 
 def make_dir_struct(tag,base,out_base):
     """Make the directory structure of all files below a starting dir.
 
     This is just a convenience routine to help build a nested directory
     hierarchy because distutils is too stupid to do this by itself.
 
     XXX - this needs a proper docstring!
     """
     
     # we'll use these a lot below
     lbase = len(base)
     pathsep = os.path.sep
     lpathsep = len(pathsep)
     
     out = []
     for (dirpath,dirnames,filenames) in os.walk(base):
         # we need to strip out the dirpath from the base to map it to the
         # output (installation) path.  This requires possibly stripping the
         # path separator, because otherwise pjoin will not work correctly
         # (pjoin('foo/','/bar') returns '/bar').
         
         dp_eff = dirpath[lbase:]
         if dp_eff.startswith(pathsep):
             dp_eff = dp_eff[lpathsep:]
         # The output path must be anchored at the out_base marker    
         out_path = pjoin(out_base,dp_eff)
         # Now we can generate the final filenames. Since os.walk only produces
         # filenames, we must join back with the dirpath to get full valid file
         # paths:
         pfiles = [pjoin(dirpath,f) for f in filenames]
         # Finally, generate the entry we need, which is a triple of (tag,output
         # path, files) for use as a data_files parameter in install_data.
         out.append((tag,out_path,pfiles))
 
     return out
     
 
 def find_data_files():
     """
     Find IPython's data_files.
 
     Most of these are docs.
     """
     
     docdirbase  = pjoin('share', 'doc', 'ipython')
     manpagebase = pjoin('share', 'man', 'man1')
     
     # Simple file lists can be made by hand
     manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
     igridhelpfiles = filter(isfile, glob(pjoin('IPython','extensions','igrid_help.*')))
 
     # For nested structures, use the utility above
     example_files = make_dir_struct(
         'data',
         pjoin('docs','examples'),
         pjoin(docdirbase,'examples')
     )
     manual_files = make_dir_struct(
         'data',
         pjoin('docs','dist'),
         pjoin(docdirbase,'manual')
     )
 
     # And assemble the entire output list
     data_files = [ ('data',manpagebase, manpages),
                    ('data',pjoin(docdirbase,'extensions'),igridhelpfiles),
                    ] + manual_files + example_files
                  
     ## import pprint  # dbg
     ## print '*'*80
     ## print 'data files'
     ## pprint.pprint(data_files)
     ## print '*'*80
     
     return data_files
 
 
 def make_man_update_target(manpage):
     """Return a target_update-compliant tuple for the given manpage.
 
     Parameters
     ----------
     manpage : string
       Name of the manpage, must include the section number (trailing number).
 
     Example
     -------
 
     >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
     ('docs/man/ipython.1.gz',
      ['docs/man/ipython.1'],
      'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
     """
     man_dir = pjoin('docs', 'man')
     manpage_gz = manpage + '.gz'
     manpath = pjoin(man_dir, manpage)
     manpath_gz = pjoin(man_dir, manpage_gz)
     gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
                locals() )
     return (manpath_gz, [manpath], gz_cmd)
     
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------
 
 def find_scripts():
     """
     Find IPython's scripts.
     """
     kernel_scripts = pjoin('IPython','kernel','scripts')
     main_scripts = pjoin('IPython','scripts')
     scripts = [pjoin(kernel_scripts, 'ipengine'),
                pjoin(kernel_scripts, 'ipcontroller'),
                pjoin(kernel_scripts, 'ipcluster'),
                pjoin(main_scripts, 'ipython'),
                pjoin(main_scripts, 'ipythonx'),
                pjoin(main_scripts, 'ipython-wx'),
                pjoin(main_scripts, 'pycolor'),
                pjoin(main_scripts, 'irunner'),
                pjoin(main_scripts, 'iptest')
               ]
     
     # Script to be run by the windows binary installer after the default setup
     # routine, to add shortcuts and similar windows-only things.  Windows
     # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
     # doesn't find them.
     if 'bdist_wininst' in sys.argv:
         if len(sys.argv) > 2 and ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
             print >> sys.stderr,"ERROR: bdist_wininst must be run alone. Exiting."
             sys.exit(1)
         scripts.append(pjoin('scripts','ipython_win_post_install.py'))
     
     return scripts
 
 #---------------------------------------------------------------------------
 # Verify all dependencies
 #---------------------------------------------------------------------------
 
 def check_for_dependencies():
     """Check for IPython's dependencies.
     
     This function should NOT be called if running under setuptools!
     """
     from setupext.setupext import (
         print_line, print_raw, print_status, print_message,
         check_for_zopeinterface, check_for_twisted,
         check_for_foolscap, check_for_pyopenssl,
         check_for_sphinx, check_for_pygments,
         check_for_nose, check_for_pexpect
     )
     print_line()
     print_raw("BUILDING IPYTHON")
     print_status('python', sys.version)
     print_status('platform', sys.platform)
     if sys.platform == 'win32':
         print_status('Windows version', sys.getwindowsversion())
     
     print_raw("")
     print_raw("OPTIONAL DEPENDENCIES")
 
     check_for_zopeinterface()
     check_for_twisted()
     check_for_foolscap()
     check_for_pyopenssl()
     check_for_sphinx()
     check_for_pygments()
     check_for_nose()
     check_for_pexpect()

setupexe.py

@@ -1,107 +1,107 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 r"""Setup script for exe distribution of IPython (does not require python).
 
 - Requires py2exe
 
 - install pyreadline *package dir* in ipython root directory by running:
   
 svn co http://ipython.scipy.org/svn/ipython/pyreadline/branches/maintenance_1.3/pyreadline/  
 wget http://ipython.scipy.org/svn/ipython/pyreadline/branches/maintenance_1.3/readline.py
 
 OR (if you want the latest trunk):
   
 svn co http://ipython.scipy.org/svn/ipython/pyreadline/trunk/pyreadline
 
 - Create the distribution in 'dist' by running "python exesetup.py py2exe"
 
 - Run ipython.exe to go.
 
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001-2005 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 # Stdlib imports
 import os
 import sys
 
 from glob import glob
 
 
 # A few handy globals
 isfile = os.path.isfile
 pjoin = os.path.join
 
 from distutils.core import setup
 from distutils import dir_util
 import py2exe
 
 # update the manuals when building a source dist
-# Release.py contains version, authors, license, url, keywords, etc.
+# release.py contains version, authors, license, url, keywords, etc.
 execfile(pjoin('IPython','core','release.py'))
 
 # A little utility we'll need below, since glob() does NOT allow you to do
 # exclusion on multiple endings!
 def file_doesnt_endwith(test,endings):
     """Return true if test is a file and its name does NOT end with any
     of the strings listed in endings."""
     if not isfile(test):
         return False
     for e in endings:
         if test.endswith(e):
             return False
     return True
 
 
 egg_extra_kwds = {}
 
 # Call the setup() routine which does most of the work
 setup(name             = name,
     options   = {
     'py2exe': {
         'packages' : ['IPython', 'IPython.extensions', 'IPython.external',
                       'pyreadline','config','core','deathrow','lib',
                       'scripts','testing','utils'],
         'excludes' : ["Tkconstants","Tkinter","tcl",'IPython.igrid','wx',
                       'wxPython','igrid', 'PyQt4', 'zope', 'Zope', 'Zope2',
                       '_curses','enthought.traits','gtk','qt', 'pydb','idlelib',                      
                       ]
                     
                      }
     },
     version          = version,
     description      = description,
     long_description = long_description,
     author           = authors['Fernando'][0],
     author_email     = authors['Fernando'][1],
     url              = url,
     download_url     = download_url,
     license          = license,
     platforms        = platforms,
     keywords         = keywords,
     console          = ['ipykit.py'],
     
     # extra params needed for eggs
     **egg_extra_kwds                        
     )
 
 minimal_conf = """
 import IPython.ipapi
 ip = IPython.ipapi.get()
 
 ip.load('ipy_kitcfg')
 import ipy_profile_sh
 """
 
 if not os.path.isdir("dist/_ipython"):
     print "Creating simple _ipython dir"
     os.mkdir("dist/_ipython")
     open("dist/_ipython/ipythonrc.ini","w").write("# intentionally blank\n")
     open("dist/_ipython/ipy_user_conf.py","w").write(minimal_conf)
     if os.path.isdir('bin'):
         dir_util.copy_tree('bin','dist/bin')

tools/compile.py

@@ -1,20 +1,19 b''
 #!/usr/bin/env python
-"""Call the compile script to check that all code we ship compiles correctly.
-"""
+"""Script to check that all code in a directory compiles correctly.
 
-import os
-import sys
+Usage:
 
+  compile.py
 
-vstr = '.'.join(map(str,sys.version_info[:2]))
+This script verifies that all Python files in the directory where run, and all
+of its subdirectories, compile correctly.
 
-stat = os.system('python %s/lib/python%s/compileall.py .' % (sys.prefix,vstr))
+Before a release, call this script from the top-level directory.
+"""
+
+import sys
 
-print
-if stat:
-    print '*** THERE WAS AN ERROR! ***'
-    print 'See messages above for the actual file that produced it.'
-else:
-    print 'OK'
+from toollib import compile_tree
 
-sys.exit(stat)
+if __name__ == '__main__':
+    compile_tree()

tools/make_tarball.py

@@ -1,36 +1,23 b''
 #!/usr/bin/env python
 """Simple script to create a tarball with proper bzr version info.
 """
 
-import os,sys,shutil
+import os
+import sys
+import shutil
 
-basever = '0.9.0'
+from  toollib import *
 
-def oscmd(c):
-    print ">",c
-    s = os.system(c)
-    if s:
-        print "Error",s
-        sys.exit(s)
+c('python update_revnum.py')
 
-def verinfo():
-    
-    out = os.popen('bzr version-info')
-    pairs = (l.split(':',1) for l in out)
-    d = dict(((k,v.strip()) for (k,v) in pairs)) 
-    return d
-
-basename = 'ipython'
-
-#tarname = '%s.r%s.tgz' % (basename, ver)
-oscmd('python update_revnum.py')
+execfile('../IPython/core/release.py')  # defines version_base
 
-ver = verinfo()
+ver = version_info()
 
 if ver['branch-nick'] == 'ipython':
-    tarname = 'ipython-%s.bzr.r%s.tgz' % (basever, ver['revno'])
+    tarname = 'ipython-%s.bzr.r%s.tgz' % (version_base, ver['revno'])
 else:
-    tarname = 'ipython-%s.bzr.r%s.%s.tgz' % (basever, ver['revno'],
+    tarname = 'ipython-%s.bzr.r%s.%s.tgz' % (version_base, ver['revno'],
                                              ver['branch-nick'])
     
-oscmd('bzr export ' + tarname)
+c('bzr export ' + tarname)

tools/mkrel.py

@@ -1,48 +1,42 b''
 #!/usr/bin/env python
-"""IPython release script
-
-Create ipykit and exe installer
-
-requires py2exe
+"""IPython release build script.
 """
+from toollib import *
 
-import os
-import distutils.dir_util
-import sys
-
-execfile('../IPython/Release.py')
-
-def c(cmd):
-    print ">",cmd
-    os.system(cmd)
+# Get main ipython dir, this will raise if it doesn't pass some checks
+ipdir = get_ipdir()
+cd(ipdir)
 
-ipykit_name = "ipykit-%s" % version
+# Load release info
+execfile(pjoin('IPython','core','release.py'))
 
-os.chdir('..')
-if os.path.isdir('dist'):
-    distutils.dir_util.remove_tree('dist')
-if os.path.isdir(ipykit_name):
-    distutils.dir_util.remove_tree(ipykit_name)
+# Check that everything compiles
+compile_tree()
 
-if sys.platform == 'win32':
-    c("python exesetup.py py2exe")
-
-    os.rename('dist',ipykit_name)
-
-    c("zip -r %s.zip %s" % (ipykit_name, ipykit_name))
+# Cleanup
+for d in ['build','dist',pjoin('docs','build'),pjoin('docs','dist')]:
+    if os.path.isdir(d):
+        remove_tree(d)
 
 # Build source and binary distros
 c('./setup.py sdist --formats=gztar')
 
-c("python2.4 ./setup.py bdist_rpm --binary-only --release=py24 --python=/usr/bin/python2.4")
-c("python2.5 ./setup.py bdist_rpm --binary-only --release=py25 --python=/usr/bin/python2.5")
+# Build version-specific RPMs, where we must use the --python option to ensure
+# that the resulting RPM is really built with the requested python version (so
+# things go to lib/python2.X/...)
+c("python2.5 ./setup.py bdist_rpm --binary-only --release=py25 "
+  "--python=/usr/bin/python2.5")
+c("python2.6 ./setup.py bdist_rpm --binary-only --release=py26 "
+  "--python=/usr/bin/python2.6")
 
 # Build eggs
-c('python2.4 ./eggsetup.py bdist_egg')
 c('python2.5 ./eggsetup.py bdist_egg')
+c('python2.6 ./eggsetup.py bdist_egg')
 
+# Call the windows build separately, so that the extra Windows scripts don't
+# get pulled into Unix builds (setup.py has code which checks for
+# bdist_wininst)
 c("python setup.py bdist_wininst --install-script=ipython_win_post_install.py")
 
-os.chdir('tools')
-c('python make_tarball.py')
-
+# Change name so retarded Vista runs the installer correctly
+c("rename 's/win32/win32-setup/' dist/*.exe")

tools/release

@@ -1,35 +1,43 b''
-#!/bin/bash
-# IPython release script
+#!/usr/bin/env python
+"""IPython release script.
 
-PYVER=`python -V 2>&1 | awk '{print $2}' | awk -F '.' '{print $1$2}' `
-version=`ipython -Version`
-ipdir=~/ipython/ipython
-ipbackupdir=~/ipython/backup
+This should only be run at real release time.
+"""
 
-echo
-echo "Releasing IPython version $version"
-echo "=================================="
+from toollib import *
+
+# Get main ipython dir, this will raise if it doesn't pass some checks
+ipdir = get_ipdir()
+cd(ipdir)
+
+# Load release info
+execfile(pjoin('IPython','core','release.py'))
+
+# Where I keep static backups of each release
+ipbackupdir = os.path.expanduser('~/ipython/backup')
+
+print
+print "Releasing IPython version $version"
+print "=================================="
 
 # Perform local backup
-cd $ipdir/tools
-./make_tarball.py
-mv ipython-*.tgz $ipbackupdir
+c('./make_tarball.py')
+c('mv ipython-*.tgz %s' % ipbackupdir)
 
 # Build release files
-./testrel $ipdir
+c('./mkrel.py %s' % ipdir)
 
 # Register with the Python Package Index (PyPI)
-echo "Registering with PyPI..."
-cd $ipdir
-./setup.py register
+print "Registering with PyPI..."
+c('./setup.py register')
 
 # Upload all files
-cd $ipdir/dist
-echo "Uploading distribution files..."
-scp * [e-mail]:www/dist/
+cd('dist')
+print "Uploading distribution files..."
+c('scp * [e-mail]:www/dist/')
 
-echo "Uploading backup files..."
-cd $ipbackupdir
-scp `ls -1tr *tgz | tail -1` [e-mail]:www/backup/
+print "Uploading backup files..."
+cd(ipbackupdir)
+c('scp `ls -1tr *tgz | tail -1` [e-mail]:www/backup/')
 
-echo "Done!"
+print "Done!"

tools/run_ipy_in_profiler.py

@@ -1,16 +1,22 b''
+"""XXX - What exactly is the use of this script?
+
+I (fperez) tried it quickly and it doesn't work in its current form.  Either it
+needs to be fixed and documented or removed.
+"""
+
 import cProfile as profile
 import sys
 #import profile
 
 def main():
     import IPython.ipapi
     print "Entering ipython for profiling. Type 'Exit' for profiler report"
     IPython.ipapi.launch_new_instance()
 
 if len(sys.argv) == 1:   
     profile.run('main()', 'ipython_profiler_results')
 
 import pstats
 p = pstats.Stats(len(sys.argv) >1 and sys.argv[1] or 'ipython_profiler_results')
 p.sort_stats('time').print_stats(30)
 

tools/testupload

@@ -1,6 +1,6 b''
 #!/bin/sh
-
+# Simple upload script to push up into the testing directory a local build
 ipdir=$PWD/..
 
 cd $ipdir/dist
 scp * [e-mail]:www/dist/testing/

tools/update_revnum.py

@@ -1,23 +1,32 b''
 #!/usr/bin/env python
-""" Change the revision number in Release.py """
+"""Change the revision number in release.py
+
+This edits in-place release.py to update the revision number from bzr info. 
+
+Usage:
+
+./update_revnum.py"""
 
 import os
-import re,pprint
+import pprint
+import re
 
-def verinfo():
-    
-    out = os.popen('bzr version-info')
-    pairs = (l.split(':',1) for l in out)
-    d = dict(((k,v.strip()) for (k,v) in pairs)) 
-    return d
+from toollib import *
 
-ver = verinfo()
+if __name__ == '__main__':
+    ver = version_info()
 
-pprint.pprint(ver)
+    pprint.pprint(ver)
 
-rfile = open('../IPython/core/release.py','rb').read()
-newcont = re.sub(r'revision\s*=.*', "revision = '%s'" % ver['revno'], rfile)
+    rfile = open('../IPython/core/release.py','rb').read()
+    newcont = re.sub(r'revision\s*=.*',
+                     "revision = '%s'" % ver['revno'],
+                     rfile)
 
-newcont = re.sub(r'^branch\s*=[^=].*', "branch = '%s'"  % ver['branch-nick'], newcont )
+    newcont = re.sub(r'^branch\s*=[^=].*',
+                     "branch = '%s'"  % ver['branch-nick'],
+                     newcont)
 
-open('../IPython/core/release.py','wb').write(newcont)
+    f = open('../IPython/core/release.py','wb')
+    f.write(newcont)
+    f.close()