contiki/tools/chakana/utils.py

#  Copyright (C) 2003-2007 Swedish Institute of Computer Science.
#  
# Please refer to the file named LICENSE in the same directory as this
# file for licensing information.
#  


# $Id: utils.py,v 1.1 2007/08/21 14:41:01 fros4943 Exp $

import errno
import math
import operator
import os
import popen2
import re
import string
import shutil
import sys
import tempfile
import threading
import traceback
import types

import chakana.command
import chakana.error
from chakana.debug import *

try:
  global False
  global True
  _ = False
except NameError:
  False = 0
  True = 1

class DefaultDict(dict):
  def __init__(self, defaultCreator, initialiser = (), inject = 0):
    dict.__init__(self, initialiser)
    if callable(defaultCreator):
      self._defaultCreator = defaultCreator
    else:
      self._defaultCreator = lambda k: defaultCreator
    self._inject = inject

  def __getitem__(self, key):
    try:
      return dict.__getitem__(self, key)
    except KeyError, err:
      value = self._defaultCreator(key) 
      if self._inject:
        self[key] = value
        return self[key]
      else:
        return value
        
class UnbufferedFile:
  def __init__(self, fileObj):
    self._fileObj = fileObj

  def __getattr__(self, attribute):
    return getattr(self._fileObj, attribute)

  def write(self, what):
    self._fileObj.write(what)
    self._fileObj.flush()

def copyFile(src, dest):
  debug(Event, "cp " + src + " " + dest)
  srcFile = file(src)
  destFile = file(dest, "w")
  destFile.write(srcFile.read())
  srcFile.close()
  destFile.close()

def unique(list):
  ret = []
  inList = {}
  for elem in list:
    if not elem in inList:
      ret.append(elem)
      inList[elem] = 1
  return ret

def unorderedEqual(listOne, listTwo, predicate = lambda x, y: x == y):
  if len(listOne) != len(listTwo):
    return 0
  list1 = list(listOne)
  list2 = list(listTwo)
  while list1 != []:
    found = 0
    for index in range(len(list2)):
      if predicate(list1[0], list2[index]):
        del list1[0]
        del list2[index]
        found = 1
        break
    if not found:
      return 0
  return 1

def reduceSequences(tupleSeq, oper = operator.add):
  """Return a list, where the item at position i is the reduced value
  of all items at position i."""

  if len(tupleSeq) == 0:
    return []
  return [reduce(oper, [s[i] for s in tupleSeq])
          for i in range(len(tupleSeq[0]))]

def listRemove(theList, predicate):
  """Remove all items that match predicate in theList."""
  if not callable(predicate):
    return listRemove(theList, lambda x: x == predicate)
  else:
    index = 0
    while index < len(theList):
      if predicate(theList[index]):
        del theList[index]
      else:
        index += 1
  return theList

def logn(n, x):
  return math.log(x) / math.log(n)

def longRange(* args):
  """As range, but works with long integers."""
  if len(args) == 1:
    start = 0L
    stop = args[0]
    step = 1L
  elif len(args) == 2:
    (start, stop) = args
    step = 1L
  else:
    (start, stop, step) = args
  if step == 0:
    raise ValueError("longRange() arg 3 must not be zero")
  ret = []
  while cmp(start, stop) == cmp(0, step):
    ret.append(start)
    start += step
  return ret

integerSuffixes = ("", "K", "M", "G", "T")

def abbreviateInteger(i, factor = 1024, minimise = 0):
  suf = 0
  while suf < len(integerSuffixes) - 1 and \
        ((i > 9999) or (minimise and (i != 0) and (i % factor == 0))):
    suf += 1
    i /= factor
  return str(i) + integerSuffixes[suf]

def readSuffixedInt(intString, factor = 1024):
  if intString[-1].isalpha():
    return int(intString[: -1]) * (
      factor ** list(integerSuffixes).index(intString[-1].upper()))
  else:
    return int(intString)

def normaliseIndex(index, seq):
  """Return a non-negative index relating to a sequence, or negative if
  index < - len(seq)."""
  
  if index < 0:
    return len(seq) + index
  else:
    return index

def truncateIndex(index, seq):
  """Return a non-negative index relating to a sequence, less than or equal
  to the length of the sequence."""
  ret = normaliseIndex(index, seq)
  if ret < 0:
    return 0
  length = len(seq)
  if ret > length:
    return length
  return ret

class LazySlice:
  """Representation of slice into other sequence."""
  def __init__(self, seq, start = None, stop = None, step = None):
    self._sequence = seq
    if step is None:
      self._step = 1
    else:
      self._step = step
    if self._step == 0:
      # Provoke ValueError
      [][0:1:0]

    if self._step > 0:
      startDefault = 0
      stopDefault = len(seq)
      indexShift = 0
    else:
      startDefault = len(seq) - 1
      stopDefault = -1
      indexShift = 1
      
    if start is None:
      self._start = startDefault
    else:
      self._start = truncateIndex(start + indexShift, seq) - indexShift
    if stop is None:
      self._stop = stopDefault
    else:
      self._stop = truncateIndex(stop + indexShift, seq) - indexShift

    if (self._step > 0) != (self._start < self._stop):
      self._stop = self._start

  def __getitem__(self, key):
    # debug(Debug2, "LS getitem " + str(key) + ": " + repr(self))
    if type(key) == types.SliceType:
      ret = LazySlice(self, key.start, key.stop, key.step)
      #debug(Debug2, "LS getitem " + str(key) + " = " +
      #      repr(ret) + ", LS: " + repr(self))
      return ret
    index = normaliseIndex(key, self)
    if index < 0:
      # Provoke IndexError
      [][1]
    seqIndex = self._start + index * self._step
    if self._step > 0:
      if seqIndex >= self._stop:
        [][1]
    elif seqIndex <= self._stop:
      [][1]
    ret = self._sequence[seqIndex]
    #debug(Debug2, "LS getitem " + str(key) + " (" + str(seqIndex) + ") = " +
    #      str(ret) + ", LS: " + repr(self))
    return ret          

  def __len__(self):
    return (abs(self._stop - self._start) + abs(self._step) - 1) / \
           abs(self._step)

  def __str__(self):
    return str(list(self))

  def __repr__(self):
    return "LazySlice(start = " + str(self._start) + ", stop = " + \
           str(self._stop) + ", step = " + str(self._step) + ",\n  " + \
           repr(self._sequence) + ")"

def getItem(sequence, key):
  """Obtain key in sequence.  Key may be an integer or a slice object."""
  if type(key) == types.SliceType:
    if key.step is None:
      return sequence[key.start : key.stop]
    return sequence[key.start : key.stop : key.step]
  return sequence[key]

def binarySearch(list, value, start = 0, end = None):
  "Return the position where value should be inserted in a sorted list."
  if end is None:
    end = len(list)
  if start == end:
    return end
  middle = start + (end - start) / 2
  if list[middle] < value:
    return binarySearch(list, value, middle + 1, end)
  else:
    return binarySearch(list, value, start, middle)

def binaryFind(list, value, *args, ** kwArgs):
  "Return position of value in sorted list, or None if not found."
  position = binarySearch(list, value, *args, ** kwArgs)
  if (position == len(list)) or (list[position] != value):
    return None
  else:
    return position
  
def compactIntListRepr(input, sort = 0):
  if sort:
    list = input[:]
    list.sort()
  else:
    list = input
    if __debug__:
      tmp = list[:]
      tmp.sort()
      assert(tmp == list)
  index = 0
  ret = "["
  sep = ""
  compact = lambda l, i: (i + 1 < len(l)) and (l[i] + 1 == l[i + 1])
  while index < len(list):
    ret += sep + str(list[index])
    if compact(list, index):
      ret += "-"
      while compact(list, index):
        index += 1
      ret += str(list[index])
    index += 1
    sep = ","
  return ret + "]"

def predicatedIndex(sequence, predicate):
  for i in range(len(sequence)):
    if predicate(sequence[i]):
      return i
  raise ValueError()

class ArgumentBinder:
  def __init__(self, function, argument, position = 0):
    self.__function = function
    self.__argument = argument
    self.__position = position

  def __call__(self, *args, **keywords):
    newArgs = list(args)
    newArgs[self.__position : self.__position] = [self.__argument]
    return self.__function(*newArgs, **keywords)

class ArgumentTupleBinder:
  def __init__(self, function, arguments):
    self._function = function
    self._arguments = arguments

  def __call__(self, * args, ** kwArgs):
    return self._function(* (self._arguments + args), ** kwArgs)

class KeywordArgumentBinder:
  def __init__(self, function, ** keywords):
    self._function = function
    self._keywords = keywords

  def __call__(self, * args, ** kwArgs):
    kw = self._keywords
    kw.update(kwArgs)
    return self._function(* args, ** kw)

cppKeywords = ["asm", "do", "inline", "short", "typeid", "auto",
               "double", "int", "signed", "typename", "bool",
               "dynamic_cast", "long", "sizeof", "union", "break",
               "else", "mutable", "static", "unsigned", "case",
               "enum", "namespace", "static_cast", "using", "catch",
               "explicit", "new", "struct", "virtual", "char",
               "extern", "operator", "switch", "void", "class",
               "false", "private", "template", "volatile", "const",
               "float", "protected", "this", "wchar_t", "const_cast",
               "for", "public", "throw", "while", "continue",
               "friend", "register", "true", "default", "goto",
               "reinterpret_cast", "try", "delete", "if", "return",
               "typedef"]

def isCWord(str):
  return not re.match("^[a-zA-Z_][a-zA-Z0-9_]*$", str) is None

def isCppIdentifier(str):
  return isCWord(str) and (str not in cppKeywords)

def find(seq, predicate = lambda x: x):
  for item in seq:
    if predicate(item):
      return item
  return None

def allBest(seq, comparator = cmp):
  if len(seq) < 2:
    return seq
  seq = seq[:]
  ret = [seq.pop()]
  for item in seq:
    c = comparator(item, ret[0])
    if c < 0:
      ret = [item]
    elif c == 0:
      ret.append(item)
  return ret

def readFile(fileName):
  f = open(fileName)
  try:
    ret = f.read()
    return ret
  finally:
    f.close()

def writeFile(fileName, contents):
  f = open(fileName, "w")
  try:
    f.write(contents)
  finally:
    f.close()

def writeFileAtomic(fileName, contents, suffix = ".tmp"):
  tmpFile = fileName + suffix
  writeFile(tmpFile, contents)
  try:
    os.rename(tmpFile, fileName)
  except:
    if os.path.exists(fileName) and os.path.exists(tmpFile):
      os.remove(tmpFile)
    raise


class LineIndexed:
  """Read-only file object indexed by line number.  The file object must
  support seeking."""
  
  def __init__(self, fileName, offset = 0):
    if type(fileName) == type(""):
      self._file = file(fileName)
    else:
      self._file = fileName      
    self._offset = offset
    self._length = None
    self._lineOffsets = [0]

  def close(self):
    self._file.close()

  def __del__(self):
    self.close()

  def _seekForward(self, index):
    if self._length == 0:
      raise IndexError()
    for index in range(len(self._lineOffsets), index + 1):
      if self._lineOffsets[-1] == self._length:
        raise IndexError()
      self._file.seek(self._lineOffsets[-1] + self._offset)
      line = self._file.readline()
      if line == "":
        self._length = self._lineOffsets[-1]
      else:
        self._lineOffsets.append(self._lineOffsets[-1] + len(line))

  def __getitem__(self, key):
    if type(key) == types.SliceType:
      ret = LazySlice(self, key.start, key.stop, key.step)
      return ret
    if key < 0:
      positiveLength = len(self) + key
      if positiveLength < 0:
        raise IndexError()
      return self[positiveLength]
    self._seekForward(key)
    offset = self._lineOffsets[key]
    if offset == self._length:
      raise IndexError()
    self._file.seek(offset + self._offset)
    return self._file.readline()

  def __len__(self):
    if self._length == 0:
      return 0
    while self._lineOffsets[-1] != self._length:
      self._seekForward(len(self._lineOffsets))
    return len(self._lineOffsets) - 1

  def lineOffset(self, index):
    self._seekForward(index)
    return self._lineOffsets[index]

  def __str__(self):
    return str(list(self))

  def __repr__(self):
    return "LineIndexed(offset = " + str(self._offset) + ", length = " + \
           str(self._length) + ", lineOffsets: " + \
           str(self._lineOffsets) + ")"

def getLine(fileName, count):
  fileObj = file(fileName)
  if count < 0:
    return fileObj.readlines()[count]
  for i in range(count + 1):
    ret = fileObj.readline()
    if ret == "":
      raise IndexError()
  return ret

def conditionalJoin(list, separator = " ", predicate = lambda e: e != ""):
  if len(list) == 0:
    return ""
  rest = conditionalJoin(list[1:], separator, predicate)
  if not predicate(rest):
    return list[0]
  if not predicate(list[0]):
    return rest
  else:
    return list[0] + separator + rest

def pathComponents(path):
  (head, tail) = os.path.split(path)
  if tail == "":
    if head == "":
      return []
    if head == "/":
      return ["/"]
    else:
      return pathComponents(head)
  else:
    return pathComponents(head) + [tail]

def commonFirstElements(listOfLists):
  if len(listOfLists) == 0:
    return []
  if len(listOfLists) == 1:
    return listOfLists[0]
  if (len(listOfLists[0]) == 0) or (len(listOfLists[1]) == 0) or \
     (listOfLists[0][0] != listOfLists[1][0]):
    return []
  else:
    return commonFirstElements([
      [listOfLists[0][0]] +
      commonFirstElements([listOfLists[0][1:], listOfLists[1][1:]])]
      + listOfLists[2:])

def commonPrefix(pathList):
  """Similar to os.path.commonprefix, but works on path components instead
  of individual characters."""

  assert(not isinstance(pathList, str))
  components = commonFirstElements(map(pathComponents, pathList))
  if components == []:
    return ""
  else:
    return os.path.join(* components)

def pathIsBelow(path, directory):
  """Check if path lies below directory."""
  return commonPrefix([path, directory]) == directory

def realPath(path):
  """Similar to os.path.realpath, but handles amd gracefully."""
  ret = os.path.realpath(path)
  for binDir in os.environ["PATH"].split(":") + ["/usr/sbin", "/sbin"]:
    amq = os.path.join(binDir, "amq")
    if os.path.isfile(amq):
      try:
        output = chakana.command.output(amq)
      except chakana.error.CommandFailed, err:
        debug(Debug, str(err))
        # Assume amd is not running
        return ret
      for line in output.splitlines():
        amdDir = line.split()[0]
        mountDir = line.split()[-1]
        if mountDir[0] == "/":
          match = re.match('^(' + re.escape(line) + ')(/$)', ret)
          if match:
            return amdDir + ret[len(line) :]
      return ret
  return ret
  
def removeTree(path, ignoreErrors = False):
  debug(Debug, "rm -rf " + path)
  if os.path.isdir(path):
    shutil.rmtree(path, ignore_errors = ignoreErrors)

def makeSymlink(value, dest, force = True, debugLevel = MinorEvent,
                dryRun = False):
  if os.path.islink(dest):
    if os.readlink(dest) == value:
      debug(Debug, "Link " + dest + " already points to " + value)
      return
    elif force:
      debug(debugLevel, "Removing " + dest)
      if not dryRun:
        os.remove(dest)
    else:
      raise OSError((errno.EEXIST, "Link already exists", dest))
  absValue = os.path.join(os.path.dirname(dest), value)
  if (not dryRun) and (not force) and (not os.path.isfile(absValue)):
    raise OSError((errno.ENOENT, "Link destination does not exist", absDest))
  debug(debugLevel, "Linking " + dest + " to " + value)
  if not dryRun:
    os.symlink(value, dest)

def copyTree(src, dst, symlinks = False, predicate = lambda path: 1,
             preserveTimes = False):
  """Similar to shutil.copytree, but allows existing destination and
  passes exceptions."""
  names = filter(predicate, os.listdir(src))
  if not os.path.isdir(dst):
    os.mkdir(dst)
  for name in names:
    srcname = os.path.join(src, name)
    dstname = os.path.join(dst, name)
    try:
      if symlinks and os.path.islink(srcname):
        linkto = os.readlink(srcname)
        os.symlink(linkto, dstname)
      elif os.path.isdir(srcname):
        copyTree(srcname, dstname, symlinks, predicate, preserveTimes)
      else:
        if preserveTimes:
          shutil.copy2(srcname, dstname)
        else:
          shutil.copy(srcname, dstname)
        # XXX What about devices, sockets etc.?
    except (IOError, os.error), why:
      debug(Error, "Can't copy %s to %s: %s" %
            (`srcname`, `dstname`, str(why)))
      raise

def makeDirsSafe(dir, mode = 0777):
  """Similar to os.makedirs, but does not fail if another process is making
  the directory simultaneously."""
  while not os.path.isdir(dir):
    try:
      os.makedirs(dir, mode)
    except OSError, err:
      if err.errno != errno.EEXIST:
        raise

def typeAssert(variable, type):
  assert(isinstance(variable, type))

def intervalsOverlap(range1, range2):
  if range1 > range2:
    return intervalsOverlap(range2, range1)
  if (range1[0] == range1[1]) or (range2[0] == range2[1]):
    return 0
  return range2[0] < range1[1]

class LexicalDistance:
  def __init__(self, caseChange = 1, whiteSpaceChange = 2,
               whiteSpaceRemoval = 3, ampersand = 5, other = 10,
               whiteSpace = " _-'\""):
    self.__caseChange = caseChange
    self.__whiteSpaceChange = whiteSpaceChange
    self.__whiteSpaceRemoval = whiteSpaceRemoval
    self.__ampersand = ampersand
    self.__other = other
    self.__whiteSpace = whiteSpace

  def removeWhiteSpace(self, str1, str2, limit):
    if str1[0] in self.__whiteSpace:
      if limit > self.__whiteSpaceRemoval:
        return self(str1[1:], str2, limit - self.__whiteSpaceRemoval) + \
               self.__whiteSpaceRemoval
    return limit

  def changeWhiteSpace(self, str1, str2, limit):
    if (str1[0] in self.__whiteSpace) and (str2[0] in self.__whiteSpace):
      if limit > self.__whiteSpaceChange:
        return self(str1[1:], str2[1:], limit - self.__whiteSpaceChange) + \
               self.__whiteSpaceChange
    return limit

  def changeCase(self, str1, str2, limit):
    if str1[0].upper() == str2[0].upper():
      if limit > self.__caseChange:
        return self(str1[1:], str2[1:], limit - self.__caseChange) + \
               self.__caseChange
    return limit

  def changeAmpersand(self, str1, str2, limit):
    if (str1[0] == "&") and (str2[:3].lower() == "and"):
      if limit > self.__ampersand:
        return self(str1[1:], str2[3:], limit - self.__ampersand) + \
               self.__ampersand
    return limit
  
  def removeOther(self, str1, str2, limit):
    if limit > self.__other:
      return self(str1[1:], str2, limit - self.__other) + self.__other
    return limit

  def changeOther(self, str1, str2, limit):
    if limit > self.__other:
      return self(str1[1:], str2[1:], limit - self.__other) + self.__other
    return limit
    
  def __call__(self, str1, str2, limit = 50):
    ret = limit
    if str1 == "":
      if str2 == "":
        return 0
      ret = self.removeWhiteSpace(str2, str1, ret)
      ret = self.removeOther(str2, str1, ret)
    elif str2 == "":
      ret = self(str2, str1, ret)
    else:
      if str1[0] == str2[0]:
        ret = self(str1[1:], str2[1:], ret)
      else:
        ret = self.removeWhiteSpace(str1, str2, ret)
        ret = self.removeWhiteSpace(str2, str1, ret)
        ret = self.changeWhiteSpace(str1, str2, ret)
        ret = self.changeCase(str1, str2, ret)
        ret = self.changeAmpersand(str1, str2, ret)
        ret = self.changeAmpersand(str2, str1, ret)
        ret = self.changeOther(str1, str2, ret)
        ret = self.removeOther(str1, str2, ret)
        ret = self.removeOther(str2, str1, ret)
    assert(ret <= limit)
    return ret
  
class TryOperation:
  def __init__(self, operation, description = None):
    self.__operation = operation
    if description is None:
      self.__description = str(operation)
    else:
      self.__description = description

  def __call__(self, * args, ** kwargs):
    try:
      self.__operation(* args, ** kwargs)
    except KeyboardInterrupt:
      raise
    except:
      import debug as d
      d.debug(d.Error, self.__description + " failed\n" +
              d.exceptionDump(sys.exc_info()))
  
def lineDirective():
  fileInfo = traceback.extract_stack(None, 2)[0]
  return "#line " + repr(fileInfo[1] + 1) + " \"" + fileInfo[0] + "\""

try:
  mkstemp = tempfile.mkstemp
except AttributeError:
  def mkstemp(suffix = "", prefix = None, dir = None, text = 0):
    if prefix is None:
      prefix = tempfile.gettempprefix()
    fileName = tempfile.mktemp(suffix)
    if dir is None:
      dir = os.path.dirname(fileName)
    newFileName = os.path.join(dir, prefix + os.path.basename(fileName))
    if text:
      flags = "w"
    else:
      flags = "wb"
    return (file(newFileName, flags), newFileName)