home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / hplip / base / utils.py < prev    next >
Encoding:
Python Source  |  2008-10-13  |  43.5 KB  |  1,469 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2001-2008 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19. # Author: Don Welch
  20. #
  21. # Thanks to Henrique M. Holschuh <hmh@debian.org> for various security patches
  22. #
  23.  
  24. from __future__ import generators
  25.  
  26. # Std Lib
  27. import sys
  28. import os
  29. import fnmatch
  30. import tempfile
  31. import socket
  32. import struct
  33. import select
  34. import time
  35. import fcntl
  36. import errno
  37. import stat
  38. import string
  39. import commands # TODO: Replace with subprocess (commands is deprecated in Python 3.0)
  40. import cStringIO
  41. import re
  42. import xml.parsers.expat as expat
  43. import getpass
  44. import locale
  45.  
  46. try:
  47.     import platform
  48.     platform_avail = True
  49. except ImportError:
  50.     platform_avail = False
  51.     
  52. # Local
  53. from g import *
  54. from codes import *
  55. import pexpect
  56.  
  57.  
  58.  
  59. def lock(f):
  60.     log.debug("Locking: %s" % f.name)
  61.     try:
  62.         fcntl.flock(f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
  63.         return True
  64.     except (IOError, OSError):
  65.         log.debug("Failed to unlock %s." % f.name)
  66.         return False
  67.  
  68.         
  69. def unlock(f):
  70.     if f is not None:
  71.         log.debug("Unlocking: %s" % f.name)
  72.         try:
  73.             fcntl.flock(f.fileno(), fcntl.LOCK_UN)
  74.             os.remove(f.name)
  75.         except (IOError, OSError):
  76.             pass
  77.         
  78.         
  79. def lock_app(application, suppress_error=False):
  80.     if not os.path.exists(prop.user_dir):
  81.         os.makedirs(prop.user_dir)
  82.         
  83.     lock_file = os.path.join(prop.user_dir, '.'.join([application, 'lock']))
  84.     try:
  85.         lock_file_f = open(lock_file, "w")
  86.     except IOError:
  87.         if not suppress_error:
  88.             log.error("Unable to open %s lock file." % lock_file) 
  89.         return False, None
  90.  
  91.     log.debug("Locking file: %s" % lock_file)
  92.     
  93.     if not lock(lock_file_f):
  94.         if not suppress_error:
  95.             log.error("Unable to lock %s. Is %s already running?" % (lock_file, application))
  96.         return False, None
  97.     
  98.     return True, lock_file_f
  99.  
  100.  
  101. xml_basename_pat = re.compile(r"""HPLIP-(\d*)_(\d*)_(\d*).xml""", re.IGNORECASE)
  102.  
  103.  
  104. def Translator(frm='', to='', delete='', keep=None):
  105.     allchars = string.maketrans('','')
  106.  
  107.     if len(to) == 1:
  108.         to = to * len(frm)
  109.     trans = string.maketrans(frm, to)
  110.  
  111.     if keep is not None:
  112.         delete = allchars.translate(allchars, keep.translate(allchars, delete))
  113.  
  114.     def callable(s):
  115.         return s.translate(trans, delete)
  116.  
  117.     return callable
  118.  
  119.  
  120. def to_bool_str(s, default='0'):
  121.     """ Convert an arbitrary 0/1/T/F/Y/N string to a normalized string 0/1."""
  122.     if isinstance(s, str) and s:
  123.         if s[0].lower() in ['1', 't', 'y']:
  124.             return u'1'
  125.         elif s[0].lower() in ['0', 'f', 'n']:
  126.             return u'0'
  127.  
  128.     return default
  129.  
  130. def to_bool(s, default=False):
  131.     """ Convert an arbitrary 0/1/T/F/Y/N string to a boolean True/False value."""
  132.     if isinstance(s, str) and s:
  133.         if s[0].lower() in ['1', 't', 'y']:
  134.             return True
  135.         elif s[0].lower() in ['0', 'f', 'n']:
  136.             return False
  137.     elif isinstance(s, bool):
  138.         return s
  139.  
  140.     return default
  141.  
  142.  
  143. def walkFiles(root, recurse=True, abs_paths=False, return_folders=False, pattern='*', path=None):
  144.     if path is None:
  145.         path = root
  146.  
  147.     try:
  148.         names = os.listdir(root)
  149.     except os.error:
  150.         raise StopIteration
  151.  
  152.     pattern = pattern or '*'
  153.     pat_list = pattern.split(';')
  154.  
  155.     for name in names:
  156.         fullname = os.path.normpath(os.path.join(root, name))
  157.  
  158.         for pat in pat_list:
  159.             if fnmatch.fnmatch(name, pat):
  160.                 if return_folders or not os.path.isdir(fullname):
  161.                     if abs_paths:
  162.                         yield fullname
  163.                     else:
  164.                         try:
  165.                             yield os.path.basename(fullname)
  166.                         except ValueError:
  167.                             yield fullname
  168.  
  169.         #if os.path.islink(fullname):
  170.         #    fullname = os.path.realpath(os.readlink(fullname))
  171.  
  172.         if recurse and os.path.isdir(fullname): # or os.path.islink(fullname):
  173.             for f in walkFiles(fullname, recurse, abs_paths, return_folders, pattern, path):
  174.                 yield f
  175.  
  176.  
  177. def is_path_writable(path):
  178.     if os.path.exists(path):
  179.         s = os.stat(path)
  180.         mode = s[stat.ST_MODE] & 0777
  181.  
  182.         if mode & 02:
  183.             return True
  184.         elif s[stat.ST_GID] == os.getgid() and mode & 020:
  185.             return True
  186.         elif s[stat.ST_UID] == os.getuid() and mode & 0200:
  187.             return True
  188.  
  189.     return False
  190.  
  191.  
  192. # Provides the TextFormatter class for formatting text into columns.
  193. # Original Author: Hamish B Lawson, 1999
  194. # Modified by: Don Welch, 2003
  195. class TextFormatter:
  196.  
  197.     LEFT  = 0
  198.     CENTER = 1
  199.     RIGHT  = 2
  200.  
  201.     def __init__(self, colspeclist):
  202.         self.columns = []
  203.         for colspec in colspeclist:
  204.             self.columns.append(Column(**colspec))
  205.  
  206.     def compose(self, textlist, add_newline=False):
  207.         numlines = 0
  208.         textlist = list(textlist)
  209.         if len(textlist) != len(self.columns):
  210.             log.error("Formatter: Number of text items does not match columns")
  211.             return
  212.         for text, column in map(None, textlist, self.columns):
  213.             column.wrap(text)
  214.             numlines = max(numlines, len(column.lines))
  215.         complines = [''] * numlines
  216.         for ln in range(numlines):
  217.             for column in self.columns:
  218.                 complines[ln] = complines[ln] + column.getline(ln)
  219.         if add_newline:
  220.             return '\n'.join(complines) + '\n'
  221.         else:
  222.             return '\n'.join(complines)
  223.  
  224. class Column:
  225.  
  226.     def __init__(self, width=78, alignment=TextFormatter.LEFT, margin=0):
  227.         self.width = width
  228.         self.alignment = alignment
  229.         self.margin = margin
  230.         self.lines = []
  231.  
  232.     def align(self, line):
  233.         if self.alignment == TextFormatter.CENTER:
  234.             return line.center(self.width)
  235.         elif self.alignment == TextFormatter.RIGHT:
  236.             return line.rjust(self.width)
  237.         else:
  238.             return line.ljust(self.width)
  239.  
  240.     def wrap(self, text):
  241.         self.lines = []
  242.         words = []
  243.         for word in text.split():
  244.             if word <= self.width:
  245.                 words.append(word)
  246.             else:
  247.                 for i in range(0, len(word), self.width):
  248.                     words.append(word[i:i+self.width])
  249.         if not len(words): return
  250.         current = words.pop(0)
  251.         for word in words:
  252.             increment = 1 + len(word)
  253.             if len(current) + increment > self.width:
  254.                 self.lines.append(self.align(current))
  255.                 current = word
  256.             else:
  257.                 current = current + ' ' + word
  258.         self.lines.append(self.align(current))
  259.  
  260.     def getline(self, index):
  261.         if index < len(self.lines):
  262.             return ' '*self.margin + self.lines[index]
  263.         else:
  264.             return ' ' * (self.margin + self.width)
  265.  
  266.  
  267.             
  268. class Stack:
  269.     def __init__(self):
  270.         self.stack = []
  271.  
  272.     def pop(self):
  273.         return self.stack.pop()
  274.  
  275.     def push(self, value):
  276.         self.stack.append(value)
  277.         
  278.     def as_list(self):
  279.         return self.stack
  280.  
  281.     def clear(self):
  282.         self.stack = []
  283.         
  284.     def __len__(self):
  285.         return len(self.stack)
  286.         
  287.         
  288.         
  289. class Queue(Stack):
  290.     def __init__(self):
  291.         Stack.__init__(self)
  292.  
  293.     def get(self):
  294.         return self.stack.pop(0)
  295.         
  296.     def put(self, value):
  297.         Stack.push(self, value)
  298.  
  299.    
  300.  
  301.  
  302. # RingBuffer class
  303. # Source: Python Cookbook 1st Ed., sec. 5.18, pg. 201
  304. # Credit: Sebastien Keim
  305. # License: Modified BSD
  306. class RingBuffer:
  307.     def __init__(self,size_max=50):
  308.         self.max = size_max
  309.         self.data = []
  310.  
  311.     def append(self,x):
  312.         """append an element at the end of the buffer"""
  313.         self.data.append(x)
  314.  
  315.         if len(self.data) == self.max:
  316.             self.cur = 0
  317.             self.__class__ = RingBufferFull
  318.  
  319.     def replace(self, x):
  320.         """replace the last element instead off appending"""
  321.         self.data[-1] = x
  322.  
  323.     def get(self):
  324.         """ return a list of elements from the oldest to the newest"""
  325.         return self.data
  326.  
  327.  
  328. class RingBufferFull:
  329.     def __init__(self,n):
  330.         #raise "you should use RingBuffer"
  331.         pass
  332.  
  333.     def append(self,x):
  334.         self.data[self.cur] = x
  335.         self.cur = (self.cur+1) % self.max
  336.  
  337.     def replace(self, x):
  338.         # back up 1 position to previous location
  339.         self.cur = (self.cur-1) % self.max
  340.         self.data[self.cur] = x
  341.         # setup for next item
  342.         self.cur = (self.cur+1) % self.max
  343.  
  344.     def get(self):
  345.         return self.data[self.cur:] + self.data[:self.cur]
  346.  
  347. def sort_dict_by_value(d):
  348.     """ Returns the keys of dictionary d sorted by their values """
  349.     items=d.items()
  350.     backitems=[[v[1],v[0]] for v in items]
  351.     backitems.sort()
  352.     return [backitems[i][1] for i in range(0, len(backitems))]
  353.  
  354. def commafy(val): 
  355.     return unicode(locale.format("%d", val, grouping=True))
  356.  
  357.  
  358. def format_bytes(s, show_bytes=False):
  359.     if s < 1024:
  360.         return ''.join([commafy(s), ' B'])
  361.     elif 1024 < s < 1048576:
  362.         if show_bytes:
  363.             return ''.join([unicode(round(s/1024.0, 1)) , u' KB (',  commafy(s), ')'])
  364.         else:
  365.             return ''.join([unicode(round(s/1024.0, 1)) , u' KB'])
  366.     elif 1048576 < s < 1073741824:
  367.         if show_bytes:
  368.             return ''.join([unicode(round(s/1048576.0, 1)), u' MB (',  commafy(s), ')'])
  369.         else:
  370.             return ''.join([unicode(round(s/1048576.0, 1)), u' MB'])
  371.     else:
  372.         if show_bytes:
  373.             return ''.join([unicode(round(s/1073741824.0, 1)), u' GB (',  commafy(s), ')'])
  374.         else:
  375.             return ''.join([unicode(round(s/1073741824.0, 1)), u' GB'])
  376.  
  377.  
  378.  
  379. try:
  380.     make_temp_file = tempfile.mkstemp # 2.3+
  381. except AttributeError:
  382.     def make_temp_file(suffix='', prefix='', dir='', text=False): # pre-2.3
  383.         path = tempfile.mktemp(suffix)
  384.         fd = os.open(path, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700)
  385.         return ( os.fdopen( fd, 'w+b' ), path )
  386.  
  387. def log_title(program_name, version, show_ver=True):
  388.     log.info("")
  389.  
  390.     if show_ver:
  391.         log.info(log.bold("HP Linux Imaging and Printing System (ver. %s)" % prop.version))
  392.     else:    
  393.         log.info(log.bold("HP Linux Imaging and Printing System"))
  394.  
  395.     log.info(log.bold("%s ver. %s" % (program_name, version)))
  396.     log.info("")
  397.     log.info("Copyright (c) 2001-8 Hewlett-Packard Development Company, LP")
  398.     log.info("This software comes with ABSOLUTELY NO WARRANTY.")
  399.     log.info("This is free software, and you are welcome to distribute it")
  400.     log.info("under certain conditions. See COPYING file for more details.")
  401.     log.info("")
  402.  
  403.  
  404. def which(command, return_full_path=False):
  405.     path = os.getenv('PATH').split(':')
  406.  
  407.     # Add these paths for Fedora
  408.     path.append('/sbin')
  409.     path.append('/usr/sbin')
  410.     path.append('/usr/local/sbin')
  411.  
  412.     found_path = ''
  413.     for p in path:
  414.         try:
  415.             files = os.listdir(p)
  416.         except OSError:
  417.             continue
  418.         else:
  419.             if command in files:
  420.                 found_path = p
  421.                 break
  422.  
  423.     if return_full_path:
  424.         if found_path:
  425.             return os.path.join(found_path, command)
  426.         else:
  427.             return ''
  428.     else:
  429.         return found_path
  430.  
  431.  
  432. class UserSettings(object):
  433.     def __init__(self):
  434.         self.load()
  435.  
  436.     def loadDefaults(self):
  437.         # Print
  438.         self.cmd_print = ''
  439.         path = which('hp-print')
  440.  
  441.         if len(path) > 0:
  442.             self.cmd_print = 'hp-print -p%PRINTER%'
  443.         else:
  444.             path = which('kprinter')
  445.  
  446.             if len(path) > 0:
  447.                 self.cmd_print = 'kprinter -P%PRINTER% --system cups'
  448.             else:
  449.                 path = which('gtklp')
  450.  
  451.                 if len(path) > 0:
  452.                     self.cmd_print = 'gtklp -P%PRINTER%'
  453.  
  454.                 else:
  455.                     path = which('xpp')
  456.  
  457.                     if len(path) > 0:
  458.                         self.cmd_print = 'xpp -P%PRINTER%'
  459.  
  460.         # Scan
  461.         self.cmd_scan = ''
  462.         path = which('xsane')
  463.  
  464.         if len(path) > 0:
  465.             self.cmd_scan = 'xsane -V %SANE_URI%'
  466.         else:
  467.             path = which('kooka')
  468.  
  469.             if len(path) > 0:
  470.                 self.cmd_scan = 'kooka'
  471.  
  472.             else:
  473.                 path = which('xscanimage')
  474.  
  475.                 if len(path) > 0:
  476.                     self.cmd_scan = 'xscanimage'
  477.  
  478.         # Photo Card
  479.         path = which('hp-unload')
  480.  
  481.         if len(path):
  482.             self.cmd_pcard = 'hp-unload -d %DEVICE_URI%'
  483.  
  484.         else:
  485.             self.cmd_pcard = 'python %HOME%/unload.py -d %DEVICE_URI%'
  486.  
  487.         # Copy
  488.         path = which('hp-makecopies')
  489.  
  490.         if len(path):
  491.             self.cmd_copy = 'hp-makecopies -d %DEVICE_URI%'
  492.  
  493.         else:
  494.             self.cmd_copy = 'python %HOME%/makecopies.py -d %DEVICE_URI%'
  495.  
  496.         # Fax
  497.         path = which('hp-sendfax')
  498.  
  499.         if len(path):
  500.             self.cmd_fax = 'hp-sendfax -d %FAX_URI%'
  501.  
  502.         else:
  503.             self.cmd_fax = 'python %HOME%/sendfax.py -d %FAX_URI%'
  504.  
  505.         # Fax Address Book
  506.         path = which('hp-fab')
  507.  
  508.         if len(path):
  509.             self.cmd_fab = 'hp-fab'
  510.  
  511.         else:
  512.             self.cmd_fab = 'python %HOME%/fab.py'    
  513.  
  514.     def load(self):
  515.         self.loadDefaults()
  516.  
  517.         log.debug("Loading user settings...")
  518.  
  519. ##        self.email_alerts = to_bool(user_cfg.alerts.email_alerts, False)
  520. ##        self.email_to_addresses = user_cfg.alerts.email_to_addresses
  521. ##        self.email_from_address = user_cfg.alerts.email_from_address
  522.         self.auto_refresh = to_bool(user_cfg.refresh.enable, False)
  523.  
  524.         try:
  525.             self.auto_refresh_rate = int(user_cfg.refresh.rate)
  526.         except ValueError:    
  527.             self.auto_refresh_rate = 30 # (secs)
  528.  
  529.         try:
  530.             self.auto_refresh_type = int(user_cfg.refresh.type)
  531.         except ValueError:
  532.             self.auto_refresh_type = 0 # refresh 1 (1=refresh all)
  533.  
  534.         self.cmd_print = user_cfg.commands.prnt or self.cmd_print
  535.         #self.cmd_print_int = to_bool(user_cfg.commands.prnt_int, True)
  536.  
  537.         self.cmd_scan = user_cfg.commands.scan or self.cmd_scan
  538.         #self.cmd_scan_int = to_bool(user_cfg.commands.scan_int, False)
  539.  
  540.         self.cmd_pcard = user_cfg.commands.pcard or self.cmd_pcard
  541.         #self.cmd_pcard_int = to_bool(user_cfg.commands.pcard_int, True)
  542.  
  543.         self.cmd_copy = user_cfg.commands.cpy or self.cmd_copy
  544.         #self.cmd_copy_int = to_bool(user_cfg.commands.cpy_int, True)
  545.  
  546.         self.cmd_fax = user_cfg.commands.fax or self.cmd_fax
  547.         #self.cmd_fax_int = to_bool(user_cfg.commands.fax_int, True)
  548.  
  549.         self.cmd_fab = user_cfg.commands.fab or self.cmd_fab
  550.         #self.cmd_fab_int = to_bool(user_cfg.commands.fab_int, False)
  551.  
  552.         self.debug()
  553.  
  554.     def debug(self):
  555.         log.debug("Print command: %s" % self.cmd_print)
  556.         #log.debug("Use Internal print command: %s" % self.cmd_print_int)
  557.  
  558.         log.debug("PCard command: %s" % self.cmd_pcard)
  559.         #log.debug("Use internal PCard command: %s" % self.cmd_pcard_int)
  560.  
  561.         log.debug("Fax command: %s" % self.cmd_fax)
  562.         #log.debug("Use internal fax command: %s" % self.cmd_fax_int)
  563.  
  564.         log.debug("FAB command: %s" % self.cmd_fab)
  565.         #log.debug("Use internal FAB command: %s" % self.cmd_fab_int)
  566.  
  567.         log.debug("Copy command: %s " % self.cmd_copy)
  568.         #log.debug("Use internal copy command: %s " % self.cmd_copy_int)
  569.  
  570.         log.debug("Scan command: %s" % self.cmd_scan)
  571.         #log.debug("Use internal scan command: %s" % self.cmd_scan_int)
  572.  
  573. ##        log.debug("Email alerts: %s" % self.email_alerts)
  574. ##        log.debug("Email to address(es): %s" % self.email_to_addresses)
  575. ##        log.debug("Email from address: %s" % self.email_from_address)
  576.         log.debug("Auto refresh: %s" % self.auto_refresh)
  577.         log.debug("Auto refresh rate: %s" % self.auto_refresh_rate)
  578.         log.debug("Auto refresh type: %s" % self.auto_refresh_type)        
  579.  
  580.     def save(self):
  581.         log.debug("Saving user settings...")
  582.  
  583.         user_cfg.commands.prnt = self.cmd_print
  584.         #user_cfg.commands.prnt_int = self.cmd_print_int
  585.  
  586.         user_cfg.commands.pcard = self.cmd_pcard
  587.         #user_cfg.commands.pcard_int = self.cmd_pcard_int
  588.  
  589.         user_cfg.commands.fax = self.cmd_fax
  590.         #user_cfg.commands.fax_int = self.cmd_fax_int
  591.  
  592.         user_cfg.commands.scan = self.cmd_scan
  593.         #user_cfg.commands.scan_int = self.cmd_scan_int
  594.  
  595.         user_cfg.commands.cpy = self.cmd_copy
  596.         #user_cfg.commands.cpy_int = self.cmd_copy_int
  597.  
  598. ##        user_cfg.alerts.email_to_addresses = self.email_to_addresses
  599. ##        user_cfg.alerts.email_from_address = self.email_from_address
  600. ##        user_cfg.alerts.email_alerts = self.email_alerts
  601.  
  602.         user_cfg.refresh.enable = self.auto_refresh
  603.         user_cfg.refresh.rate = self.auto_refresh_rate
  604.         user_cfg.refresh.type = self.auto_refresh_type
  605.  
  606.         self.debug()
  607.  
  608.  
  609.  
  610. def no_qt_message_gtk():
  611.     try:
  612.         import gtk
  613.         w = gtk.Window()
  614.         dialog = gtk.MessageDialog(w, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
  615.                                    gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, 
  616.                                    "PyQt not installed. GUI not available. Install \"python-qt3\" with the Synaptic Package Manager (Menu: System -> Administration -> Synaptic Package Manager) or run the command \"sudo apt-get install python-qt3\" in a terminal window.")
  617.         dialog.run()
  618.         dialog.destroy()
  619.  
  620.     except ImportError:
  621.         log.error("PyQt not installed. GUI not available. Please check that the PyQt package is installed. Exiting.")
  622.  
  623.  
  624. def canEnterGUIMode():
  625.     if not prop.gui_build:
  626.         log.warn("GUI mode disabled in build.")
  627.         return False
  628.  
  629.     elif not os.getenv('DISPLAY'):
  630.         log.warn("No display found.")
  631.         return False
  632.  
  633.     elif not checkPyQtImport():
  634.         log.warn("Qt/PyQt initialization failed.")
  635.         return False
  636.  
  637.     return True
  638.  
  639. def checkPyQtImport():
  640.     # PyQt
  641.     try:
  642.         import qt
  643.     except ImportError:
  644.         if os.getenv('DISPLAY') and os.getenv('STARTED_FROM_MENU'):
  645.             no_qt_message_gtk()
  646.  
  647.         log.error("PyQt not installed. GUI not available. Exiting.")
  648.         return False
  649.  
  650.     # check version of Qt
  651.     qtMajor = int(qt.qVersion().split('.')[0])
  652.  
  653.     if qtMajor < MINIMUM_QT_MAJOR_VER:
  654.  
  655.         log.error("Incorrect version of Qt installed. Ver. 3.0.0 or greater required.")
  656.         return False
  657.  
  658.     #check version of PyQt
  659.     try:
  660.         pyqtVersion = qt.PYQT_VERSION_STR
  661.     except AttributeError:
  662.         pyqtVersion = qt.PYQT_VERSION
  663.  
  664.     while pyqtVersion.count('.') < 2:
  665.         pyqtVersion += '.0'
  666.  
  667.     (maj_ver, min_ver, pat_ver) = pyqtVersion.split('.')
  668.  
  669.     if pyqtVersion.find('snapshot') >= 0:
  670.         log.warning("A non-stable snapshot version of PyQt is installed.")
  671.     else:
  672.         try:
  673.             maj_ver = int(maj_ver)
  674.             min_ver = int(min_ver)
  675.             pat_ver = int(pat_ver)
  676.         except ValueError:
  677.             maj_ver, min_ver, pat_ver = 0, 0, 0
  678.  
  679.         if maj_ver < MINIMUM_PYQT_MAJOR_VER or \
  680.             (maj_ver == MINIMUM_PYQT_MAJOR_VER and min_ver < MINIMUM_PYQT_MINOR_VER):
  681.             log.error("This program may not function properly with the version of PyQt that is installed (%d.%d.%d)." % (maj_ver, min_ver, pat_ver))
  682.             log.error("Incorrect version of pyQt installed. Ver. %d.%d or greater required." % (MINIMUM_PYQT_MAJOR_VER, MINIMUM_PYQT_MINOR_VER))
  683.             log.error("This program will continue, but you may experience errors, crashes or other problems.")
  684.             return True
  685.  
  686.     return True
  687.  
  688. try:
  689.     from string import Template # will fail in Python <= 2.3
  690. except ImportError:
  691.     # Code from Python 2.4 string.py
  692.     #import re as _re
  693.  
  694.     class _multimap:
  695.         """Helper class for combining multiple mappings.
  696.  
  697.         Used by .{safe_,}substitute() to combine the mapping and keyword
  698.         arguments.
  699.         """
  700.         def __init__(self, primary, secondary):
  701.             self._primary = primary
  702.             self._secondary = secondary
  703.  
  704.         def __getitem__(self, key):
  705.             try:
  706.                 return self._primary[key]
  707.             except KeyError:
  708.                 return self._secondary[key]
  709.  
  710.  
  711.     class _TemplateMetaclass(type):
  712.         pattern = r"""
  713.         %(delim)s(?:
  714.           (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
  715.           (?P<named>%(id)s)      |   # delimiter and a Python identifier
  716.           {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
  717.           (?P<invalid>)              # Other ill-formed delimiter exprs
  718.         )
  719.         """
  720.  
  721.         def __init__(cls, name, bases, dct):
  722.             super(_TemplateMetaclass, cls).__init__(name, bases, dct)
  723.             if 'pattern' in dct:
  724.                 pattern = cls.pattern
  725.             else:
  726.                 pattern = _TemplateMetaclass.pattern % {
  727.                     'delim' : re.escape(cls.delimiter),
  728.                     'id'    : cls.idpattern,
  729.                     }
  730.             cls.pattern = re.compile(pattern, re.IGNORECASE | re.VERBOSE)
  731.  
  732.  
  733.     class Template:
  734.         """A string class for supporting $-substitutions."""
  735.         __metaclass__ = _TemplateMetaclass
  736.  
  737.         delimiter = '$'
  738.         idpattern = r'[_a-z][_a-z0-9]*'
  739.  
  740.         def __init__(self, template):
  741.             self.template = template
  742.  
  743.         # Search for $$, $identifier, ${identifier}, and any bare $'s
  744.         def _invalid(self, mo):
  745.             i = mo.start('invalid')
  746.             lines = self.template[:i].splitlines(True)
  747.             if not lines:
  748.                 colno = 1
  749.                 lineno = 1
  750.             else:
  751.                 colno = i - len(''.join(lines[:-1]))
  752.                 lineno = len(lines)
  753.             raise ValueError('Invalid placeholder in string: line %d, col %d' %
  754.                              (lineno, colno))
  755.  
  756.         def substitute(self, *args, **kws):
  757.             if len(args) > 1:
  758.                 raise TypeError('Too many positional arguments')
  759.             if not args:
  760.                 mapping = kws
  761.             elif kws:
  762.                 mapping = _multimap(kws, args[0])
  763.             else:
  764.                 mapping = args[0]
  765.             # Helper function for .sub()
  766.             def convert(mo):
  767.                 # Check the most common path first.
  768.                 named = mo.group('named') or mo.group('braced')
  769.                 if named is not None:
  770.                     val = mapping[named]
  771.                     # We use this idiom instead of str() because the latter will
  772.                     # fail if val is a Unicode containing non-ASCII characters.
  773.                     return '%s' % val
  774.                 if mo.group('escaped') is not None:
  775.                     return self.delimiter
  776.                 if mo.group('invalid') is not None:
  777.                     self._invalid(mo)
  778.                 raise ValueError('Unrecognized named group in pattern',
  779.                                  self.pattern)
  780.             return self.pattern.sub(convert, self.template)
  781.  
  782.         def safe_substitute(self, *args, **kws):
  783.             if len(args) > 1:
  784.                 raise TypeError('Too many positional arguments')
  785.             if not args:
  786.                 mapping = kws
  787.             elif kws:
  788.                 mapping = _multimap(kws, args[0])
  789.             else:
  790.                 mapping = args[0]
  791.             # Helper function for .sub()
  792.             def convert(mo):
  793.                 named = mo.group('named')
  794.                 if named is not None:
  795.                     try:
  796.                         # We use this idiom instead of str() because the latter
  797.                         # will fail if val is a Unicode containing non-ASCII
  798.                         return '%s' % mapping[named]
  799.                     except KeyError:
  800.                         return self.delimiter + named
  801.                 braced = mo.group('braced')
  802.                 if braced is not None:
  803.                     try:
  804.                         return '%s' % mapping[braced]
  805.                     except KeyError:
  806.                         return self.delimiter + '{' + braced + '}'
  807.                 if mo.group('escaped') is not None:
  808.                     return self.delimiter
  809.                 if mo.group('invalid') is not None:
  810.                     return self.delimiter
  811.                 raise ValueError('Unrecognized named group in pattern',
  812.                                  self.pattern)
  813.             return self.pattern.sub(convert, self.template)
  814.  
  815.  
  816.  
  817. #cat = lambda _ : Template(_).substitute(sys._getframe(1).f_globals, **sys._getframe(1).f_locals)
  818.  
  819. def cat(s):
  820.     globals = sys._getframe(1).f_globals.copy()
  821.     if 'self' in globals:
  822.         del globals['self']
  823.     
  824.     locals = sys._getframe(1).f_locals.copy()
  825.     if 'self' in locals:
  826.         del locals['self']
  827.         
  828.     return Template(s).substitute(sys._getframe(1).f_globals, **locals)
  829.     
  830. identity = string.maketrans('','')
  831. unprintable = identity.translate(identity, string.printable)
  832.  
  833. def printable(s):
  834.     return s.translate(identity, unprintable)
  835.  
  836.  
  837. def any(S,f=lambda x:x):
  838.     for x in S:
  839.         if f(x): return True
  840.     return False
  841.  
  842. def all(S,f=lambda x:x):
  843.     for x in S:
  844.         if not f(x): return False
  845.     return True
  846.  
  847. BROWSERS = ['firefox', 'mozilla', 'konqueror', 'galeon', 'skipstone'] # in preferred order
  848. BROWSER_OPTS = {'firefox': '-new-window', 'mozilla' : '', 'konqueror': '', 'galeon': '-w', 'skipstone': ''}
  849.  
  850. def find_browser():
  851.     if platform_avail and platform.system() == 'Darwin':
  852.         return "open"
  853.     else:
  854.         for b in BROWSERS:
  855.             if which(b):
  856.                 return b
  857.         else:
  858.             return None
  859.     
  860. def openURL(url):
  861.     if platform_avail and platform.system() == 'Darwin':
  862.         cmd = 'open "%s"' % url
  863.         log.debug(cmd)
  864.         os.system(cmd)
  865.     else:
  866.         for b in BROWSERS:
  867.             bb = which(b)
  868.             if bb:
  869.                 bb = os.path.join(bb, b)
  870.                 cmd = """%s %s "%s" &""" % (bb, BROWSER_OPTS[b], url)
  871.                 log.debug(cmd)
  872.                 os.system(cmd)
  873.                 break
  874.         else:
  875.             log.warn("Unable to open URL: %s" % url)
  876.  
  877.  
  878. def uniqueList(input):
  879.     temp = []
  880.     [temp.append(i) for i in input if not temp.count(i)]
  881.     return temp
  882.  
  883.  
  884. def list_move_up(l, m):
  885.     for i in range(1, len(l)):
  886.         if l[i] == m:
  887.             l[i-1], l[i] = l[i], l[i-1]
  888.  
  889.  
  890. def list_move_down(l, m):
  891.     for i in range(len(l)-2, -1, -1):
  892.         if l[i] == m:
  893.             l[i], l[i+1] = l[i+1], l[i] 
  894.  
  895.  
  896.  
  897. class XMLToDictParser:
  898.     def __init__(self):
  899.         self.stack = []
  900.         self.data = {}
  901.         self.last_start = ''
  902.  
  903.     def startElement(self, name, attrs):
  904.         #print "START:", name, attrs
  905.         self.stack.append(str(name).lower())
  906.         self.last_start = str(name).lower()
  907.  
  908.         if len(attrs):
  909.             for a in attrs:
  910.                 self.stack.append(str(a).lower())
  911.                 self.addData(attrs[a])
  912.                 self.stack.pop()
  913.  
  914.     def endElement(self, name):
  915.         if name.lower() == self.last_start:
  916.             self.addData('')
  917.         
  918.         #print "END:", name
  919.         self.stack.pop()
  920.  
  921.     def charData(self, data):
  922.         data = str(data).strip()
  923.  
  924.         if data and self.stack:
  925.             self.addData(data)
  926.  
  927.     def addData(self, data):
  928.         #print "DATA:", data
  929.         self.last_start = ''
  930.         try:
  931.             data = int(data)
  932.         except ValueError:
  933.             data = str(data)
  934.  
  935.         stack_str = '-'.join(self.stack)
  936.         stack_str_0 = '-'.join([stack_str, '0'])
  937.  
  938.         try:
  939.             self.data[stack_str]
  940.         except KeyError:
  941.             try:
  942.                 self.data[stack_str_0]
  943.             except KeyError:
  944.                 self.data[stack_str] = data
  945.             else:
  946.                 j = 2
  947.                 while True:
  948.                     try:
  949.                         self.data['-'.join([stack_str, str(j)])]
  950.                     except KeyError:
  951.                         self.data['-'.join([stack_str, str(j)])] = data
  952.                         break
  953.                     j += 1                    
  954.  
  955.         else:
  956.             self.data[stack_str_0] = self.data[stack_str]
  957.             self.data['-'.join([stack_str, '1'])] = data
  958.             del self.data[stack_str]
  959.  
  960.  
  961.     def parseXML(self, text):
  962.         parser = expat.ParserCreate()
  963.         parser.StartElementHandler = self.startElement
  964.         parser.EndElementHandler = self.endElement
  965.         parser.CharacterDataHandler = self.charData
  966.         parser.Parse(text, True)
  967.         return self.data
  968.  
  969.  
  970.  # ------------------------- Usage Help
  971. USAGE_OPTIONS = ("[OPTIONS]", "", "heading", False)
  972. USAGE_LOGGING1 = ("Set the logging level:", "-l<level> or --logging=<level>", 'option', False)
  973. USAGE_LOGGING2 = ("", "<level>: none, info\*, error, warn, debug (\*default)", "option", False)
  974. USAGE_LOGGING3 = ("Run in debug mode:", "-g (same as option: -ldebug)", "option", False)
  975. USAGE_LOGGING_PLAIN = ("Output plain text only:", "-t", "option", False)
  976. USAGE_ARGS = ("[PRINTER|DEVICE-URI] (See Notes)", "", "heading", False)
  977. USAGE_DEVICE = ("To specify a device-URI:", "-d<device-uri> or --device=<device-uri>", "option", False)
  978. USAGE_PRINTER = ("To specify a CUPS printer:", "-p<printer> or --printer=<printer>", "option", False)
  979. USAGE_BUS1 = ("Bus to probe (if device not specified):", "-b<bus> or --bus=<bus>", "option", False)
  980. USAGE_BUS2 = ("", "<bus>: cups\*, usb\*, net, bt, fw, par\* (\*defaults) (Note: bt and fw not supported in this release.)", 'option', False)
  981. USAGE_HELP = ("This help information:", "-h or --help", "option", True)
  982. USAGE_SPACE = ("", "", "space", False)
  983. USAGE_EXAMPLES = ("Examples:", "", "heading", False)
  984. USAGE_NOTES = ("Notes:", "", "heading", False)
  985. USAGE_STD_NOTES1 = ("1. If device or printer is not specified, the local device bus is probed and the program enters interactive mode.", "", "note", False)
  986. USAGE_STD_NOTES2 = ("2. If -p\* is specified, the default CUPS printer will be used.", "", "note", False)
  987. USAGE_SEEALSO = ("See Also:", "", "heading", False)
  988. USAGE_LANGUAGE = ("Set the language:", "-q <lang> or --lang=<lang>. Use -q? or --lang=? to see a list of available language codes.", "option", False)
  989. USAGE_LANGUAGE2 = ("Set the language:", "--lang=<lang>. Use --lang=? to see a list of available language codes.", "option", False)
  990.  
  991. def ttysize():
  992.     ln1 = commands.getoutput('stty -a').splitlines()[0]
  993.     vals = {'rows':None, 'columns':None}
  994.     for ph in ln1.split(';'):
  995.         x = ph.split()
  996.         if len(x) == 2:
  997.             vals[x[0]] = x[1]
  998.             vals[x[1]] = x[0]
  999.     try:
  1000.         rows, cols = int(vals['rows']), int(vals['columns'])
  1001.     except TypeError:
  1002.         rows, cols = 25, 80
  1003.  
  1004.     return rows, cols
  1005.  
  1006.  
  1007. def usage_formatter(override=0):
  1008.     rows, cols = ttysize()
  1009.  
  1010.     if override:
  1011.         col1 = override
  1012.         col2 = cols - col1 - 8
  1013.     else:
  1014.         col1 = int(cols / 3) - 8
  1015.         col2 = cols - col1 - 8
  1016.  
  1017.     return TextFormatter(({'width': col1, 'margin' : 2},
  1018.                             {'width': col2, 'margin' : 2},))
  1019.  
  1020.  
  1021. def format_text(text_list, typ='text', title='', crumb='', version=''):
  1022.     """
  1023.     Format usage text in multiple formats:
  1024.         text: for --help in the console
  1025.         rest: for conversion with rst2web for the website
  1026.         man: for manpages
  1027.     """
  1028.     if typ == 'text':
  1029.         formatter = usage_formatter()
  1030.  
  1031.         for line in text_list:
  1032.             text1, text2, format, trailing_space = line
  1033.  
  1034.             # remove any reST/man escapes
  1035.             text1 = text1.replace("\\", "")
  1036.             text2 = text2.replace("\\", "")
  1037.  
  1038.             if format == 'summary':
  1039.                 log.info(log.bold(text1))
  1040.                 log.info("")
  1041.  
  1042.             elif format in ('para', 'name', 'seealso'):
  1043.                 log.info(text1)
  1044.  
  1045.                 if trailing_space:
  1046.                     log.info("")
  1047.  
  1048.             elif format in ('heading', 'header'):
  1049.                 log.info(log.bold(text1))
  1050.  
  1051.             elif format in ('option', 'example'):
  1052.                 log.info(formatter.compose((text1, text2), trailing_space))
  1053.  
  1054.             elif format == 'note':
  1055.                 if text1.startswith(' '):
  1056.                     log.info('\t' + text1.lstrip())
  1057.                 else:
  1058.                     log.info(text1)
  1059.  
  1060.             elif format == 'space':
  1061.                 log.info("")
  1062.  
  1063.         log.info("")
  1064.  
  1065.  
  1066.     elif typ == 'rest':
  1067.         colwidth1, colwidth2 = 0, 0
  1068.         for line in text_list:
  1069.             text1, text2, format, trailing_space = line
  1070.  
  1071.             if format in ('option', 'example', 'note'):
  1072.                 colwidth1 = max(len(text1), colwidth1)
  1073.                 colwidth2 = max(len(text2), colwidth2)
  1074.  
  1075.         colwidth1 += 3
  1076.         tablewidth = colwidth1 + colwidth2
  1077.  
  1078.         # write the rst2web header
  1079.         log.info("""restindex
  1080. page-title: %s
  1081. crumb: %s
  1082. format: rest
  1083. file-extension: html
  1084. encoding: utf8
  1085. /restindex\n""" % (title, crumb))
  1086.  
  1087.         log.info("%s: %s (ver. %s)" % (crumb, title, version))
  1088.         log.info("="*80)
  1089.         log.info("")
  1090.  
  1091.         links = []
  1092.  
  1093.         for line in text_list:
  1094.             text1, text2, format, trailing_space = line
  1095.  
  1096.             if format == 'seealso':
  1097.                 links.append(text1)
  1098.                 text1 = "`%s`_" % text1
  1099.  
  1100.             len1, len2 = len(text1), len(text2)
  1101.  
  1102.             if format == 'summary':
  1103.                 log.info(''.join(["**", text1, "**"]))
  1104.                 log.info("")
  1105.  
  1106.             elif format in ('para', 'name'):
  1107.                 log.info("")
  1108.                 log.info(text1)
  1109.                 log.info("")
  1110.  
  1111.             elif format in ('heading', 'header'):
  1112.  
  1113.                 log.info("")
  1114.                 log.info("**" + text1 + "**")
  1115.                 log.info("")
  1116.                 log.info(".. class:: borderless")
  1117.                 log.info("")
  1118.                 log.info(''.join(["+", "-"*colwidth1, "+", "-"*colwidth2, "+"]))
  1119.  
  1120.             elif format in ('option', 'example', 'seealso'):
  1121.  
  1122.                 if text1 and '`_' not in text1:
  1123.                     log.info(''.join(["| *", text1, '*', " "*(colwidth1-len1-3), "|", text2, " "*(colwidth2-len2), "|"]))
  1124.                 elif text1:
  1125.                     log.info(''.join(["|", text1, " "*(colwidth1-len1), "|", text2, " "*(colwidth2-len2), "|"]))
  1126.                 else:
  1127.                     log.info(''.join(["|", " "*(colwidth1), "|", text2, " "*(colwidth2-len2), "|"]))
  1128.  
  1129.                 log.info(''.join(["+", "-"*colwidth1, "+", "-"*colwidth2, "+"]))
  1130.  
  1131.             elif format == 'note':
  1132.                 if text1.startswith(' '):
  1133.                     log.info(''.join(["|", " "*(tablewidth+1), "|"]))
  1134.  
  1135.                 log.info(''.join(["|", text1, " "*(tablewidth-len1+1), "|"]))
  1136.                 log.info(''.join(["+", "-"*colwidth1, "+", "-"*colwidth2, "+"]))
  1137.  
  1138.             elif format == 'space':
  1139.                 log.info("")
  1140.  
  1141.         for l in links:
  1142.             log.info("\n.. _`%s`: %s.html\n" % (l, l.replace('hp-', '')))
  1143.  
  1144.         log.info("")
  1145.  
  1146.     elif typ == 'man':
  1147.         log.info('.TH "%s" 1 "%s" Linux "User Manuals"' % (title, version))
  1148.  
  1149.         for line in text_list:
  1150.             text1, text2, format, trailing_space = line
  1151.  
  1152.             text1 = text1.replace("\\*", "*")
  1153.             text2 = text2.replace("\\*", "*")            
  1154.  
  1155.             len1, len2 = len(text1), len(text2)
  1156.  
  1157.             if format == 'summary':
  1158.                 log.info(".SH SYNOPSIS")
  1159.                 log.info(".B %s" % text1)
  1160.  
  1161.             elif format == 'name':
  1162.                 log.info(".SH NAME\n%s" % text1)
  1163.  
  1164.             elif format in ('option', 'example', 'note'):
  1165.                 if text1:
  1166.                     log.info('.IP "%s"\n%s' % (text1, text2))
  1167.                 else:
  1168.                     log.info(text2)
  1169.  
  1170.             elif format in ('header', 'heading'):
  1171.                 log.info(".SH %s" % text1.upper().replace(':', '').replace('[', '').replace(']', ''))
  1172.  
  1173.             elif format in ('seealso, para'):
  1174.                 log.info(text1)
  1175.  
  1176.         log.info("")
  1177.  
  1178.  
  1179. def dquote(s):
  1180.     return ''.join(['"', s, '"'])
  1181.  
  1182. # Python 2.2 compatibility functions (strip() family with char argument)
  1183. def xlstrip(s, chars=' '):
  1184.     i = 0
  1185.     for c, i in zip(s, range(len(s))):
  1186.         if c not in chars:
  1187.             break
  1188.  
  1189.     return s[i:]
  1190.  
  1191. def xrstrip(s, chars=' '):
  1192.     return xreverse(xlstrip(xreverse(s), chars))
  1193.  
  1194. def xreverse(s):
  1195.     l = list(s)
  1196.     l.reverse()
  1197.     return ''.join(l)
  1198.  
  1199. def xstrip(s, chars=' '):
  1200.     return xreverse(xlstrip(xreverse(xlstrip(s, chars)), chars))
  1201.  
  1202. def getBitness():
  1203.     if platform_avail:
  1204.         return int(platform.architecture()[0][:-3])
  1205.     else:
  1206.         return struct.calcsize("P") << 3
  1207.  
  1208. def getProcessor():
  1209.     if platform_avail:
  1210.         return platform.machine().replace(' ', '_').lower() # i386, i686, power_macintosh, etc.
  1211.     else:
  1212.         return "i686" # TODO: Need a fix here
  1213.     
  1214.  
  1215. BIG_ENDIAN = 0
  1216. LITTLE_ENDIAN = 1
  1217.  
  1218. def getEndian():
  1219.     if struct.pack("@I", 0x01020304)[0] == '\x01':
  1220.         return BIG_ENDIAN
  1221.     else:
  1222.         return LITTLE_ENDIAN
  1223.  
  1224.  
  1225. def get_password():
  1226.     return getpass.getpass("Enter password: ")
  1227.     
  1228.  
  1229. def run(cmd, log_output=True, password_func=get_password, timeout=1):
  1230.     output = cStringIO.StringIO()
  1231.  
  1232.     try:
  1233.         child = pexpect.spawn(cmd, timeout=timeout)
  1234.     except pexpect.ExceptionPexpect:
  1235.         return -1, ''
  1236.  
  1237.     try:
  1238.         while True:
  1239.             update_spinner()
  1240.             i = child.expect(["[pP]assword:", pexpect.EOF, pexpect.TIMEOUT])
  1241.  
  1242.             if child.before:
  1243.                 log.debug(child.before)
  1244.                 output.write(child.before)
  1245.  
  1246.             if i == 0: # Password:
  1247.                 if password_func is not None:
  1248.                     child.sendline(password_func())
  1249.                 else:
  1250.                     child.sendline(get_password())
  1251.  
  1252.             elif i == 1: # EOF
  1253.                 break
  1254.  
  1255.             elif i == 2: # TIMEOUT
  1256.                 continue
  1257.  
  1258.  
  1259.     except Exception, e:
  1260.         log.error("Exception: %s" % e)
  1261.  
  1262.     cleanup_spinner()
  1263.     child.close()
  1264.  
  1265.     return child.exitstatus, output.getvalue()
  1266.  
  1267.  
  1268. def expand_range(ns): # ns -> string repr. of numeric range, e.g. "1-4, 7, 9-12"
  1269.     """Credit: Jean Brouwers, comp.lang.python 16-7-2004
  1270.        Convert a string representation of a set of ranges into a 
  1271.        list of ints, e.g.
  1272.        "1-4, 7, 9-12" --> [1,2,3,4,7,9,10,11,12]
  1273.     """
  1274.     fs = []
  1275.     for n in ns.split(','):
  1276.         n = n.strip()
  1277.         r = n.split('-')
  1278.         if len(r) == 2:  # expand name with range
  1279.             h = r[0].rstrip('0123456789')  # header
  1280.             r[0] = r[0][len(h):]
  1281.              # range can't be empty
  1282.             if not (r[0] and r[1]):
  1283.                 raise ValueError, 'empty range: ' + n
  1284.              # handle leading zeros
  1285.             if r[0] == '0' or r[0][0] != '0':
  1286.                 h += '%d'
  1287.             else:
  1288.                 w = [len(i) for i in r]
  1289.                 if w[1] > w[0]:
  1290.                    raise ValueError, 'wide range: ' + n
  1291.                 h += '%%0%dd' % max(w)
  1292.              # check range
  1293.             r = [int(i, 10) for i in r]
  1294.             if r[0] > r[1]:
  1295.                raise ValueError, 'bad range: ' + n
  1296.             for i in range(r[0], r[1]+1):
  1297.                 fs.append(h % i)
  1298.         else:  # simple name
  1299.             fs.append(n)
  1300.  
  1301.      # remove duplicates
  1302.     fs = dict([(n, i) for i, n in enumerate(fs)]).keys()
  1303.      # convert to ints and sort
  1304.     fs = [int(x) for x in fs if x]
  1305.     fs.sort()
  1306.  
  1307.     return fs
  1308.  
  1309.  
  1310. def collapse_range(x): # x --> sorted list of ints
  1311.     """ Convert a list of integers into a string
  1312.         range representation: 
  1313.         [1,2,3,4,7,9,10,11,12] --> "1-4,7,9-12"
  1314.     """
  1315.     if not x:
  1316.         return ''
  1317.  
  1318.     s, c, r = [str(x[0])], x[0], False
  1319.  
  1320.     for i in x[1:]:
  1321.         if i == (c+1):
  1322.             r = True
  1323.         else:
  1324.             if r:
  1325.                 s.append('-%s,%s' % (c,i))
  1326.                 r = False
  1327.             else:
  1328.                 s.append(',%s' % i)
  1329.  
  1330.         c = i
  1331.  
  1332.     if r:
  1333.         s.append('-%s' % i)
  1334.  
  1335.     return ''.join(s)
  1336.  
  1337. def createSequencedFilename(basename, ext, dir=None, digits=3):
  1338.     if dir is None:
  1339.         dir = os.getcwd()
  1340.  
  1341.     m = 0
  1342.     for f in walkFiles(dir, recurse=False, abs_paths=False, return_folders=False, pattern='*', path=None):
  1343.         r, e = os.path.splitext(f)
  1344.  
  1345.         if r.startswith(basename) and ext == e:
  1346.             try:
  1347.                 i = int(r[len(basename):])
  1348.             except ValueError:
  1349.                 continue
  1350.             else:
  1351.                 m = max(m, i)
  1352.  
  1353.     return os.path.join(dir, "%s%0*d%s" % (basename, digits, m+1, ext))
  1354.  
  1355.  
  1356. def validate_language(lang, default='en_US'):
  1357.     if lang is None:
  1358.         loc, encoder = locale.getdefaultlocale()
  1359.     else:
  1360.         lang = lang.lower().strip()
  1361.         for loc, ll in supported_locales.items():
  1362.             if lang in ll:
  1363.                 break
  1364.         else:
  1365.             loc = user_cfg.ui.get("loc", "en_US")
  1366.             log.warn("Unknown lang/locale. Using default of %s." % loc)
  1367.  
  1368.     return loc
  1369.  
  1370.    
  1371. def gen_random_uuid():
  1372.     try:
  1373.         import uuid # requires Python 2.5+
  1374.         return str(uuid.uuid4())
  1375.         
  1376.     except ImportError:
  1377.         uuidgen = which("uuidgen")
  1378.         if uuidgen:
  1379.             uuidgen = os.path.join(uuidgen, "uuidgen")
  1380.             return commands.getoutput(uuidgen) # TODO: Replace with subprocess (commands is deprecated in Python 3.0)
  1381.         else:
  1382.             return ''
  1383.             
  1384.             
  1385. class RestTableFormatter(object):
  1386.     def __init__(self, header=None):
  1387.         self.header = header # tuple of strings
  1388.         self.rows = [] # list of tuples
  1389.  
  1390.     def add(self, row_data): # tuple of strings
  1391.         self.rows.append(row_data)
  1392.  
  1393.     def output(self, w):
  1394.         if self.rows:
  1395.             num_cols = len(self.rows[0])
  1396.             for r in self.rows:
  1397.                 if len(r) != num_cols:
  1398.                     log.error("Invalid number of items in row: %s" % r)
  1399.                     return
  1400.  
  1401.             if len(self.header) != num_cols:
  1402.                 log.error("Invalid number of items in header.")
  1403.  
  1404.             col_widths = []
  1405.             for x, c in enumerate(self.header):
  1406.                 max_width = len(c)
  1407.                 for r in self.rows:
  1408.                     max_width = max(max_width, len(r[x]))
  1409.  
  1410.                 col_widths.append(max_width+2)
  1411.  
  1412.             x = '+'
  1413.             for c in col_widths:
  1414.                 x = ''.join([x, '-' * (c+2), '+'])
  1415.  
  1416.             x = ''.join([x, '\n'])
  1417.             w.write(x)
  1418.  
  1419.             # header
  1420.             if self.header:
  1421.                 x = '|'
  1422.                 for i, c in enumerate(col_widths):
  1423.                     x = ''.join([x, ' ', self.header[i], ' ' * (c+1-len(self.header[i])), '|'])
  1424.  
  1425.                 x = ''.join([x, '\n'])
  1426.                 w.write(x)
  1427.  
  1428.                 x = '+'
  1429.                 for c in col_widths:
  1430.                     x = ''.join([x, '=' * (c+2), '+'])
  1431.  
  1432.                 x = ''.join([x, '\n'])
  1433.                 w.write(x)
  1434.  
  1435.             # data rows
  1436.             for j, r in enumerate(self.rows):
  1437.                 x = '|'
  1438.                 for i, c in enumerate(col_widths):
  1439.                     x = ''.join([x, ' ', self.rows[j][i], ' ' * (c+1-len(self.rows[j][i])), '|'])
  1440.  
  1441.                 x = ''.join([x, '\n'])
  1442.                 w.write(x)
  1443.  
  1444.                 x = '+'
  1445.                 for c in col_widths:
  1446.                     x = ''.join([x, '-' * (c+2), '+'])
  1447.  
  1448.                 x = ''.join([x, '\n'])
  1449.                 w.write(x)
  1450.  
  1451.         else:
  1452.             log.error("No data rows")
  1453.  
  1454.  
  1455. def mixin(cls):
  1456.     import inspect
  1457.     
  1458.     locals = inspect.stack()[1][0].f_locals
  1459.     if "__module__" not in locals:
  1460.         raise TypeError("Must call mixin() from within class def.")
  1461.         
  1462.     dict = cls.__dict__.copy()
  1463.     dict.pop("__doc__", None)
  1464.     dict.pop("__module__", None)
  1465.     
  1466.     locals.update(dict)
  1467.     
  1468.     
  1469.