Mac/Tools/IDE/PackageManager.py

   1 # Prelude to allow running this as a main program
   2 def _init():
   3         import macresource
   4         import sys, os
   5         macresource.need('DITL', 468, "PythonIDE.rsrc")
   6         widgetrespathsegs = [sys.exec_prefix, "Mac", "Tools", "IDE", "Widgets.rsrc"]
   7         widgetresfile = os.path.join(*widgetrespathsegs)
   8         if not os.path.exists(widgetresfile):
   9                 widgetrespathsegs = [os.pardir, "Tools", "IDE", "Widgets.rsrc"]
  10                 widgetresfile = os.path.join(*widgetrespathsegs)
  11         refno = macresource.need('CURS', 468, widgetresfile)
  12         if os.environ.has_key('PYTHONIDEPATH'):
  13                 # For development set this environment variable
  14                 ide_path = os.environ['PYTHONIDEPATH']
  15         elif refno:
  16                 # We're not a fullblown application
  17                 idepathsegs = [sys.exec_prefix, "Mac", "Tools", "IDE"]
  18                 ide_path = os.path.join(*idepathsegs)
  19                 if not os.path.exists(ide_path):
  20                         idepathsegs = [os.pardir, "Tools", "IDE"]
  21                         for p in sys.path:
  22                                 ide_path = os.path.join(*([p]+idepathsegs))
  23                                 if os.path.exists(ide_path):
  24                                         break
  25
  26         else:
  27                 # We are a fully frozen application
  28                 ide_path = sys.argv[0]
  29         if ide_path not in sys.path:
  30                 sys.path.insert(0, ide_path)
  31
  32 if __name__ == '__main__':
  33         _init()
  34
  35 import W
  36 import Wapplication
  37 from Carbon import Evt
  38 import EasyDialogs
  39 import FrameWork
  40
  41 import sys
  42 import string
  43 import os
  44 import urllib
  45
  46 import pimp
  47
  48 ELIPSES = '...'
  49
  50 USER_INSTALL_DIR = os.path.join(os.environ.get('HOME', ''),
  51                                                                 'Library',
  52                                                                 'Python',
  53                                                                 sys.version[:3],
  54                                                                 'site-packages')
  55
  56 class PackageManagerMain(Wapplication.Application):
  57
  58         def __init__(self):
  59                 self.preffilepath = os.path.join("Python", "Package Install Manager Prefs")
  60                 Wapplication.Application.__init__(self, 'Pimp')
  61                 from Carbon import AE
  62                 from Carbon import AppleEvents
  63
  64                 AE.AEInstallEventHandler(AppleEvents.kCoreEventClass, AppleEvents.kAEOpenApplication,
  65                                 self.ignoreevent)
  66                 AE.AEInstallEventHandler(AppleEvents.kCoreEventClass, AppleEvents.kAEReopenApplication,
  67                                 self.ignoreevent)
  68                 AE.AEInstallEventHandler(AppleEvents.kCoreEventClass, AppleEvents.kAEPrintDocuments,
  69                                 self.ignoreevent)
  70                 AE.AEInstallEventHandler(AppleEvents.kCoreEventClass, AppleEvents.kAEQuitApplication,
  71                                 self.quitevent)
  72                 if 1:
  73                         import PyConsole
  74                         # With -D option (OSX command line only) keep stderr, for debugging the IDE
  75                         # itself.
  76                         debug_stderr = None
  77                         if len(sys.argv) >= 2 and sys.argv[1] == '-D':
  78                                 debug_stderr = sys.stderr
  79                                 del sys.argv[1]
  80                         PyConsole.installoutput()
  81                         if debug_stderr:
  82                                 sys.stderr = debug_stderr
  83                 self.opendoc(None)
  84                 self.mainloop()
  85
  86         def makeusermenus(self):
  87                 m = Wapplication.Menu(self.menubar, "File")
  88                 newitem = FrameWork.MenuItem(m, "Open Standard Database", "N", 'openstandard')
  89                 openitem = FrameWork.MenuItem(m, "Open"+ELIPSES, "O", 'open')
  90                 openURLitem = FrameWork.MenuItem(m, "Open URL"+ELIPSES, "D", 'openURL')
  91                 FrameWork.Separator(m)
  92                 closeitem = FrameWork.MenuItem(m, "Close", "W", 'close')
  93 ##              saveitem = FrameWork.MenuItem(m, "Save", "S", 'save')
  94 ##              saveasitem = FrameWork.MenuItem(m, "Save as"+ELIPSES, None, 'save_as')
  95 ##              FrameWork.Separator(m)
  96
  97                 m = Wapplication.Menu(self.menubar, "Edit")
  98                 undoitem = FrameWork.MenuItem(m, "Undo", 'Z', "undo")
  99                 FrameWork.Separator(m)
 100                 cutitem = FrameWork.MenuItem(m, "Cut", 'X', "cut")
 101                 copyitem = FrameWork.MenuItem(m, "Copy", "C", "copy")
 102                 pasteitem = FrameWork.MenuItem(m, "Paste", "V", "paste")
 103                 FrameWork.MenuItem(m, "Clear", None,  "clear")
 104                 FrameWork.Separator(m)
 105                 selallitem = FrameWork.MenuItem(m, "Select all", "A", "selectall")
 106
 107                 m = Wapplication.Menu(self.menubar, "Package")
 108                 runitem = FrameWork.MenuItem(m, "Install", "I", 'install')
 109                 homepageitem = FrameWork.MenuItem(m, "Visit Homepage", None, 'homepage')
 110
 111                 self.openwindowsmenu = Wapplication.Menu(self.menubar, 'Windows')
 112                 self.makeopenwindowsmenu()
 113                 self._menustocheck = [closeitem,
 114                                 undoitem, cutitem, copyitem, pasteitem,
 115                                 selallitem,
 116                                 runitem, homepageitem]
 117
 118         def quitevent(self, theAppleEvent, theReply):
 119                 self._quit()
 120
 121         def ignoreevent(self, theAppleEvent, theReply):
 122                 pass
 123
 124         def opendocsevent(self, theAppleEvent, theReply):
 125                 W.SetCursor('watch')
 126                 import aetools
 127                 parameters, args = aetools.unpackevent(theAppleEvent)
 128                 docs = parameters['----']
 129                 if type(docs) <> type([]):
 130                         docs = [docs]
 131                 for doc in docs:
 132                         fsr, a = doc.FSResolveAlias(None)
 133                         path = fsr.as_pathname()
 134                         path = urllib.pathname2url(path)
 135                         self.opendoc(path)
 136
 137         def opendoc(self, url):
 138                 PackageBrowser(url)
 139
 140         def getabouttext(self):
 141                 return "About Package Manager"+ELIPSES
 142
 143         def do_about(self, id, item, window, event):
 144                 EasyDialogs.Message("Package Install Manager for Python")
 145
 146         def domenu_openstandard(self, *args):
 147                 self.opendoc(None)
 148
 149         def domenu_open(self, *args):
 150                 filename = EasyDialogs.AskFileForOpen(typeList=("TEXT",))
 151                 if filename:
 152                         filename = urllib.pathname2url(filename)
 153                         self.opendoc(filename)
 154
 155         def domenu_openURL(self, *args):
 156                 ok = EasyDialogs.AskYesNoCancel(
 157                         "Warning: by opening a non-standard database "
 158                         "you are trusting the maintainer of it "
 159                         "to run arbitrary code on your machine.",
 160                         yes="OK", no="")
 161                 if ok <= 0: return
 162                 url = EasyDialogs.AskString("URL of database to open:", ok="Open")
 163                 if url:
 164                         self.opendoc(url)
 165
 166         def domenu_openbyname(self, *args):
 167                 url = EasyDialogs.AskString("Open URL:", ok="Open")
 168                 if url:
 169                         self.opendoc(url)
 170
 171         def makeopenwindowsmenu(self):
 172                 for i in range(len(self.openwindowsmenu.items)):
 173                         self.openwindowsmenu.menu.DeleteMenuItem(1)
 174                         self.openwindowsmenu.items = []
 175                 windows = []
 176                 self._openwindows = {}
 177                 for window in self._windows.keys():
 178                         title = window.GetWTitle()
 179                         if not title:
 180                                 title = "<no title>"
 181                         windows.append((title, window))
 182                 windows.sort()
 183                 for title, window in windows:
 184                         shortcut = None
 185                         item = FrameWork.MenuItem(self.openwindowsmenu, title, shortcut, callback = self.domenu_openwindows)
 186                         self._openwindows[item.item] = window
 187                 self._openwindowscheckmark = 0
 188                 self.checkopenwindowsmenu()
 189
 190         def domenu_openwindows(self, id, item, window, event):
 191                 w = self._openwindows[item]
 192                 w.ShowWindow()
 193                 w.SelectWindow()
 194
 195         def domenu_quit(self):
 196                 self._quit()
 197
 198         def domenu_save(self, *args):
 199                 print "Save"
 200
 201         def _quit(self):
 202 ##              import PyConsole, PyEdit
 203                 for window in self._windows.values():
 204                         try:
 205                                 rv = window.close() # ignore any errors while quitting
 206                         except:
 207                                 rv = 0   # (otherwise, we can get stuck!)
 208                         if rv and rv > 0:
 209                                 return
 210 ##              try:
 211 ##                      PyConsole.console.writeprefs()
 212 ##                      PyConsole.output.writeprefs()
 213 ##                      PyEdit.searchengine.writeprefs()
 214 ##              except:
 215 ##                      # Write to __stderr__ so the msg end up in Console.app and has
 216 ##                      # at least _some_ chance of getting read...
 217 ##                      # But: this is a workaround for way more serious problems with
 218 ##                      # the Python 2.2 Jaguar addon.
 219 ##                      sys.__stderr__.write("*** PythonIDE: Can't write preferences ***\n")
 220                 self.quitting = 1
 221
 222 class PimpInterface:
 223
 224         def setuppimp(self, url):
 225                 self.pimpprefs = pimp.PimpPreferences()
 226                 self.pimpdb = pimp.PimpDatabase(self.pimpprefs)
 227                 self.pimpinstaller = pimp.PimpInstaller(self.pimpdb)
 228                 if not url:
 229                         url = self.pimpprefs.pimpDatabase
 230                 try:
 231                         self.pimpdb.appendURL(url)
 232                 except IOError, arg:
 233                         rv = "Cannot open %s: %s\n" % (url, arg)
 234                         rv += "\nSee MacPython Package Manager help page."
 235                         return rv
 236                 # Check whether we can write the installation directory.
 237                 # If not, set to the per-user directory, possibly
 238                 # creating it, if needed.
 239                 installDir = self.pimpprefs.installDir
 240                 if not os.access(installDir, os.R_OK|os.W_OK|os.X_OK):
 241                         rv = self.setuserinstall(1)
 242                         if rv: return rv
 243                 return self.pimpprefs.check()
 244
 245         def closepimp(self):
 246                 self.pimpdb.close()
 247                 self.pimpprefs = None
 248                 self.pimpdb = None
 249                 self.pimpinstaller = None
 250                 self.packages = []
 251
 252         def setuserinstall(self, onoff):
 253                 rv = ""
 254                 if onoff:
 255                         if not os.path.exists(USER_INSTALL_DIR):
 256                                 try:
 257                                         os.makedirs(USER_INSTALL_DIR)
 258                                 except OSError, arg:
 259                                         rv = rv + arg + "\n"
 260                         if not USER_INSTALL_DIR in sys.path:
 261                                 import site
 262                                 reload(site)
 263                         self.pimpprefs.setInstallDir(USER_INSTALL_DIR)
 264                 else:
 265                         self.pimpprefs.setInstallDir(None)
 266                 rv = rv + self.pimpprefs.check()
 267                 return rv
 268
 269         def getuserinstall(self):
 270                 return self.pimpprefs.installDir == USER_INSTALL_DIR
 271
 272         def getbrowserdata(self, show_hidden=1):
 273                 packages = self.pimpdb.list()
 274                 if show_hidden:
 275                         self.packages = packages
 276                 else:
 277                         self.packages = []
 278                         for pkg in packages:
 279                                 name = pkg.fullname()
 280                                 if name[0] == '(' and name[-1] == ')' and not show_hidden:
 281                                         continue
 282                                 self.packages.append(pkg)
 283                 rv = []
 284                 for pkg in self.packages:
 285                         name = pkg.fullname()
 286                         status, _ = pkg.installed()
 287                         description = pkg.description()
 288                         rv.append((status, name, description))
 289                 return rv
 290
 291         def getstatus(self, number):
 292                 pkg = self.packages[number]
 293                 return pkg.installed()
 294
 295         def installpackage(self, sel, output, recursive, force):
 296                 pkg = self.packages[sel]
 297                 list, messages = self.pimpinstaller.prepareInstall(pkg, force, recursive)
 298                 if messages:
 299                         return messages
 300                 messages = self.pimpinstaller.install(list, output)
 301                 return messages
 302
 303 class PackageBrowser(PimpInterface):
 304
 305         def __init__(self, url = None):
 306                 self.ic = None
 307                 messages = self.setuppimp(url)
 308                 self.setupwidgets()
 309                 self.updatestatus()
 310                 self.showmessages(messages)
 311
 312         def close(self):
 313                 self.closepimp()
 314
 315         def setupwidgets(self):
 316                 INSTALL_POS = -30
 317                 STATUS_POS = INSTALL_POS - 70
 318                 self.w = W.Window((580, 400), "Python Install Manager", minsize = (400, 200), tabbable = 0)
 319                 self.w.titlebar = W.TextBox((4, 8, 60, 18), 'Packages:')
 320                 self.w.hidden_button = W.CheckBox((-100, 4, 0, 18), 'Show Hidden', self.updatestatus)
 321                 data = self.getbrowserdata()
 322                 self.w.packagebrowser = W.MultiList((4, 24, 0, STATUS_POS-2), data, self.listhit, cols=3)
 323
 324                 self.w.installed_l = W.TextBox((4, STATUS_POS, 60, 12), 'Installed:')
 325                 self.w.installed = W.TextBox((64, STATUS_POS, 0, 12), '')
 326                 self.w.message_l = W.TextBox((4, STATUS_POS+20, 60, 12), 'Status:')
 327                 self.w.message = W.TextBox((64, STATUS_POS+20, 0, 12), '')
 328                 self.w.homepage_button = W.Button((4, STATUS_POS+40, 96, 18), 'View homepage', self.do_homepage)
 329
 330                 self.w.divline = W.HorizontalLine((0, INSTALL_POS-4, 0, 0))
 331                 self.w.verbose_button = W.CheckBox((84, INSTALL_POS+4, 60, 18), 'Verbose')
 332                 self.w.recursive_button = W.CheckBox((146, INSTALL_POS+4, 120, 18), 'Install dependencies', self.updatestatus)
 333                 self.w.recursive_button.set(1)
 334                 self.w.force_button = W.CheckBox((268, INSTALL_POS+4, 70, 18), 'Overwrite', self.updatestatus)
 335                 self.w.user_button = W.CheckBox((340, INSTALL_POS+4, 140, 18), 'For Current User Only', self.do_user)
 336                 self.w.install_button = W.Button((4, INSTALL_POS+4, 56, 18), 'Install:', self.do_install)
 337                 self.w.open()
 338
 339         def updatestatus(self):
 340                 sel = self.w.packagebrowser.getselection()
 341                 data = self.getbrowserdata(self.w.hidden_button.get())
 342                 self.w.packagebrowser.setitems(data)
 343                 self.w.user_button.set(self.getuserinstall())
 344                 if len(sel) != 1:
 345                         self.w.installed.set('')
 346                         self.w.message.set('')
 347                         self.w.install_button.enable(0)
 348                         self.w.homepage_button.enable(0)
 349                         self.w.verbose_button.enable(0)
 350                         self.w.recursive_button.enable(0)
 351                         self.w.force_button.enable(0)
 352                         self.w.user_button.enable(0)
 353                 else:
 354                         sel = sel[0]
 355                         self.w.packagebrowser.setselection([sel])
 356                         installed, message = self.getstatus(sel)
 357                         self.w.installed.set(installed)
 358                         self.w.message.set(message)
 359                         self.w.install_button.enable(installed != "yes" or self.w.force_button.get())
 360                         self.w.homepage_button.enable(not not self.packages[sel].homepage())
 361                         self.w.verbose_button.enable(1)
 362                         self.w.recursive_button.enable(1)
 363                         self.w.force_button.enable(1)
 364                         self.w.user_button.enable(1)
 365
 366         def listhit(self, *args, **kwargs):
 367                 self.updatestatus()
 368
 369         def do_install(self):
 370                 sel = self.w.packagebrowser.getselection()[0]
 371                 if self.w.verbose_button.get():
 372                         output = sys.stdout
 373                 else:
 374                         output = None
 375                 recursive = self.w.recursive_button.get()
 376                 force = self.w.force_button.get()
 377                 messages = self.installpackage(sel, output, recursive, force)
 378
 379                 # Re-read .pth files
 380                 import site
 381                 reload(site)
 382
 383                 self.updatestatus()
 384                 self.showmessages(messages)
 385
 386         def showmessages(self, messages):
 387                 if messages:
 388                         if type(messages) == list:
 389                                 messages = '\n'.join(messages)
 390                         if self.w.verbose_button.get():
 391                                 sys.stdout.write(messages + '\n')
 392                         EasyDialogs.Message(messages)
 393
 394         def do_homepage(self):
 395                 sel = self.w.packagebrowser.getselection()[0]
 396                 if not self.ic:
 397                         import ic
 398
 399                         self.ic = ic.IC()
 400                 self.ic.launchurl(self.packages[sel].homepage())
 401
 402         def do_user(self):
 403                 messages = self.setuserinstall(self.w.user_button.get())
 404                 self.updatestatus()
 405                 self.showmessages(messages)
 406
 407 if __name__ == '__main__':
 408         PackageManagerMain()