This module is designed to be both run and imported. When run by itself on my Windows machine, Firefox starts up. The requested page file is always displayed in a new browser window when os.spawnv is applied but in the currently open browser window (if any) when running a start command:

C:...PP3E>LaunchBrowser.py
Opening file://C:MarkPP3E-cdExamplesPP3E/Internet/Web/PyInternetDemos.html
Starting

The seemingly odd mix of forward and backward slashes in the URL here works fine within the browser; it pops up the window shown in Figure 6-2. Note that this script may be renamed with a .pyw extension by the time you fetch its source in order to suppress its pop-up window on Windows; rename back to a .py to see its trace outputs.

Figure 6-2. Launching a Windows browser on a local file

By default, a start command is spawned; to see the browser search procedure in action on Windows, set the script’s useWinStart variable to False (or 0). The script will search for a browser on your PATH settings, and then search in common Windows install directories hardcoded in Launcher.py. Here is the search in action on an older machine with Internet Explorer as the first in the list of browsers to try (the PATH on my newer machine is too complex to bear):

C:...PP3E>python LaunchBrowser.py
                       -file C:StuffWebsitepublic_htmlabout-pp.html
Opening file://C:StuffWebsitepublic_htmlabout-pp.html
Looking for IEXPLORE.EXE on ['C:\WINDOWS', 'C:\WINDOWS',
'C:\WINDOWS\COMMAND', 'C:\STUFF\BIN.MKS', 'C:\PROGRAM FILES\PYTHON']
Not at C:WINDOWSIEXPLORE.EXE
Not at C:WINDOWSIEXPLORE.EXE
Not at C:WINDOWSCOMMANDIEXPLORE.EXE
Not at C:STUFFBIN.MKSIEXPLORE.EXE
Not at C:PROGRAM FILESPYTHONIEXPLORE.EXE
IEXPLORE.EXE not on system path
Searching for IEXPLORE.EXE in C:Program FilesPython
Searching for IEXPLORE.EXE in C:PP3rdEdexamplesPP3E
Searching for IEXPLORE.EXE in C:Program Files
Spawning C:Program FilesInternet ExplorerIEXPLORE.EXE

If you study these trace message you’ll notice that the browser wasn’t on the system search path but was eventually located in a local C:Program Files subdirectory; this is just the Launcher module’s which and guessLocation functions at work. As run here, the script searches for Internet Explorer first; if that’s not to your liking, try changing the script’s tries list to make Netscape (or Firefox) first:

C:...PP3E>python LaunchBrowser.py
Opening file://C:PP3rdEdexamplesPP3E/Internet/Cgi-Web/PyInternetDemos.html
Looking for netscape.exe on ['C:\WINDOWS', 'C:\WINDOWS',
'C:\WINDOWS\COMMAND', 'C:\STUFF\BIN.MKS', 'C:\PROGRAM FILES\PYTHON']
Not at C:WINDOWS
etscape.exe
Not at C:WINDOWS
etscape.exe
Not at C:WINDOWSCOMMAND
etscape.exe
Not at C:STUFFBIN.MKS
etscape.exe
Not at C:PROGRAM FILESPYTHON
etscape.exe
netscape.exe not on system path
Searching for netscape.exe in C:Program FilesPython
Searching for netscape.exe in C:PP3rdEdexamplesPP3E
Searching for netscape.exe in C:Program Files
Spawning C:Program FilesNetscapeCommunicatorProgram
etscape.exe

Here, the script eventually found Netscape in a different install directory on the local machine. Besides automatically finding a user’s browser for him, this script also aims to be portable. When running this file unchanged on Linux, the local Netscape browser starts if it lives on your PATH; otherwise, others are tried:

[mark@toy ~/PP3rdEd/examples/PP3E]$python LaunchBrowser.py
Opening file:///home/mark/PP3rdEd/examples/PP3E/Internet/Cgi-
Web/PyInternetDemos.html
Looking for netscape on ['/home/mark/bin', '.', '/usr/bin', '/usr/bin',
'/usr/local/bin', '/usr/X11R6/bin', '/bin', '/usr/X11R6/bin', '/home/mark/
bin', '/usr/X11R6/bin', '/home/mark/bin', '/usr/X11R6/bin']
Not at /home/mark/bin/netscape
Not at ./netscape
Found /usr/bin/netscape
Running netscape
[mark@toy ~/PP3rdEd/examples/PP3E]$

If you have an Internet connection, you can open pages at remote servers too—the next command opens the root page at my site on the starship.python.net server, located somewhere on the East Coast the last time I checked:

C:...PP3E>python LaunchBrowser.py -live ~lutz starship.python.net
Opening http://starship.python.net/~lutz
Starting

In Chapter 10, we’ll see that this script is also run to start Internet examples in the top-level demo launcher system: the PyDemos script presented in that chapter portably opens local or remote web page files with this button-press callback:

[File mode]
    pagepath = os.getcwd( ) + '/Internet/Web'
    demoButton('PyMailCGI2',
               'Browser-based pop/smtp email interface',
               'LaunchBrowser.pyw -file %s/PyMailCgi/pymailcgi.html' % pagepath,
               pymailcgifiles)

[Live mode]
    site = 'localhost:%s'
    demoButton('PyMailCGI2',
               'Browser-based pop/smtp email interface',
               'LaunchBrowser.pyw -live pymailcgi.html '+ (site % 8000),
               pymailcgifiles)

Other programs can spawn LaunchBrowser.py command lines such as those shown previously with tools such as os.system, as usual; but since the script’s core logic is coded in a function, it can just as easily be imported and called:

>>>from PP3E.LaunchBrowser import launchBrowser
>>> launchBrowser(Page=r'C:MarkWEBSITEpublic_htmlabout-pp.html')
Opening file://C:MarkWEBSITEpublic_htmlabout-pp.html
Starting
>>>

When called like this, launchBrowser isn’t much different than spawning a start command on DOS or a netscape command on Linux, but the Python launchBrowser function is designed to be a portable interface for browser startup across platforms. Python scripts can use this interface to pop up local HTML documents in web browsers; on machines with live Internet links, this call even lets scripts open browsers on remote pages on the Web:

>>>launchBrowser(Mode='-live', Page='index.html', Site='www.python.org')
Opening http://www.python.org/index.html
Starting

>>> launchBrowser(Mode='-live', Page='PyInternetDemos.html',
...                             Site='localhost')
Opening http://localhost/PyInternetDemos.html
Starting

On a computer where there is just a dial-up connection, the first call here opens a new Internet Explorer GUI window if needed, dials out through a modem, and fetches the Python home page from http://www.python.org on both Windows and Linux—not bad for a single function call. On broadband connections, the page comes up directly. The second call does the same but, using a locally running web server, opens a web demos page we’ll explore in Chapter 16.

I mentioned earlier that browsers are a cheap way to present multimedia. Alas, this sort of thing is best viewed live, so the best I can do is show startup commands here. The next command line and function call, for example, display two GIF images in Internet Explorer on my machine (be sure to use full local pathnames). The result of the first of these is captured in Figure 6-3 (you may have to edit the browser tries list and start-mode flags on your machine to make this work).

Figure 6-3. Launching a browser on an image file

C:...PP3E>python LaunchBrowser.py
           -file C:MarkPP3E-cdExamplesPP3EGuiPILimagesdublin3.jpg

C:	emp>python
>>> from LaunchBrowser import launchBrowser
>>> launchBrowser(Page=r'C:	empExamplesPP3EGuigifsmp_lumberjack.gif')

The next command line and call open the sousa.au audio file on my machine; the second of these downloads the file from http://www.rmi.net first. If all goes as planned, the Monty Python theme song should play on your computer:

C:PP3rdEdexamples>python LaunchBrowser.py
                     -file C:MarkPP3E-cdExamplesPP3EInternetFtpsousa.au
Opening file://C:PP3E-cdExamplesPP3EInternetFtpsousa.au
Starting

>>> launchBrowser(Mode='-live',
...               Site='www.rmi.net',
...               Page='~lutz/sousa.au',
...               verbose=0)
>>>

Of course, you could just pass these filenames to a spawned start command or os.startfile call on Windows, or run the appropriate handler program directly with something like os.system. But opening these files in a browser is a more portable approach; you don’t need to keep track of a set of file-handler programs per platform. Provided your scripts use a portable browser launcher such as LaunchBrowser, you don’t even need to keep track of a browser per platform.

That generality is a win unless you wish to do something more specific for certain media types or can’t run a web browser. On some PDAs, for instance, you may not be able to open a general web browser on a particular file. In the next section, we’ll see how to get more specific when we need to.

Finally, I want to point out that LaunchBrowser reflects browsers that I tend to use. For instance, it tries to find Firefox and then Internet Explorer before Netscape on Windows, and prefers Netscape over Mosaic and Lynx on Linux, but you should feel free to change these choices in your copy of the script. In fact, both LaunchBrowser and Launcher make a few heuristic guesses when searching for files that may not make sense on every computer. Configure as needed.

Like LaunchBrowser of the prior section, the standard library webbrowser module also attempts to provide a portable interface for launching browsers from scripts. Its implementation is more complex but likely to support more options and platforms than the LaunchBrowser script presented earlier (classic Macintosh browsers, for instance, are directly supported as well). Its interface is straightforward:

import webbrowser
webbrowser.open_new('file://' + fullfilename)         # or http://...

The preceding code will open the named file in a new web browser window using whatever browser is found on the underlying computer or raise an exception if it cannot. Use the module’s open call to reuse an already-open browser window if possible, and use an argument string of the form “http://...” to open a page on a web server. In fact, you can pass in any URL that the browser understands. The following pops up Python’s home page in a new browser window, for example:

>>> webbrowser.open_new('http://www.python.org')

Among other things, this is an easy way to display HTML documents as well as media files, as shown in the prior section. We’ll use this module later in this book as a way to display HTML-formatted email messages in the PyMailGUI program in Chapter 15. See the Python library manual for more details. In Chapter 16, we’ll also meet a related call, urllib.urlopen, which fetches a web page’s text but does not open it in a browser.

To demonstrate the webbrowser module’s basic utility, though, let’s code another way to open multimedia files. Example 6-16 tries to open a media file on your computer in a somewhat more intelligent way. As a last resort, it always falls back on trying to open the file in a web browser, much like we did in the prior section. Here, though, we first try to run a type-specific player if one is specific in tables, and we use the Python standard library’s webbrowser to open a browser instead of using our LaunchBrowser.

To make this even more useful, we also use the Python mimetypes standard library module to automatically determine the media type from the filename. We get back a type/subtype MIME content-type string if the type can be determined or None if the guess failed:

>>>import mimetypes
>>> mimetypes.guess_type('spam.jpg')
('image/jpeg', None)

>>> mimetypes.guess_type('TheBrightSideOfLife.mp3')
('audio/mpeg', None)

>>> mimetypes.guess_type('lifeofbrian.mpg')
('video/mpeg', None)

>>> mimetypes.guess_type('lifeofbrian.xyz')       # unknown type
(None, None)

Stripping off the first part of the content-type string gives the file’s general media type, which we can use to select a generic player:

>>>contype, encoding = mimetypes.guess_type('spam.jpg')
>>> contype.split('/')[0]
'image'

A subtle thing: the second item in the tuple returned from the mimetypes guess is an encoding type we won’t use here for opening purposes. We still have to pay attention to it, though—if it is not None, it means the file is compressed (gzip or compress), even if we receive a media content type. For example, if the filename is something like spam.gif.gz, it’s a compressed image that we don’t want to try to open directly:

>>>mimetypes.guess_type('spam.gz')              # content unknown
(None, 'gzip')

>>> mimetypes.guess_type('spam.gif.gz')          # don't play me!
('image/gif', 'gzip')

>>> mimetypes.guess_type('spam.zip')             # skip archives
('application/zip', None)

This module is even smart enough to give us a filename extension for a type:

>>>mimetypes.guess_type('sousa.au')
('audio/basic', None)

>>> mimetypes.guess_extension('audio/basic')
'.au'

We’ll use the mimetypes module again in FTP examples in Chapter 14 to determine transfer type (text or binary), and in our email examples in Chapters 14 and 15 to send, save, and open mail attachments.

In Example 6-16, we use mimetypes to select a table of platform-specific player commands for the media type of the file to be played. That is, we pick a player table for the file’s media type, and then pick a command from the player table for the platform. At each step, we give up and run a web browser if there is nothing more specific to be done. The end result is a general and smarter media player tool that you can extend as needed. It will be as portable and specific as the tables you provide to it.

#!/usr/local/bin/python
################################################################################
# Try to play an arbitrary media file.  This may not work on your system as is;
# audio files use filters and command lines on Unix, and filename associations
# on Windows via the start command (i.e., whatever you have on your machine to
# run .au files--an audio player, or perhaps a web browser).  Configure and
# extend as needed.  As a last resort, always tries to launch a web browser with
# Python webbrowser module (like LaunchBrowser.py).  See also: Lib/audiodev.py.
# playknownfile assumes you know what sort of media you wish to open; playfile
# tries to determine media type automatically using Python mimetypes module.
################################################################################

import os, sys

helpmsg = """
Sorry: can't find a media player for '%s' on your system!
Add an entry for your system to the media player dictionary
for this type of file in playfile.py, or play the file manually.
"""

def trace(*args):
    print ' '.join(args)   # with spaces between

################################################################################
# player techniques: generic and otherwise: extend me
################################################################################

class MediaTool:
    def _ _init_ _(self, runtext=''):
        self.runtext = runtext

class Filter(MediaTool):
    def run(self, mediafile, **options):
        media  = open(mediafile, 'rb')
        player = os.popen(self.runtext, 'w')          # spawn shell tool
        player.write(media.read( ))                  # send to its stdin

class Cmdline(MediaTool):
    def run(self, mediafile, **options):
        cmdline = self.runtext % mediafile          # run any cmd line
        os.system(cmdline)                          # use %s for filename

class Winstart(MediaTool):                          # use Windows registry
    def run(self, mediafile, wait=False):           # or os.system('start file')
        if not wait:                                # allow wait for curr media
            os.startfile(mediafile)
        else:
            os.system('start /WAIT ' + mediafile)

class Webbrowser(MediaTool):
    def run(self, mediafile, **options):                 # open in web browser
        import webbrowser                                # find browser, no wait
        fullpath = os.path.abspath(mediafile)            # file:// needs abs dir
        webbrowser.open_new('file://%s' % fullpath)      # open media file

################################################################################
# media- and platform-specific policies: change me, or pass one in
##############################################################################

# map platform to player: change me!

audiotools = {
    'sunos5':  Filter('/usr/bin/audioplay'),             # os.popen().write( )
    'linux2':  Cmdline('cat %s > /dev/audio'),           # on zaurus, at least
    'sunos4':  Filter('/usr/demo/SOUND/play'),
    'win32':   Winstart( )                                # startfile or system
   #'win32':   Cmdline('start %s')
    }

videotools = {
    'linux2':  Cmdline('tkcVideo_c700 %s'),               # zaurus pda
    'win32':   Winstart( ),                               # avoid DOS pop up
    }

imagetools = {
    'linux2':  Cmdline('zimager %s/%%s' % os.getcwd( )),  # zaurus pda
    'win32':   Winstart( ),
    }

# map mimetype of filenames to player tables

mimetable = {'audio': audiotools,                        # add text: PyEdit?
             'video': videotools,
             'image': imagetools}

################################################################################
# top-level interfaces
################################################################################

def trywebbrowser(mediafile, helpmsg=helpmsg):
    """
    try to open a file in a web browser
    """
    trace('trying browser', mediafile)                         # last resort
    try:
        player = Webbrowser( )
        player.run(mediafile)
    except:
        print helpmsg % mediafile                              # nothing worked

def playknownfile(mediafile, playertable={}, **options):
    """
    play media file of known type: uses platform-specific
    player objects, or spawns a web browser if nothing for
    this platform; pass in a media-specific player table
    """
    if sys.platform in playertable:
        playertable[sys.platform].run(mediafile, **options)    # specific tool
    else:
        trywebbrowser(mediafile)                               # general scheme

def playfile(mediafile, mimetable=mimetable, **options):
    """
    play media file of any type: uses mimetypes to guess
    media type and map to platform-specific player tables;
    spawn web browser if media type unknown, or has no table
    """
    import mimetypes
    (contenttype, encoding) = mimetypes.guess_type(mediafile)     # check name
    if contenttype == None or encoding is not None:               # can't guess
        contenttype = '?/?'                                       # poss .txt.gz
    maintype, subtype = contenttype.split('/', 1)                 # 'image/jpeg'
    if maintype in mimetable:
        playknownfile(mediafile, mimetable[maintype], **options)  # try table
    else:
        trywebbrowser(mediafile)                                  # other types

###############################################################################
# self-test code
###############################################################################

if _ _name_ _ == '_ _main_ _':
    # media type known
    playknownfile('sousa.au', audiotools, wait=True)
    playknownfile('ora-pp2e.jpg', imagetools, wait=True)
    playknownfile('mov10428.mpg', videotools, wait=True)
    playknownfile('img_0276.jpg', imagetools)
    playknownfile('mov10510.mpg', mimetable['video'])

    # media type guessed
    raw_input('Stop players and press Enter')
    playfile('sousa.au', wait=True)                       # default mimetable
    playfile('img_0268.jpg')
    playfile('mov10428.mpg' , mimetable)                  # no extra options
    playfile('calendar.html')                             # default web browser
    playfile('wordfile.doc')
    raw_input('Done')                                     # stay open if clicked

One coding note: we could also write the playknownfile function the following way (this form is more concise, but some future readers of our code might make the case that it is also less explicit and hence less understandable, especially if we code the same way in playfile with an empty table default):

defaultplayer = Webbrowser( )
player = playertable.get(sys.platform, defaultplayer)
player.run(mediafile, **options)

Study this script’s code and run it on your own computer to see what happens. As usual, you can test it interactively (use the package path to import from a different directory):

>>>from PP3E.System.Media.playfile import playfile
>>> playfile('mov10428.mpg')

We’ll use this example again as an imported library like this in Chapter 14 to open media files downloaded by FTP. When the script file is run directly, if all goes well, its self-test code at the end opens a number of audio, image, and video files located in the script’s directory, using either platform-specific players or a general web browser on your machine. Just for fun, it also opens an HTML file and a Word document to test the web browser code. As is, its player tables are only populated with commands for the machines on which I tested it:

Figure 6-4 shows the script’s handiwork on Windows. For other platforms and machines, you will likely have to extend the player dictionaries with platform-specific entries, within this file, or by assigning from outside:

import playfile
playfile.audiotools['platformX'] = playfile.Cmdline('...')
playfile.mimetable['newstuff'] = {...}

Figure 6-4. Launching media files with specific players

Or you can pass your own player table to the playfile function:

from playfile import playfile
myplayers = {...}                              # or start with mimetools.copy( )
playfile('Nautyus_Maximus.xyz', myplayers)

The MediaTool classes in this file provide general ways to open files, but you may also need to subclass to customize for unique cases. This script also assumes the media file is located on the local machine (even though the webbrowser module supports remote files with “http://” names), and it does not currently allow different players for different MIME subtypes (you may want to handle both “text/plain” and “text/xml” differently).

In fact, this script is really just something of a simple framework that was designed to be extended. As always, hack on; this is Python, after all.

...PP3ESystemMedia>set BROWSER=C:"Program Files""Mozilla Firefox"firefox.exe
 %s
...PP3ESystemMedia>playfile.py

...PP3ESystemMedia>set PATH=%PATH%;C:Program FilesMozilla Firefox
...PP3ESystemMedia>set BROWSER=firefox.exe
...PP3ESystemMedia>playfile.py