Merge PR #1143 (Python3 StartMenu items)

Start Menu items are now installed with bdist_wininst on Python 3.

closes  #1143

IPython/zmq/completer.py

@@ -1,87 +1,91 b''
 """Tab-completion over zmq"""
 
 # Trying to get print statements to work during completion, not very
 # successfully...
 from __future__ import print_function
 
 import itertools
-import readline
+try:
+    import readline
+except ImportError:
+    readline = None
 import rlcompleter
 import time
 
 import session
 
 class KernelCompleter(object):
     """Kernel-side completion machinery."""
     def __init__(self, namespace):
         self.namespace = namespace
         self.completer = rlcompleter.Completer(namespace)
 
     def complete(self, line, text):
         # We'll likely use linel later even if now it's not used for anything
         matches = []
         complete = self.completer.complete
         for state in itertools.count():
             comp = complete(text, state)
             if comp is None:
                 break
             matches.append(comp)
         return matches
     
 
 class ClientCompleter(object):
     """Client-side completion machinery.
 
     How it works: self.complete will be called multiple times, with
     state=0,1,2,... When state=0 it should compute ALL the completion matches,
     and then return them for each value of state."""
     
     def __init__(self, client, session, socket):
-         # ugly, but we get called asynchronously and need access to some
-         # client state, like backgrounded code
+        # ugly, but we get called asynchronously and need access to some
+        # client state, like backgrounded code
+        assert readline is not None, "ClientCompleter depends on readline"
         self.client = client
         self.session = session
         self.socket = socket
         self.matches = []
 
     def request_completion(self, text):
         # Get full line to give to the kernel in case it wants more info.
         line = readline.get_line_buffer()
         # send completion request to kernel
         msg = self.session.send(self.socket,
                                 'complete_request',
                                 dict(text=text, line=line))
 
         # Give the kernel up to 0.5s to respond
         for i in range(5):
             ident,rep = self.session.recv(self.socket)
             rep = Message(rep)
             if rep is not None and rep.msg_type == 'complete_reply':
                 matches = rep.content.matches
                 break
             time.sleep(0.1)
         else:
             # timeout
             print ('TIMEOUT')  # Can't see this message...
             matches = None
         return matches
     
     def complete(self, text, state):
         
         if self.client.backgrounded > 0:
             print("\n[Not completing, background tasks active]")
             print(readline.get_line_buffer(), end='')
             return None
         
         if state==0:
             matches = self.request_completion(text)
             if matches is None:
                 self.matches = []
                 print('WARNING: Kernel timeout on tab completion.')
             else:
                 self.matches = matches
 
         try:
             return self.matches[state]
         except IndexError:
             return None

scripts/ipython_win_post_install.py

@@ -1,133 +1,142 b''
 #!python
 """Windows-specific part of the installation"""
 
+from __future__ import print_function
+
 import os, sys, shutil
 pjoin = os.path.join
 
 # import setuptools if we can
 try:
     import setuptools
 except ImportError:
     pass
 
 
 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 suffix(s):
+    """add '3' suffix to programs for Python 3"""
+    if sys.version_info[0] == 3:
+        s = s+'3'
+    return s
 
 def install():
     """Routine to be run by the win32 installer with the -install switch."""
     
-    from IPython.core.release import version
-    
     # Get some system constants
     prefix = sys.prefix
     python = pjoin(prefix, 'python.exe')
     pythonw = pjoin(prefix, 'pythonw.exe')
     have_setuptools = 'setuptools' in sys.modules
     
     if not have_setuptools:
         # This currently doesn't work without setuptools,
         # so don't bother making broken links
         return
     
     # Lookup path to common startmenu ...
     ip_start_menu = pjoin(get_special_folder_path('CSIDL_COMMON_PROGRAMS'),
                           'IPython (Py%i.%i %i bit)' % (sys.version_info[0],
                                                         sys.version_info[1],
                                                         8*tuple.__itemsize__))
     # Create IPython entry ...
     if not os.path.isdir(ip_start_menu):
         os.mkdir(ip_start_menu)
         directory_created(ip_start_menu)
     
     # Create .py and .bat files to make things available from
     # the Windows command line.  Thanks to the Twisted project
     # for this logic!
     programs = [
         'ipython',
         'iptest',
         'ipcontroller',
         'ipengine',
         'ipcluster',
         'irunner'
     ]
+    programs = [ suffix(p) for p in programs ]
     scripts = pjoin(prefix,'scripts')
     if not have_setuptools:
         # only create .bat files if we don't have setuptools
         for program in programs:
             raw = pjoin(scripts, program)
             bat = raw + '.bat'
             py = raw + '.py'
             # Create .py versions of the scripts
             shutil.copy(raw, py)
             # Create .bat files for each of the scripts
             bat_file = file(bat,'w')
             bat_file.write("@%s %s %%*" % (python, py))
             bat_file.close()
 
     # Now move onto setting the Start Menu up
-    ipybase = pjoin(scripts, 'ipython')
+    ipybase = suffix(pjoin(scripts, 'ipython'))
     if have_setuptools:
         # let setuptools take care of the scripts:
         ipybase = ipybase + '-script.py'
     workdir = "%HOMEDRIVE%%HOMEPATH%"
 
     link = pjoin(ip_start_menu, 'IPython.lnk')
     cmd = '"%s"' % ipybase
     mkshortcut(python, 'IPython', link, cmd, workdir)
     
     # Disable pysh Start item until the profile restores functionality
     # Most of this code is in IPython/deathrow, and needs to be updated
     # to 0.11 APIs
     
     # link = pjoin(ip_start_menu, 'pysh.lnk')
     # cmd = '"%s" profile=pysh --init' % ipybase
     # mkshortcut(python, 'IPython (command prompt mode)', link, cmd, workdir)
     
     link = pjoin(ip_start_menu, 'pylab.lnk')
     cmd = '"%s" profile=pylab --init' % ipybase
     mkshortcut(python, 'IPython (pylab profile)', link, cmd, workdir)
         
     link = pjoin(ip_start_menu, 'ipcontroller.lnk')
-    cmdbase = pjoin(scripts, 'ipcontroller')
+    cmdbase = suffix(pjoin(scripts, 'ipcontroller'))
     if have_setuptools:
         cmdbase += '-script.py'
     cmd = '"%s"' % cmdbase
     mkshortcut(python, 'IPython controller', link, cmd, workdir)
     
     link = pjoin(ip_start_menu, 'ipengine.lnk')
-    cmdbase = pjoin(scripts, 'ipengine')
+    cmdbase = suffix(pjoin(scripts, 'ipengine'))
     if have_setuptools:
         cmdbase += '-script.py'
     cmd = '"%s"' % cmdbase
     mkshortcut(python, 'IPython engine', link, cmd, workdir)
 
     link = pjoin(ip_start_menu, 'ipythonqt.lnk')
-    cmdbase = pjoin(scripts, 'ipython-qtconsole')
+    cmdbase = suffix(pjoin(scripts, 'ipython')) + '-qtconsole'
     if have_setuptools:
         cmdbase += '-script.pyw'
     cmd = '"%s"' % cmdbase
     mkshortcut(pythonw, 'IPython Qt Console', link, cmd, workdir)
     # Create documentation shortcuts ...
     t = prefix + r'\share\doc\ipython\manual\index.html'
     f = ip_start_menu + r'\Manual in HTML.lnk'
     mkshortcut(t,'IPython Manual - HTML-Format',f)
     
     
 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()
+        try:
+            install()
+        except OSError:
+            print("Failed to create Start Menu items, try running installer as administrator.", file=sys.stderr)
     elif sys.argv[1] == '-remove':
         remove()
     else:
-        print "Script was called with option %s" % sys.argv[1]
+        print("Script was called with option %s" % sys.argv[1], file=sys.stderr)

setup3.py

@@ -1,21 +1,36 b''
 import os.path
+import sys
 from setuptools import setup
 from setuptools.command.build_py import build_py
 
 from setupbase import (setup_args,
                        find_scripts,
                        find_packages,
                        find_package_data,
                        record_commit_info,
                        )
     
 setup_args['entry_points'] = find_scripts(True, suffix='3')
 setup_args['packages'] = find_packages()
 setup_args['package_data'] = find_package_data()
 setup_args['cmdclass'] = {'build_py': record_commit_info('IPython', build_cmd=build_py)}
 
+# 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)
+    setup_args['scripts'] = [os.path.join('scripts','ipython_win_post_install.py')]
+    setup_args['options'] = {"bdist_wininst":
+                             {"install_script":
+                              "ipython_win_post_install.py"}}
+
 def main():
     setup(use_2to3 = True, **setup_args)
     
 if __name__ == "__main__":
     main()