|
|
- __builtin__.dict(__builtin__.object)
-
- ConfigFile
- ConfigImport
class
ConfigFile(__builtin__.dict) |
|
This is a configuration dictionary base class; it takes
care of reading and writing the configuration to a file
transparently as needed.
Thanks to Mike Pirnat <exilejedi@users.sourceforge.net>
for the original idea and code this was copied from
as well as a number of useful comments and tips.
It has to be subclassed, so that cfg_default contains the
default option mapping, and __doc__ the comment to be printed out
at the beginning of the configuration file.
For instance, one could define:
class MyConfig(adesklets.ConfigFile):
"""
This is my configuration file description
"""
cfg_default = { 'my_one_parameter' : 'some_value' }
def __init__(self, id, filename):
adesklets.
ConfigFile.__init__(self, id, filename)
And then call, from somewhere in its code:
config = MyConfig(adesklets.get_id(),'/path/to/config_file')
From there, all configuration read and write would be taken care of,
and the parameter value could be accessed through
config['my_one_parameter'].
Parameter resolution works this way:
- Parameters are first looked up in a textual representation of
a dictionnary from the 'config_file' file named id##,
## being the ID number.
- All undefined parameters are set to their default values from
the cfg_default dictionary
- Whenever a parameter is changed using something such as:
config['my_one_parameter']='new_value'
or anytime a load phase is over, all the parameters initially
present in 'config_file' (NOT default ones) are pretty printed
back to the file.
- In the special case where no id## entry did exist in
'config_file', the dictionary of default values is copied
instead.
This behavior ensure desklets writers being able to add or remove
parameters on upgrade while preserving backward compatibility.
|
|
- Method resolution order:
- ConfigFile
- __builtin__.dict
- __builtin__.object
Methods defined here:
- __init__(self,
id, filename)
- __setitem__(self,
key, value)
-
This was 'overloaded' since we wanted to make
sure the configuration file was kept in sync
with the live configuration data
Data and other attributes defined here:
- __dict__ = <dictproxy
object>
-
dictionary for instance variables (if defined)
- __weakref__ = <attribute
'__weakref__' of 'ConfigFile' objects>
-
list of weak references to the object (if defined)
- cfg_default = {}
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
- __hash__(...)
- x.__hash__() <==> hash(x)
- __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)
- 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 E and F: for k in E: D[k] = E[k]
(if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]
- values(...)
- D.values() -> list of D's values
Data and other attributes inherited from __builtin__.dict:
- __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
ConfigImport |
|
This class makes use of the AST (Abstract Syntax Tree) generated
by the compiler package parsing an arbitrary string of
python code to 'walk' through it until it finishes retrieving
all the global variables completely determined at compile time.
For instance, one could call:
ConfigImport.load('i=1; j={2:True,3:False}')
To get back, as a dictionary:
{'i':1, 'j': {2:True,3:False}}
This was written as a safe alternative to calls such as:
exec file('some_File','r') in some_dict
It is indeed much safer, since no arbitrary code ever
get executed (only parsed), and variadic symbols
(i.e everything that is not a known constant at compile time)
are all discarded.
|
|
Data and other attributes defined here:
- load =
<adesklets.configfile._StaticConfigImport
instance>
|
|