MiscUtils.PropertiesObject | index /usr/local/share/webware/MiscUtils/PropertiesObject.py

Modules

``

os | sys |  |

Classes

``

__builtin__.dict(__builtin__.object)
  PropertiesObject
exceptions.Exception(exceptions.BaseException)
  WillNotRunError

class PropertiesObject(__builtin__.dict)

``

`A Properties Object.
A PropertiesObject represents, in a dictionary-like fashion, the values
found in a Properties.py file. That file is always included with a Webware
component to advertise its name, version, status, etc. Note that a Webware
component is a Python package that follows additional conventions.
Also, the top level Webware directory contains a Properties.py.
Component properties are often used for:
* generation of documentation
* runtime examination of components, especially prior to loading
PropertiesObject provides additional keys:
* filename - the filename from which the properties were read
* versionString - a nicely printable string of the version
* requiredPyVersionString - like versionString,
but for requiredPyVersion instead
* willRun - 1 if the component will run.
So far that means having the right Python version.
* willNotRunReason - defined only if willRun is 0,
contains a readable error message
Using a PropertiesObject is better than investigating the Properties.py
file directly, because the rules for determining derived keys and any
future convenience methods will all be provided here.
Usage example:
from MiscUtils.PropertiesObject import PropertiesObject
props = PropertiesObject(filename)
for item in props.items():
print '%s: %s' % item
Note: We don't normally suffix a class name with "Object" as we have
with this class, however, the name Properties.py is already used in
our containing package and all other packages.
`

Method resolution order:
  PropertiesObject
  __builtin__.dict
  __builtin__.object

Methods defined here:

__init__(self, filename=None)

checkDeniedOpSys(self)

checkRequiredOpSys(self)

checkRequiredPyVersion(self)

checkRequiredSoftware(self)
  `Not implemented. No op right now.`

checkWillRunFunc(self)

cleanPrivateItems(self)
  `Remove items whose keys start with a double underscore, such as __builtins__.`

createDerivedItems(self)

createRequiredPyVersionString(self)

createVersionString(self)

createWillRun(self)

loadValues(self, *args, **kwargs)

readFileNamed(self, filename)

willRunKeys(self)
  `Return keys to be examined before running the component.
  This returns a set of all keys whose values should be examined in
  order to determine if the component will run. Used by createWillRun().`

Data descriptors defined here:

__dict__
  `dictionary for instance variables (if defined)`

__weakref__
  `list of weak references to the object (if defined)`

Methods inherited from __builtin__.dict:

__cmp__(...)
  `x.__cmp__(y) <==> cmp(x,y)`

__contains__(...)
  `D.__contains__(k) -> True if D has a key k, else False`

__delitem__(...)
  `x.__delitem__(y) <==> del x[y]`

__eq__(...)
  `x.__eq__(y) <==> x==y`

__ge__(...)
  `x.__ge__(y) <==> x>=y`

__getattribute__(...)
  `x.__getattribute__('name') <==> x.name`

__getitem__(...)
  `x.__getitem__(y) <==> x[y]`

__gt__(...)
  `x.__gt__(y) <==> x>y`

__iter__(...)
  `x.__iter__() <==> iter(x)`

__le__(...)
  `x.__le__(y) <==> x<=y`

__len__(...)
  `x.__len__() <==> len(x)`

__lt__(...)
  `x.__lt__(y) <==> x<y`

__ne__(...)
  `x.__ne__(y) <==> x!=y`

__repr__(...)
  `x.__repr__() <==> repr(x)`

__setitem__(...)
  `x.__setitem__(i, y) <==> x[i]=y`

__sizeof__(...)
  `D.__sizeof__() -> size of D in memory, in bytes`

clear(...)
  `D.clear() -> None. Remove all items from D.`

copy(...)
  `D.copy() -> a shallow copy of D`

get(...)
  `D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.`

has_key(...)
  `D.has_key(k) -> True if D has a key k, else False`

items(...)
  `D.items() -> list of D's (key, value) pairs, as 2-tuples`

iteritems(...)
  `D.iteritems() -> an iterator over the (key, value) items of D`

iterkeys(...)
  `D.iterkeys() -> an iterator over the keys of D`

itervalues(...)
  `D.itervalues() -> an iterator over the values of D`

keys(...)
  `D.keys() -> list of D's keys`

pop(...)
  `D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  If key is not found, d is returned if given, otherwise KeyError is raised`

popitem(...)
  `D.popitem() -> (k, v), remove and return some (key, value) pair as a
  2-tuple; but raise KeyError if D is empty.`

setdefault(...)
  `D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D`

update(...)
  `D.update(E, **F) -> None. Update D from dict/iterable E and F.
  If E has a .keys() method, does: for k in E: D[k] = E[k]
  If E lacks .keys() method, does: for (k, v) in E: D[k] = v
  In either case, this is followed by: for k in F: D[k] = F[k]`

values(...)
  `D.values() -> list of D's values`

viewitems(...)
  `D.viewitems() -> a set-like object providing a view on D's items`

viewkeys(...)
  `D.viewkeys() -> a set-like object providing a view on D's keys`

viewvalues(...)
  `D.viewvalues() -> an object providing a view on D's values`

Data and other attributes inherited from __builtin__.dict:

__hash__ = None

__new__ = <built-in method __new__ of type object>
  `T.__new__(S, ...) -> a new object with type S, a subtype of T`

fromkeys = <built-in method fromkeys of type object>
  `dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  v defaults to None.`

class WillNotRunError(exceptions.Exception)
`` | `Error for Webware components that will not run.`

Method resolution order:
  WillNotRunError
  exceptions.Exception
  exceptions.BaseException
  __builtin__.object

Data descriptors defined here:

__weakref__
  `list of weak references to the object (if defined)`

Methods inherited from exceptions.Exception:

__init__(...)
  `x.__init__(...) initializes x; see help(type(x)) for signature`

Data and other attributes inherited from exceptions.Exception:

__new__ = <built-in method __new__ of type object>
  `T.__new__(S, ...) -> a new object with type S, a subtype of T`

Methods inherited from exceptions.BaseException:

__delattr__(...)
  `x.__delattr__('name') <==> del x.name`

__getattribute__(...)
  `x.__getattribute__('name') <==> x.name`

__getitem__(...)
  `x.__getitem__(y) <==> x[y]`

__getslice__(...)
  `x.__getslice__(i, j) <==> x[i:j]
  Use of negative indices is not supported.`

__reduce__(...)

__repr__(...)
  `x.__repr__() <==> repr(x)`

__setattr__(...)
  `x.__setattr__('name', value) <==> x.name = value`

__setstate__(...)

__str__(...)
  `x.__str__() <==> str(x)`

__unicode__(...)

Data descriptors inherited from exceptions.BaseException:

__dict__

args

message