buildbot.scripts.runner.DebugClientOptions

Package buildbot :: Package scripts :: Module runner :: Class DebugClientOptions

Type DebugClientOptions

object --+        
         |        
      dict --+    
             |    
       Options --+
                 |
                DebugClientOptions

Method Summary
	`parseArgs(self)` I am called with any leftover arguments which were not options.
Inherited from Options
	`__init__(self)`
	`__hash__(self)`
	`__str__(self)`
	`getSynopsis(self)` Returns a string containing a description of these options and how to pass them to the executed file.
	`getUsage(self, width)`
	`opt_help(self)` Display this help and exit.
	`opt_version(self)`
	`parseOptions(self, options)` The guts of the command-line parser.
	`postOptions(self)` I am called after the options are parsed.
Inherited from dict
	`__cmp__(x, y)` x.__cmp__(y) <==> cmp(x,y)
	`__contains__(D, k)` D.__contains__(k) -> True if D has a key k, else False
	`__delitem__(x, y)` x.__delitem__(y) <==> del x[y]
	`__eq__(x, y)` x.__eq__(y) <==> x==y
	`__ge__(x, y)` x.__ge__(y) <==> x>=y
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__getitem__(x, y)` x.__getitem__(y) <==> x[y]
	`__gt__(x, y)` x.__gt__(y) <==> x>y
	`__iter__(x)` x.__iter__() <==> iter(x)
	`__le__(x, y)` x.__le__(y) <==> x<=y
	`__len__(x)` x.__len__() <==> len(x)
	`__lt__(x, y)` x.__lt__(y) <==> x<y
	`__ne__(x, y)` x.__ne__(y) <==> x!=y
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__repr__(x)` x.__repr__() <==> repr(x)
	`__setitem__(x, i, y)` x.__setitem__(i, y) <==> x[i]=y
	`clear(D)` D.clear() -> None.
	`copy(D)` D.copy() -> a shallow copy of D
	`get(D, k, d)` D.get(k[,d]) -> D[k] if k in D, else d.
	`has_key(D, k)` D.has_key(k) -> True if D has a key k, else False
	`items(D)` D.items() -> list of D's (key, value) pairs, as 2-tuples
	`iteritems(D)` D.iteritems() -> an iterator over the (key, value) items of D
	`iterkeys(D)` D.iterkeys() -> an iterator over the keys of D
	`itervalues(D)` D.itervalues() -> an iterator over the values of D
	`keys(D)` D.keys() -> list of D's keys
	`pop(D, k, d)` If key is not found, d is returned if given, otherwise KeyError is raised
	`popitem(D)` 2-tuple; but raise KeyError if D is empty
	`setdefault(D, k, d)` D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
	`update(...)` D.update(E, **F) -> None.
	`values(D)` D.values() -> list of D's values
Inherited from object
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__reduce__(...)` helper for pickle
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value
Inherited from type
	`fromkeys(dict, S, v)` v defaults to None.

Class Variable Summary
`list`	`optFlags` = `[['help', 'h', 'Display this message']]`
`list`	`optParameters` = `[['master', 'm', None, "Location of the ...`
Inherited from Options
`NoneType`	`defaultSubCommand` = None
`NoneType`	`parent` = None
`NoneType`	`subCommand` = None

Method Details

parseArgs(self, *args)

I am called with any leftover arguments which were not options.

Override me to do something with the remaining arguments on the command line, those which were not flags or options. e.g. interpret them as a list of files to operate on.

Note that if there more arguments on the command line than this method accepts, parseArgs will blow up with a getopt.error. This means if you don't override me, parseArgs will blow up if I am passed any arguments at all!

Overrides:: twisted.python.usage.Options.parseArgs (inherited documentation)

Class Variable Details

optFlags

Type:: list
Value:: [['help', 'h', 'Display this message']]

optParameters

Type:: list
Value:: [['master', 'm', None, "Location of the buildmaster's slaveport (host:\ port)"], ['passwd', 'p', None, 'Debug password to use']]

Generated by Epydoc 2.1 on Sun Dec 10 22:04:44 2006

http://epydoc.sf.net