""" Abstract class to implement reporting on cache opening

def __init__(self):

pass

def update(self, percent):

pass

def done(self):

""" A simple text based cache open reporting class """

def __init__(self):

OpProgress.__init__(self)

def update(self, percent):

sys.stdout.write("\r%s: %.2i " % (self.subOp,percent))

sys.stdout.flush()

def done(self):

""" Report the download/fetching progress

# download status constants

dlDone = 0

dlQueued = 1

dlFailed = 2

dlHit = 3

dlIgnored = 4

dlStatusStr = {dlDone : "Done",

dlQueued : "Queued",

dlFailed : "Failed",

dlHit : "Hit",

dlIgnored : "Ignored"}

def __init__(self):

self.eta = 0.0

self.percent = 0.0

pass

def start(self):

pass

def stop(self):

pass

def updateStatus(self, uri, descr, shortDescr, status):

pass

def pulse(self):

""" called periodically (to update the gui), importend to

self.percent = ((self.currentBytes + self.currentItems)*100.0)/float(self.totalBytes+self.totalItems)

if self.currentCPS > 0:

self.eta = (self.totalBytes-self.currentBytes)/float(self.currentCPS)

return True

def mediaChange(self, medium, drive):

""" Ready to use progress object for terminal windows """

def __init__(self):

self.items = {}

def updateStatus(self, uri, descr, shortDescr, status):

if status != self.dlQueued:

print "\r%s %s" % (self.dlStatusStr[status], descr)

self.items[uri] = status

def pulse(self):

FetchProgress.pulse(self)

if self.currentCPS > 0:

s = "[%2.f%%] %sB/s %s" % (self.percent,

apt_pkg.SizeToStr(int(self.currentCPS)),

apt_pkg.TimeToStr(int(self.eta)))

else:

s = "%2.f%% [Working]" % (self.percent)

print "\r%s" % (s),

sys.stdout.flush()

return True

def stop(self):

print "\rDone downloading "

def mediaChange(self, medium, drive):

""" react to media change events """

res = True;

print "Media change: please insert the disc labeled \

'%s' in the drive '%s' and press enter" % (medium,drive)

s = sys.stdin.readline()

if(s == 'c' or s == 'C'):

res = false;

""" Report the install progress

def __init__(self):

pass

def startUpdate(self):

pass

def run(self, pm):

return pm.DoInstall()

def finishUpdate(self):

pass

def updateInterface(self):

""" A InstallProgress that is pretty useful.

def __init__(self):

DumbInstallProgress.__init__(self)

self.selectTimeout = 0.1

(read, write) = os.pipe()

self.writefd=write

self.statusfd = os.fdopen(read, "r")

fcntl.fcntl(self.statusfd.fileno(), fcntl.F_SETFL,os.O_NONBLOCK)

self.read = ""

self.percent = 0.0

self.status = ""

def error(self, pkg, errormsg):

" called when a error is detected during the install "

pass

def conffile(self,current,new):

" called when a conffile question from dpkg is detected "

pass

def statusChange(self, pkg, percent, status):

" called when the status changed "

pass

def updateInterface(self):

if self.statusfd != None:

try:

while not self.read.endswith("\n"):

self.read += os.read(self.statusfd.fileno(),1)

except OSError, (errno,errstr):

# resource temporarly unavailable is ignored

if errno != EAGAIN and errnor != EWOULDBLOCK:

print errstr

if self.read.endswith("\n"):

s = self.read

#print s

try:

(status, pkg, percent, status_str) = string.split(s, ":",3)

except ValueError, e:

# silently ignore lines that can't be parsed

self.read = ""

return

#print "percent: %s %s" % (pkg, float(percent)/100.0)

if status == "pmerror":

self.error(pkg,status_str)

elif status == "pmconffile":

# we get a string like this:

# 'current-conffile' 'new-conffile' useredited distedited

match = re.compile("\s*\'(.*)\'\s*\'(.*)\'.*").match(status_str)

if match:

self.conffile(match.group(1), match.group(2))

elif status == "pmstatus":

if float(percent) != self.percent or \

status_str != self.status:

self.statusChange(pkg, float(percent), status_str.strip())

self.percent = float(percent)

self.status = string.strip(status_str)

self.read = ""

def fork(self):

return os.fork()

def waitChild(self):

while True:

select.select([self.statusfd],[],[], self.selectTimeout)

self.updateInterface()

(pid, res) = os.waitpid(self.child_pid,os.WNOHANG)

if pid == self.child_pid:

break

return os.WEXITSTATUS(res)

def run(self, pm):

pid = self.fork()

if pid == 0:

# child

res = pm.DoInstall(self.writefd)

os._exit(res)

self.child_pid = pid

res = self.waitChild()

""" Report the cdrom add progress

def __init__(self):

pass

def update(self, text, step):

""" update is called regularly so that the gui can be redrawn """

pass

def askCdromName(self):

pass

def changeCdrom(self):