|
28
|
1 from __future__ import with_statement
|
|
|
2
|
|
18
|
3 from orpg.dirpath import dir_struct
|
|
28
|
4 from upmana.validate import validate
|
|
|
5 from orpg.tools.orpg_log import logger
|
|
|
6 from os import sep, getcwd
|
|
14
|
7 from types import *
|
|
|
8
|
|
28
|
9 from xml.etree.ElementTree import ElementTree, Element, parse, fromstring
|
|
|
10 from xml.etree.ElementPath import find
|
|
|
11
|
|
|
12 class ManifestChanges(object):
|
|
|
13 etree = ElementTree()
|
|
|
14 filename = dir_struct['home'] + 'upmana' + sep + 'upmana.xml'
|
|
14
|
15
|
|
28
|
16 def __new__(cls, *args, **kwargs):
|
|
|
17 it = cls.__dict__.get("__it__")
|
|
|
18 if it is not None:
|
|
|
19 return it
|
|
|
20 cls.__it__ = it = object.__new__(cls)
|
|
|
21 it._init()
|
|
|
22 return it
|
|
|
23
|
|
|
24 def _init(self):
|
|
|
25 validate.config_file('upmana.xml', "default_upmana.xml")
|
|
|
26 self.LoadDoc()
|
|
|
27
|
|
|
28 def PluginChildren(self, plugname):
|
|
|
29 plugin = self.etree.find(plugname)
|
|
|
30 children = plugin.getchildren()
|
|
|
31 nodes = []
|
|
|
32 for child in children:
|
|
|
33 nodes.append(child.tag)
|
|
|
34 return nodes
|
|
|
35
|
|
|
36 def GetString(self, plugname, strname, defaultval="", verbose=False):
|
|
14
|
37 strname = self.safe(strname)
|
|
28
|
38 plugin = self.etree.find(plugname)
|
|
|
39 if plugin is None or plugin.find(strname) is None:
|
|
|
40 msg = ["plugindb: no value has been stored for", strname, "in",
|
|
|
41 plugname, "so the default has been returned"]
|
|
14
|
42 return defaultval
|
|
28
|
43 return self.normal(plugin.find(strname).text or '')
|
|
|
44
|
|
|
45 def DelString(self, plugname, strname):
|
|
|
46 strname = self.safe(strname)
|
|
|
47 plugin = self.etree.find(plugname)
|
|
|
48 plugin.remove(plugin.find(strname))
|
|
|
49 self.SaveDoc()
|
|
14
|
50
|
|
|
51 def SetString(self, plugname, strname, val):
|
|
|
52 val = self.safe(val)
|
|
|
53 strname = self.safe(strname)
|
|
28
|
54 plugin = self.etree.find(plugname)
|
|
|
55 if plugin is None:
|
|
|
56 plugin = Element(plugname)
|
|
|
57 self.etree.getroot().append(plugin)
|
|
|
58 str_el = plugin.find(strname)
|
|
|
59 if str_el is None:
|
|
|
60 str_el = Element(strname)
|
|
|
61 str_el.set('type', 'str')
|
|
|
62 plugin.append(str_el)
|
|
|
63 str_el.text = val
|
|
|
64 self.SaveDoc()
|
|
14
|
65
|
|
|
66 def FetchList(self, parent):
|
|
|
67 retlist = []
|
|
28
|
68 for litem in parent.find('list').findall('lobject'):
|
|
|
69 if litem.get('type') == 'int': retlist.append(int(litem.text))
|
|
|
70 if litem.get('type') == 'bool': retlist.append(litem.text == 'True')
|
|
|
71 elif litem.get('type') == 'float': retlist.append(float(litem.text))
|
|
|
72 elif litem.get('type') == 'list': retlist.append(self.FetchList(litem))
|
|
|
73 elif litem.get('type') == 'dict': retlist.append(self.FetchDict(litem))
|
|
|
74 else: retlist.append(str(self.normal(litem.text)))
|
|
|
75 return retlist
|
|
|
76
|
|
|
77 def GetList(self, plugname, listname, defaultval=list(), verbose=False):
|
|
|
78 listname = self.safe(listname)
|
|
|
79 plugin = self.etree.find(plugname)
|
|
|
80 if plugin is None or plugin.find(listname) is None:
|
|
|
81 msg = ["plugindb: no value has been stored for", listname, "in",
|
|
|
82 plugname, "so the default has been returned"]
|
|
|
83 return defaultval
|
|
|
84 retlist = self.FetchList(plugin.find(listname))
|
|
14
|
85 return retlist
|
|
|
86
|
|
|
87 def BuildList(self, val):
|
|
28
|
88 list_el = Element('list')
|
|
14
|
89 for item in val:
|
|
28
|
90 i = Element('lobject')
|
|
|
91 if isinstance(item, bool):
|
|
|
92 i.set('type', 'bool')
|
|
|
93 i.text = str(item)
|
|
|
94 elif isinstance(item, int):#it's an int
|
|
|
95 i.set('type', 'int')
|
|
|
96 i.text = str(item)
|
|
|
97 elif isinstance(item, float):#it's a float
|
|
|
98 i.set('type', 'float')
|
|
|
99 i.text = str(item)
|
|
|
100 elif isinstance(item, (list, tuple)):#it's a list
|
|
|
101 i.set('type', 'list')
|
|
|
102 i.append(self.BuildList(item))
|
|
|
103 elif isinstance(item, dict):#it's a dictionary
|
|
|
104 i.set('type', 'dict')
|
|
|
105 i.append(self.BuildDict(item))
|
|
|
106 else:
|
|
|
107 i.set('type', 'str')
|
|
|
108 i.text = self.safe(item)
|
|
|
109 list_el.append(i)
|
|
|
110 return list_el
|
|
14
|
111
|
|
|
112 def SetList(self, plugname, listname, val):
|
|
|
113 listname = self.safe(listname)
|
|
28
|
114 plugin = self.etree.find(plugname)
|
|
|
115 if plugin is None:
|
|
|
116 plugin = Element(plugname)
|
|
|
117 self.etree.getroot().append(plugin)
|
|
|
118 list_el = plugin.find(listname)
|
|
|
119 if list_el is None:
|
|
|
120 list_el = Element(listname)
|
|
|
121 list_el.set('type', 'list')
|
|
|
122 plugin.append(list_el)
|
|
14
|
123 else:
|
|
28
|
124 list_el.remove(list_el.find('list'))
|
|
|
125 list_el.append(self.BuildList(val))
|
|
|
126 self.SaveDoc()
|
|
14
|
127
|
|
|
128 def BuildDict(self, val):
|
|
28
|
129 dict_el = Element('dict')
|
|
|
130 for key, item in val.items():
|
|
|
131 i = Element('dobject')
|
|
|
132 if isinstance(item, bool):
|
|
|
133 i.set('type', 'bool')
|
|
|
134 i.set('name', self.safe(key))
|
|
|
135 i.text = str(item)
|
|
|
136 elif isinstance(item, int):#it's an int
|
|
|
137 i.set('type', 'int')
|
|
|
138 i.set('name', self.safe(key))
|
|
|
139 i.text = str(item)
|
|
|
140 elif isinstance(item, float):#it's a float
|
|
|
141 i.set('type', 'float')
|
|
|
142 i.set('name', self.safe(key))
|
|
|
143 i.text = str(item)
|
|
|
144 elif isinstance(item, (list, tuple)):#it's a list
|
|
|
145 i.set('type', 'list')
|
|
|
146 i.set('name', self.safe(key))
|
|
|
147 i.append(self.BuildList(item))
|
|
|
148 elif isinstance(item, dict):#it's a dictionary
|
|
|
149 i.set('type', 'dict')
|
|
|
150 i.set('name', self.safe(key))
|
|
|
151 i.append(self.BuildDict(item))
|
|
|
152 else:
|
|
|
153 i.set('type', 'str')
|
|
|
154 i.set('name', self.safe(key))
|
|
|
155 i.text = self.safe(item)
|
|
|
156 dict_el.append(i)
|
|
|
157 return dict_el
|
|
14
|
158
|
|
28
|
159 def SetDict(self, plugname, dictname, val):
|
|
14
|
160 dictname = self.safe(dictname)
|
|
28
|
161 plugin = self.etree.find(plugname)
|
|
|
162 if plugin is None:
|
|
|
163 plugin = Element(plugname)
|
|
|
164 self.etree.getroot().append(plugin)
|
|
|
165 dict_el = plugin.find(dictname)
|
|
|
166 if dict_el is None:
|
|
|
167 dict_el = Element(dictname)
|
|
|
168 dict_el.set('type', 'dict')
|
|
|
169 plugin.append(dict_el)
|
|
14
|
170 else:
|
|
28
|
171 dict_el.remove(list_el.find('dict'))
|
|
|
172 dict_el.append(self.BuildDict(val))
|
|
|
173 self.SaveDoc()
|
|
14
|
174
|
|
|
175 def FetchDict(self, parent):
|
|
|
176 retdict = {}
|
|
28
|
177 for ditem in parent.findall('dobject'):
|
|
|
178 key = self.normal(ditem.get('name'))
|
|
|
179 if ditem.get('type') == 'int': value = int(ditem.text)
|
|
|
180 elif ditem.get('type') == 'bool': value = ditem.text == 'True'
|
|
|
181 elif ditem.get('type') == 'float': value = float(ditem.text)
|
|
|
182 elif ditem.get('type') == 'list': value = self.FetchList(ditem)
|
|
|
183 elif ditem.get('type') == 'dict': value = self.FetchDict(ditem)
|
|
|
184 else: value = str(self.normal(ditem[0]))
|
|
|
185 retdict[key] = value
|
|
14
|
186 return retdict
|
|
|
187
|
|
28
|
188 def GetDict(self, plugname, dictname, defaultval=dict(), verbose=False):
|
|
14
|
189 dictname = self.safe(dictname)
|
|
28
|
190 plugin = self.etree.find(plugname)
|
|
|
191 if plugin is None or plugin.find(dictname) is None:
|
|
|
192 msg = ["plugindb: no value has been stored for", dictname, "in",
|
|
|
193 plugname, "so the default has been returned"]
|
|
14
|
194 return defaultval
|
|
28
|
195 retdict = self.FetchDict(plugin.find(dictname))
|
|
|
196 return retdict
|
|
14
|
197
|
|
|
198 def safe(self, string):
|
|
28
|
199 return string.replace("<", "$$lt$$").replace(">", "$$gt$$")\
|
|
|
200 .replace("&","$$amp$$").replace('"',"$$quote$$")
|
|
14
|
201
|
|
|
202 def normal(self, string):
|
|
28
|
203 return string.replace("$$lt$$", "<").replace("$$gt$$", ">")\
|
|
|
204 .replace("$$amp$$","&").replace("$$quote$$",'"')
|
|
14
|
205
|
|
|
206 def SaveDoc(self):
|
|
28
|
207 with open(self.filename, "w") as f:
|
|
|
208 self.etree.write(f)
|
|
14
|
209
|
|
|
210 def LoadDoc(self):
|
|
28
|
211 with open(self.filename) as f:
|
|
|
212 self.etree.parse(f)
|
|
|
213
|
|
|
214 manifest = ManifestChanges()
|
