Package ldaptor :: Module usage :: Class Options
[show private | hide private]
[frames | no frames]

Type Options

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


Method Summary
  postOptions(self)
I am called after the options are parsed.
    Inherited from Options
  __init__(self)
  __hash__(self)
  __str__(self, width)
  getSynopsis(self)
  getUsage(self, width)
  opt_help(self)
Display this help and exit.
  opt_version(self)
  parseArgs(self)
I am called with any leftover arguments which were not options.
  parseOptions(self, options)
The guts of the command-line parser.
  _gather_flags(self)
Gather up boolean (flag) options.
  _gather_handlers(self)
Gather up options with their own handler methods.
  _gather_parameters(self)
Gather options which take a value.
  _generic_flag(self, flagName, value)
  _generic_parameter(self, parameterName, value)
    Inherited from dict
  __cmp__(x, y)
x.__cmp__(y) <==> cmp(x,y)
  __contains__(x, y)
x.__contains__(y) <==> y in x
  __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, E)
D.update(E) -> 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
tuple optParameters = ()
    Inherited from Options
NoneType defaultSubCommand = None                                                                  
NoneType parent = None                                                                  
NoneType subCommand = None                                                                  

Method Details

postOptions(self)

I am called after the options are parsed.

Override this method in your subclass to do something after the options have been parsed and assigned, like validate that all options are sane.
Overrides:
twisted.python.usage.Options.postOptions (inherited documentation)

Class Variable Details

optParameters

Type:
tuple
Value:
()                                                                     

Generated by Epydoc 2.1 on Tue Aug 17 17:08:20 2004 http://epydoc.sf.net