File Manager

X7ROOT File Manager

Current Path: /lib64/python2.7/Demo/pdist

lib64 / python2.7 / Demo / pdist /

ðŸ“ ..
ðŸ“„ FSProxy.py(7.64 KB)
ðŸ“„ FSProxy.pyc(12.5 KB)
ðŸ“„ FSProxy.pyo(12.5 KB)
ðŸ“„ RCSProxy.py(4.61 KB)
ðŸ“„ RCSProxy.pyc(7.57 KB)
ðŸ“„ RCSProxy.pyo(7.57 KB)
ðŸ“„ README(4.16 KB)
ðŸ“„ client.py(4.6 KB)
ðŸ“„ client.pyc(6.57 KB)
ðŸ“„ client.pyo(6.57 KB)
ðŸ“„ cmdfw.py(4.53 KB)
ðŸ“„ cmdfw.pyc(5.12 KB)
ðŸ“„ cmdfw.pyo(5.12 KB)
ðŸ“„ cmptree.py(5.64 KB)
ðŸ“„ cmptree.pyc(5.98 KB)
ðŸ“„ cmptree.pyo(5.98 KB)
ðŸ“„ cvslib.py(9.94 KB)
ðŸ“„ cvslib.pyc(12.83 KB)
ðŸ“„ cvslib.pyo(12.83 KB)
ðŸ“„ cvslock.py(6.61 KB)
ðŸ“„ cvslock.pyc(8.36 KB)
ðŸ“„ cvslock.pyo(8.36 KB)
ðŸ“„ mac.py(352 B)
ðŸ“„ mac.pyc(598 B)
ðŸ“„ mac.pyo(598 B)
ðŸ“„ makechangelog.py(2.92 KB)
ðŸ“„ makechangelog.pyc(3.05 KB)
ðŸ“„ makechangelog.pyo(3.05 KB)
ðŸ“„ rcsbump(745 B)
ðŸ“„ rcsclient.py(1.76 KB)
ðŸ“„ rcsclient.pyc(2.05 KB)
ðŸ“„ rcsclient.pyo(2.05 KB)
ðŸ“„ rcslib.py(10.08 KB)
ðŸ“„ rcslib.pyc(11.28 KB)
ðŸ“„ rcslib.pyo(11.28 KB)
ðŸ“„ rcvs(117 B)
ðŸ“„ rcvs.py(13.32 KB)
ðŸ“„ rcvs.pyc(14.08 KB)
ðŸ“„ rcvs.pyo(14.08 KB)
ðŸ“„ rrcs(117 B)
ðŸ“„ rrcs.py(3.9 KB)
ðŸ“„ rrcs.pyc(5.5 KB)
ðŸ“„ rrcs.pyo(5.5 KB)
ðŸ“„ security.py(1.07 KB)
ðŸ“„ security.pyc(1.64 KB)
ðŸ“„ security.pyo(1.64 KB)
ðŸ“„ server.py(4.47 KB)
ðŸ“„ server.pyc(5.83 KB)
ðŸ“„ server.pyo(5.83 KB)
ðŸ“„ sumtree.py(518 B)
ðŸ“„ sumtree.pyc(903 B)
ðŸ“„ sumtree.pyo(903 B)

Editing: cmdfw.py

"Framework for command line interfaces like CVS.  See class CmdFrameWork."

class CommandFrameWork:

"""Framework class for command line interfaces like CVS.

The general command line structure is

command [flags] subcommand [subflags] [argument] ...

There's a class variable GlobalFlags which specifies the
    global flags options.  Subcommands are defined by defining
    methods named do_<subcommand>.  Flags for the subcommand are
    defined by defining class or instance variables named
    flags_<subcommand>.  If there's no command, method default()
    is called.  The __doc__ strings for the do_ methods are used
    for the usage message, printed after the general usage message
    which is the class variable UsageMessage.  The class variable
    PostUsageMessage is printed after all the do_ methods' __doc__
    strings.  The method's return value can be a suggested exit
    status.  [XXX Need to rewrite this to clarify it.]

Common usage is to derive a class, instantiate it, and then call its
    run() method; by default this takes its arguments from sys.argv[1:].
    """

UsageMessage = \
      "usage: (name)s [flags] subcommand [subflags] [argument] ..."

PostUsageMessage = None

GlobalFlags = ''

def __init__(self):
        """Constructor, present for completeness."""
        pass

def run(self, args = None):
        """Process flags, subcommand and options, then run it."""
        import getopt, sys
        if args is None: args = sys.argv[1:]
        try:
            opts, args = getopt.getopt(args, self.GlobalFlags)
        except getopt.error, msg:
            return self.usage(msg)
        self.options(opts)
        if not args:
            self.ready()
            return self.default()
        else:
            cmd = args[0]
            mname = 'do_' + cmd
            fname = 'flags_' + cmd
            try:
                method = getattr(self, mname)
            except AttributeError:
                return self.usage("command %r unknown" % (cmd,))
            try:
                flags = getattr(self, fname)
            except AttributeError:
                flags = ''
            try:
                opts, args = getopt.getopt(args[1:], flags)
            except getopt.error, msg:
                return self.usage(
                        "subcommand %s: " % cmd + str(msg))
            self.ready()
            return method(opts, args)

def options(self, opts):
        """Process the options retrieved by getopt.
        Override this if you have any options."""
        if opts:
            print "-"*40
            print "Options:"
            for o, a in opts:
                print 'option', o, 'value', repr(a)
            print "-"*40

def ready(self):
        """Called just before calling the subcommand."""
        pass

def usage(self, msg = None):
        """Print usage message.  Return suitable exit code (2)."""
        if msg: print msg
        print self.UsageMessage % {'name': self.__class__.__name__}
        docstrings = {}
        c = self.__class__
        while 1:
            for name in dir(c):
                if name[:3] == 'do_':
                    if docstrings.has_key(name):
                        continue
                    try:
                        doc = getattr(c, name).__doc__
                    except:
                        doc = None
                    if doc:
                        docstrings[name] = doc
            if not c.__bases__:
                break
            c = c.__bases__[0]
        if docstrings:
            print "where subcommand can be:"
            names = docstrings.keys()
            names.sort()
            for name in names:
                print docstrings[name]
        if self.PostUsageMessage:
            print self.PostUsageMessage
        return 2

def default(self):
        """Default method, called when no subcommand is given.
        You should always override this."""
        print "Nobody expects the Spanish Inquisition!"

def test():
    """Test script -- called when this module is run as a script."""
    import sys
    class Hello(CommandFrameWork):
        def do_hello(self, opts, args):
            "hello -- print 'hello world', needs no arguments"
            print "Hello, world"
    x = Hello()
    tests = [
            [],
            ['hello'],
            ['spam'],
            ['-x'],
            ['hello', '-x'],
            None,
            ]
    for t in tests:
        print '-'*10, t, '-'*10
        sts = x.run(t)
        print "Exit status:", repr(sts)

if __name__ == '__main__':
    test()

X7ROOT File Manager

Editing: cmdfw.py

Upload File

Create Folder