FM / pdist

/usr/lib64/python2.6/Demo/pdist

Name	Size	Mode	Actions
client.py	4708	0644	edit dl rm
client.pyc	6769	0644	edit dl rm
client.pyo	6769	0644	edit dl rm
cmdfw.py	4641	0644	edit dl rm
cmdfw.pyc	5276	0644	edit dl rm
cmdfw.pyo	5276	0644	edit dl rm
cmptree.py	5778	0644	edit dl rm
cmptree.pyc	6189	0644	edit dl rm
cmptree.pyo	6189	0644	edit dl rm
cvslib.py	10175	0644	edit dl rm
cvslib.pyc	13240	0644	edit dl rm
cvslib.pyo	13240	0644	edit dl rm
cvslock.py	6771	0644	edit dl rm
cvslock.pyc	8597	0644	edit dl rm
cvslock.pyo	8597	0644	edit dl rm
FSProxy.py	8469	0644	edit dl rm
FSProxy.pyc	13360	0644	edit dl rm
FSProxy.pyo	13360	0644	edit dl rm
mac.py	352	0644	edit dl rm
mac.pyc	603	0644	edit dl rm
mac.pyo	603	0644	edit dl rm
makechangelog.py	2992	0755	edit dl rm
makechangelog.pyc	3156	0644	edit dl rm
makechangelog.pyo	3156	0644	edit dl rm
rcsbump	742	0755	edit dl rm
rcsclient.py	1803	0644	edit dl rm
rcsclient.pyc	2128	0644	edit dl rm
rcsclient.pyo	2128	0644	edit dl rm
rcslib.py	10318	0644	edit dl rm
rcslib.pyc	11613	0644	edit dl rm
rcslib.pyo	11613	0644	edit dl rm
RCSProxy.py	4727	0755	edit dl rm
RCSProxy.pyc	7786	0644	edit dl rm
RCSProxy.pyo	7786	0644	edit dl rm
rcvs	114	0755	edit dl rm
rcvs.py	13648	0755	edit dl rm
rcvs.pyc	14581	0644	edit dl rm
rcvs.pyo	14581	0644	edit dl rm
README	4264	0644	edit dl rm
rrcs	114	0755	edit dl rm
rrcs.py	3996	0755	edit dl rm
rrcs.pyc	5670	0644	edit dl rm
rrcs.pyo	5670	0644	edit dl rm
security.py	1092	0644	edit dl rm
security.pyc	1693	0644	edit dl rm
security.pyo	1693	0644	edit dl rm
server.py	4581	0644	edit dl rm
server.pyc	6033	0644	edit dl rm
server.pyo	6033	0644	edit dl rm
sumtree.py	518	0644	edit dl rm
sumtree.pyc	905	0644	edit dl rm
sumtree.pyo	905	0644	edit dl rm

Edit: /usr/lib64/python2.6/Demo/pdist/cvslib.py (10175B)

"""Utilities for CVS administration."""

import string
import os
import time
import md5
import fnmatch

if not hasattr(time, 'timezone'):
    time.timezone = 0

class File:

"""Represent a file's status.

Instance variables:

file -- the filename (no slashes), None if uninitialized
    lseen -- true if the data for the local file is up to date
    eseen -- true if the data from the CVS/Entries entry is up to date
             (this implies that the entry must be written back)
    rseen -- true if the data for the remote file is up to date
    proxy -- RCSProxy instance used to contact the server, or None

Note that lseen and rseen don't necessary mean that a local
    or remote file *exists* -- they indicate that we've checked it.
    However, eseen means that this instance corresponds to an
    entry in the CVS/Entries file.

If lseen is true:

lsum -- checksum of the local file, None if no local file
    lctime -- ctime of the local file, None if no local file
    lmtime -- mtime of the local file, None if no local file

If eseen is true:

erev -- revision, None if this is a no revision (not '0')
    enew -- true if this is an uncommitted added file
    edeleted -- true if this is an uncommitted removed file
    ectime -- ctime of last local file corresponding to erev
    emtime -- mtime of last local file corresponding to erev
    extra -- 5th string from CVS/Entries file

If rseen is true:

rrev -- revision of head, None if non-existent
    rsum -- checksum of that revision, Non if non-existent

If eseen and rseen are both true:

esum -- checksum of revision erev, None if no revision

Note
    """

def __init__(self, file = None):
        if file and '/' in file:
            raise ValueError, "no slash allowed in file"
        self.file = file
        self.lseen = self.eseen = self.rseen = 0
        self.proxy = None

def __cmp__(self, other):
        return cmp(self.file, other.file)

def getlocal(self):
        try:
            self.lmtime, self.lctime = os.stat(self.file)[-2:]
        except os.error:
            self.lmtime = self.lctime = self.lsum = None
        else:
            self.lsum = md5.new(open(self.file).read()).digest()
        self.lseen = 1

def getentry(self, line):
        words = string.splitfields(line, '/')
        if self.file and words[1] != self.file:
            raise ValueError, "file name mismatch"
        self.file = words[1]
        self.erev = words[2]
        self.edeleted = 0
        self.enew = 0
        self.ectime = self.emtime = None
        if self.erev[:1] == '-':
            self.edeleted = 1
            self.erev = self.erev[1:]
        if self.erev == '0':
            self.erev = None
            self.enew = 1
        else:
            dates = words[3]
            self.ectime = unctime(dates[:24])
            self.emtime = unctime(dates[25:])
        self.extra = words[4]
        if self.rseen:
            self.getesum()
        self.eseen = 1

def getremote(self, proxy = None):
        if proxy:
            self.proxy = proxy
        try:
            self.rrev = self.proxy.head(self.file)
        except (os.error, IOError):
            self.rrev = None
        if self.rrev:
            self.rsum = self.proxy.sum(self.file)
        else:
            self.rsum = None
        if self.eseen:
            self.getesum()
        self.rseen = 1

def getesum(self):
        if self.erev == self.rrev:
            self.esum = self.rsum
        elif self.erev:
            name = (self.file, self.erev)
            self.esum = self.proxy.sum(name)
        else:
            self.esum = None

def putentry(self):
        """Return a line suitable for inclusion in CVS/Entries.

The returned line is terminated by a newline.
        If no entry should be written for this file,
        return "".
        """
        if not self.eseen:
            return ""

rev = self.erev or '0'
        if self.edeleted:
            rev = '-' + rev
        if self.enew:
            dates = 'Initial ' + self.file
        else:
            dates = gmctime(self.ectime) + ' ' + \
                    gmctime(self.emtime)
        return "/%s/%s/%s/%s/\n" % (
                self.file,
                rev,
                dates,
                self.extra)

def report(self):
        print '-'*50
        def r(key, repr=repr, self=self):
            try:
                value = repr(getattr(self, key))
            except AttributeError:
                value = "?"
            print "%-15s:" % key, value
        r("file")
        if self.lseen:
            r("lsum", hexify)
            r("lctime", gmctime)
            r("lmtime", gmctime)
        if self.eseen:
            r("erev")
            r("enew")
            r("edeleted")
            r("ectime", gmctime)
            r("emtime", gmctime)
        if self.rseen:
            r("rrev")
            r("rsum", hexify)
            if self.eseen:
                r("esum", hexify)

class CVS:

"""Represent the contents of a CVS admin file (and more).

Class variables:

FileClass -- the class to be instantiated for entries
                 (this should be derived from class File above)
    IgnoreList -- shell patterns for local files to be ignored

Instance variables:

entries -- a dictionary containing File instances keyed by
               their file name
    proxy -- an RCSProxy instance, or None
    """

FileClass = File

IgnoreList = ['.*', '@*', ',*', '*~', '*.o', '*.a', '*.so', '*.pyc']

def __init__(self):
        self.entries = {}
        self.proxy = None

def setproxy(self, proxy):
        if proxy is self.proxy:
            return
        self.proxy = proxy
        for e in self.entries.values():
            e.rseen = 0

def getentries(self):
        """Read the contents of CVS/Entries"""
        self.entries = {}
        f = self.cvsopen("Entries")
        while 1:
            line = f.readline()
            if not line: break
            e = self.FileClass()
            e.getentry(line)
            self.entries[e.file] = e
        f.close()

def putentries(self):
        """Write CVS/Entries back"""
        f = self.cvsopen("Entries", 'w')
        for e in self.values():
            f.write(e.putentry())
        f.close()

def getlocalfiles(self):
        list = self.entries.keys()
        addlist = os.listdir(os.curdir)
        for name in addlist:
            if name in list:
                continue
            if not self.ignored(name):
                list.append(name)
        list.sort()
        for file in list:
            try:
                e = self.entries[file]
            except KeyError:
                e = self.entries[file] = self.FileClass(file)
            e.getlocal()

def getremotefiles(self, proxy = None):
        if proxy:
            self.proxy = proxy
        if not self.proxy:
            raise RuntimeError, "no RCS proxy"
        addlist = self.proxy.listfiles()
        for file in addlist:
            try:
                e = self.entries[file]
            except KeyError:
                e = self.entries[file] = self.FileClass(file)
            e.getremote(self.proxy)

def report(self):
        for e in self.values():
            e.report()
        print '-'*50

def keys(self):
        keys = self.entries.keys()
        keys.sort()
        return keys

def values(self):
        def value(key, self=self):
            return self.entries[key]
        return map(value, self.keys())

def items(self):
        def item(key, self=self):
            return (key, self.entries[key])
        return map(item, self.keys())

def cvsexists(self, file):
        file = os.path.join("CVS", file)
        return os.path.exists(file)

def cvsopen(self, file, mode = 'r'):
        file = os.path.join("CVS", file)
        if 'r' not in mode:
            self.backup(file)
        return open(file, mode)

def backup(self, file):
        if os.path.isfile(file):
            bfile = file + '~'
            try: os.unlink(bfile)
            except os.error: pass
            os.rename(file, bfile)

def ignored(self, file):
        if os.path.isdir(file): return True
        for pat in self.IgnoreList:
            if fnmatch.fnmatch(file, pat): return True
        return False

# hexify and unhexify are useful to print MD5 checksums in hex format

hexify_format = '%02x' * 16
def hexify(sum):
    "Return a hex representation of a 16-byte string (e.g. an MD5 digest)"
    if sum is None:
        return "None"
    return hexify_format % tuple(map(ord, sum))

def unhexify(hexsum):
    "Return the original from a hexified string"
    if hexsum == "None":
        return None
    sum = ''
    for i in range(0, len(hexsum), 2):
        sum = sum + chr(string.atoi(hexsum[i:i+2], 16))
    return sum

unctime_monthmap = {}
def unctime(date):
    if date == "None": return None
    if not unctime_monthmap:
        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
        i = 0
        for m in months:
            i = i+1
            unctime_monthmap[m] = i
    words = string.split(date) # Day Mon DD HH:MM:SS YEAR
    year = string.atoi(words[4])
    month = unctime_monthmap[words[1]]
    day = string.atoi(words[2])
    [hh, mm, ss] = map(string.atoi, string.splitfields(words[3], ':'))
    ss = ss - time.timezone
    return time.mktime((year, month, day, hh, mm, ss, 0, 0, 0))

def gmctime(t):
    if t is None: return "None"
    return time.asctime(time.gmtime(t))

def test_unctime():
    now = int(time.time())
    t = time.gmtime(now)
    at = time.asctime(t)
    print 'GMT', now, at
    print 'timezone', time.timezone
    print 'local', time.ctime(now)
    u = unctime(at)
    print 'unctime()', u
    gu = time.gmtime(u)
    print '->', gu
    print time.asctime(gu)

def test():
    x = CVS()
    x.getentries()
    x.getlocalfiles()
##      x.report()
    import rcsclient
    proxy = rcsclient.openrcsclient()
    x.getremotefiles(proxy)
    x.report()

if __name__ == "__main__":
    test()

cmd: