More updates for release of 0.9.rc1.

- Fix links for pyreadline.
- Fix setup.py to include new -wx script.
- Add pylab profile to win32 native installer.
- Fix manual win32 post install script (though this script may not work, and
I'm considering removing it...)

MANIFEST.in

@@ -1,32 +1,33
 include README_Windows.txt
 include win32_manual_post_install.py
 include ipython.py
 include setupbase.py
 
 graft scripts
 
 graft setupext
 
 graft IPython/UserConfig
 
 graft IPython/kernel
 graft IPython/config
 graft IPython/testing
 graft IPython/tools
 
 recursive-include IPython/Extensions igrid_help*
 
 graft docs
 exclude docs/\#*
 exclude docs/man/*.1
 
 # docs subdirs we want to skip
 prune docs/attic
 prune docs/build
 
 global-exclude *~
 global-exclude *.flc
 global-exclude *.pyc
 global-exclude .dircopy.log
 global-exclude .svn
 global-exclude .bzr
+global-exclude .hgignore

scripts/ipython_win_post_install.py

@@ -1,85 +1,89
 #!python
 """Windows-specific part of the installation"""
 
 import os, sys, shutil
 
 def mkshortcut(target,description,link_file,*args,**kw):
     """make a shortcut if it doesn't exist, and register its creation"""
     
     create_shortcut(target, description, link_file,*args,**kw)
     file_created(link_file)
 
 def install():
     """Routine to be run by the win32 installer with the -install switch."""
 
     from IPython.Release import version
 
     # Get some system constants
     prefix = sys.prefix
     python = prefix + r'\python.exe'
     # Lookup path to common startmenu ...
     ip_dir = get_special_folder_path('CSIDL_COMMON_PROGRAMS') + r'\IPython'
     
     # Some usability warnings at installation time.  I don't want them at the
     # top-level, so they don't appear if the user is uninstalling.
     try:
         import ctypes
     except ImportError:
         print ('To take full advantage of IPython, you need ctypes from:\n'
                'http://sourceforge.net/projects/ctypes')
 
     try:
         import win32con
     except ImportError:
         print ('To take full advantage of IPython, you need pywin32 from:\n'
                'http://starship.python.net/crew/mhammond/win32/Downloads.html')
 
     try:
         import readline
     except ImportError:
         print ('To take full advantage of IPython, you need readline from:\n'
-               'http://sourceforge.net/projects/uncpythontools')
+               'https://launchpad.net/pyreadline')
 
     ipybase = '"' + prefix + r'\scripts\ipython"'
     # Create IPython entry ...
     if not os.path.isdir(ip_dir):
         os.mkdir(ip_dir)
         directory_created(ip_dir)
 
     # Create program shortcuts ...
     f = ip_dir + r'\IPython.lnk'
     a = ipybase
     mkshortcut(python,'IPython',f,a)
 
     f = ip_dir + r'\pysh.lnk'
     a = ipybase+' -p sh'
-    mkshortcut(python,'IPython command prompt mode',f,a)
+    mkshortcut(python,'IPython (command prompt mode)',f,a)
+
+    f = ip_dir + r'\pylab.lnk'
+    a = ipybase+' -pylab'
+    mkshortcut(python,'IPython (PyLab mode)',f,a)
 
     f = ip_dir + r'\scipy.lnk'
     a = ipybase+' -pylab -p scipy'
-    mkshortcut(python,'IPython scipy profile',f,a)
+    mkshortcut(python,'IPython (scipy profile)',f,a)
 
     # Create documentation shortcuts ...
     t = prefix + r'\share\doc\ipython\manual\ipython.pdf'
     f = ip_dir + r'\Manual in PDF.lnk'
     mkshortcut(t,r'IPython Manual - PDF-Format',f)
 
     t = prefix + r'\share\doc\ipython\manual\html\index.html'
     f = ip_dir + r'\Manual in HTML.lnk'
     mkshortcut(t,'IPython Manual - HTML-Format',f)
 
     # make ipython.py
     shutil.copy(prefix + r'\scripts\ipython', prefix + r'\scripts\ipython.py')
     
 def remove():
     """Routine to be run by the win32 installer with the -remove switch."""
     pass
 
 # main()
 if len(sys.argv) > 1:
     if sys.argv[1] == '-install':
         install()
     elif sys.argv[1] == '-remove':
         remove()
     else:
         print "Script was called with option %s" % sys.argv[1]

setupbase.py

@@ -1,277 +1,278
 # 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.
 execfile(pjoin('IPython','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 , 'Extensions')
     add_package(packages, 'external')
     add_package(packages, 'gui')
     add_package(packages, 'gui.wx')
     add_package(packages, 'frontend', tests=True)
     add_package(packages, 'frontend._process')
     add_package(packages, 'frontend.wx')
     add_package(packages, 'frontend.cocoa', tests=True)
     add_package(packages, 'kernel', config=True, tests=True, scripts=True)
     add_package(packages, 'kernel.core', config=True, tests=True)
     add_package(packages, 'testing', tests=True)
     add_package(packages, 'testing.plugin', tests=False)
     add_package(packages, 'tools', tests=True)
     add_package(packages, 'UserConfig')
     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.UserConfig' : ['*'],
         'IPython.tools.tests' : ['*.txt'],
         '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  = 'share/doc/ipython'
     manpagebase = 'share/man/man1'
 
     # Simple file lists can be made by hand
     manpages  = filter(isfile, glob('docs/man/*.1.gz'))
     igridhelpfiles = filter(isfile, glob('IPython/Extensions/igrid_help.*'))
 
     # For nested structures, use the utility above
     example_files = make_dir_struct('data','docs/examples',
                                     pjoin(docdirbase,'examples'))
     manual_files = make_dir_struct('data','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
 
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------
 
 def find_scripts():
     """
     Find IPython's scripts.
     """
     scripts = ['IPython/kernel/scripts/ipengine',
                'IPython/kernel/scripts/ipcontroller',
                'IPython/kernel/scripts/ipcluster',
                'scripts/ipython',
                'scripts/ipythonx',
+               'scripts/ipython-wx',
                'scripts/pycolor',
                'scripts/irunner',
                '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('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()

win32_manual_post_install.py

@@ -1,141 +1,141
 #!python
 """Windows-specific part of the installation"""
 
 import os, sys
 
 try:
     import shutil,pythoncom
     from win32com.shell import shell
     import _winreg as wreg
 except ImportError:
     print """
 You seem to be missing the PythonWin extensions necessary for automatic
 installation.  You can get them (free) from
 http://starship.python.net/crew/mhammond/
 
 Please see the manual for details if you want to finish the installation by
 hand, or get PythonWin and repeat the procedure.
 
 Press <Enter> to exit this installer."""
     raw_input()
     sys.exit()
 
 
 def make_shortcut(fname,target,args='',start_in='',comment='',icon=None):
     """Make a Windows shortcut (.lnk) file.
 
     make_shortcut(fname,target,args='',start_in='',comment='',icon=None)
 
     Arguments:
         fname - name of the final shortcut file (include the .lnk)
         target - what the shortcut will point to
         args - additional arguments to pass to the target program
         start_in - directory where the target command will be called
         comment - for the popup tooltips
         icon - optional icon file. This must be a tuple of the type 
         (icon_file,index), where index is the index of the icon you want
         in the file. For single .ico files, index=0, but for icon libraries
         contained in a single file it can be >0.
     """
 
     shortcut = pythoncom.CoCreateInstance(
         shell.CLSID_ShellLink, None,
         pythoncom.CLSCTX_INPROC_SERVER, shell.IID_IShellLink
     )
     shortcut.SetPath(target)
     shortcut.SetArguments(args)
     shortcut.SetWorkingDirectory(start_in)
     shortcut.SetDescription(comment)
     if icon:
         shortcut.SetIconLocation(*icon)
     shortcut.QueryInterface(pythoncom.IID_IPersistFile).Save(fname,0)
 
 
 def run(wait=0):
     # Find where the Start Menu and My Documents are on the filesystem
     key = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
                        r'Software\Microsoft\Windows\CurrentVersion'
                        r'\Explorer\Shell Folders')
 
     programs_dir = wreg.QueryValueEx(key,'Programs')[0]
     my_documents_dir = wreg.QueryValueEx(key,'Personal')[0]
     key.Close()
 
     # Find where the 'program files' directory is
     key = wreg.OpenKey(wreg.HKEY_LOCAL_MACHINE,
                        r'SOFTWARE\Microsoft\Windows\CurrentVersion')
 
     program_files_dir = wreg.QueryValueEx(key,'ProgramFilesDir')[0]
     key.Close()
 
 
     # File and directory names
     ip_dir = program_files_dir + r'\IPython'
     ip_prog_dir = programs_dir + r'\IPython'
-    doc_dir = ip_dir+r'\doc'
+    doc_dir = ip_dir+r'\docs'
     ip_filename = ip_dir+r'\IPython_shell.py'
     pycon_icon = doc_dir+r'\pycon.ico'
 
     if not os.path.isdir(ip_dir):
         os.mkdir(ip_dir)
 
     # Copy startup script and documentation
     shutil.copy(sys.prefix+r'\Scripts\ipython',ip_filename)
     if os.path.isdir(doc_dir):
         shutil.rmtree(doc_dir)
-    shutil.copytree('doc',doc_dir)
+    shutil.copytree('docs',doc_dir)
 
     # make shortcuts for IPython, html and pdf docs.
     print 'Making entries for IPython in Start Menu...',
 
     # Create .bat file in \Scripts
     fic = open(sys.prefix + r'\Scripts\ipython.bat','w')
     fic.write('"' + sys.prefix + r'\python.exe' + '" -i ' + '"' +
               sys.prefix + r'\Scripts\ipython" %*')
     fic.close()
 
     # Create .bat file in \\Scripts
     fic = open(sys.prefix + '\\Scripts\\ipython.bat','w')
     fic.write('"' + sys.prefix + '\\python.exe' + '" -i ' + '"' + sys.prefix + '\\Scripts\ipython" %*')
     fic.close()
 
     # Create shortcuts in Programs\IPython:
     if not os.path.isdir(ip_prog_dir):
         os.mkdir(ip_prog_dir)
     os.chdir(ip_prog_dir)
 
-    man_pdf = doc_dir + r'\manual\ipython.pdf'
-    man_htm = doc_dir + r'\manual\ipython.html'
+    man_pdf = doc_dir + r'\dist\ipython.pdf'
+    man_htm = doc_dir + r'\dist\index.html'
 
     make_shortcut('IPython.lnk',sys.executable, '"%s"' % ip_filename,
                   my_documents_dir,
                   'IPython - Enhanced python command line interpreter',
                   (pycon_icon,0))
     make_shortcut('pysh.lnk',sys.executable, '"%s" -p pysh' % ip_filename,
                   my_documents_dir,
                   'pysh - a system shell with Python syntax (IPython based)',
                   (pycon_icon,0))
     make_shortcut('Manual in HTML format.lnk',man_htm,'','',
                   'IPython Manual - HTML format')
     make_shortcut('Manual in PDF format.lnk',man_pdf,'','',
                   'IPython Manual - PDF format')
 
     print """Done.
 
 I created the directory %s. There you will find the
 IPython startup script and manuals.
 
 An IPython menu was also created in your Start Menu, with entries for
 IPython itself and the manual in HTML and PDF formats.
 
 For reading PDF documents you need the freely available Adobe Acrobat
 Reader. If you don't have it, you can download it from:
 http://www.adobe.com/products/acrobat/readstep2.html
 """ % ip_dir
 
     if wait:
         print "Finished with IPython installation. Press Enter to exit this installer.",
         raw_input()
 
 if __name__ == '__main__':
     run()