##// END OF EJS Templates
schain
RSS
log to file
José Chávez -
r1047:20a96cdbf240
parent child
Show More
Side by Side Unified
Context file:
r1047:20a96cdbf240 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,167 +1,157
1 import click
1 import click
2 import schainpy
2 import schainpy
3 import subprocess
3 import subprocess
4 import os
4 import os
5 import sys
5 import sys
6 import glob
6 import glob
7 save_stdout = sys.stdout
7 save_stdout = sys.stdout
8 sys.stdout = open('trash', 'w')
8 sys.stdout = open('trash', 'w')
9 from multiprocessing import cpu_count
9 from multiprocessing import cpu_count
10 from schaincli import templates
10 from schaincli import templates
11 from schainpy import controller_api
11 from schainpy.controller import Project
12 from schainpy.model import Operation, ProcessingUnit
12 from schainpy.model import Operation, ProcessingUnit
13 from schainpy.utils import log
13 from schainpy.utils import log
14 from importlib import import_module
14 from importlib import import_module
15 from pydoc import locate
15 from pydoc import locate
16 from fuzzywuzzy import process
16 from fuzzywuzzy import process
17 from schainpy.utils import paramsFinder
17 from schainpy.utils import paramsFinder
18 sys.stdout = save_stdout
18 sys.stdout = save_stdout
19
19
20
20
21 def print_version(ctx, param, value):
21 def print_version(ctx, param, value):
22 if not value or ctx.resilient_parsing:
22 if not value or ctx.resilient_parsing:
23 return
23 return
24 click.echo(schainpy.__version__)
24 click.echo(schainpy.__version__)
25 ctx.exit()
25 ctx.exit()
26
26
27
27
28 cliLogger = log.makelogger('schain cli')
28 cliLogger = log.makelogger('schain cli')
29 PREFIX = 'experiment'
29 PREFIX = 'experiment'
30
30
31
31
32 @click.command()
32 @click.command()
33 @click.option('--version', '-v', is_flag=True, callback=print_version, help='SChain version', type=str)
33 @click.option('--version', '-v', is_flag=True, callback=print_version, help='SChain version', type=str)
34 @click.option('--xml', '-x', default=None, help='run an XML file', type=click.Path(exists=True, resolve_path=True))
34 @click.option('--xml', '-x', default=None, help='run an XML file', type=click.Path(exists=True, resolve_path=True))
35 @click.argument('command', default='run', required=True)
35 @click.argument('command', default='run', required=True)
36 @click.argument('nextcommand', default=None, required=False, type=str)
36 @click.argument('nextcommand', default=None, required=False, type=str)
37 def main(command, nextcommand, version, xml):
37 def main(command, nextcommand, version, xml):
38 """COMMAND LINE INTERFACE FOR SIGNAL CHAIN - JICAMARCA RADIO OBSERVATORY \n
38 """COMMAND LINE INTERFACE FOR SIGNAL CHAIN - JICAMARCA RADIO OBSERVATORY \n
39 Available commands.\n
39 Available commands.\n
40 --xml: runs a schain XML generated file\n
40 --xml: runs a schain XML generated file\n
41 run: runs any python script starting 'experiment_'\n
41 run: runs any python script starting 'experiment_'\n
42 generate: generates a template schain script\n
42 generate: generates a template schain script\n
43 search: return avilable operations, procs or arguments of the give operation/proc\n"""
43 search: return avilable operations, procs or arguments of the give operation/proc\n"""
44 if xml is not None:
44 if xml is not None:
45 runFromXML(xml)
45 runFromXML(xml)
46 elif command == 'generate':
46 elif command == 'generate':
47 generate()
47 generate()
48 elif command == 'test':
48 elif command == 'test':
49 test()
49 test()
50 elif command == 'run':
50 elif command == 'run':
51 runschain(nextcommand)
51 runschain(nextcommand)
52 elif command == 'search':
52 elif command == 'search':
53 search(nextcommand)
53 search(nextcommand)
54 else:
54 else:
55 log.error('Command {} is not defined'.format(command))
55 log.error('Command {} is not defined'.format(command))
56
56
57 def check_module(possible, instance):
57 def check_module(possible, instance):
58 def check(x):
58 def check(x):
59 try:
59 try:
60 instancia = locate('schainpy.model.{}'.format(x))
60 instancia = locate('schainpy.model.{}'.format(x))
61 return isinstance(instancia(), instance)
61 return isinstance(instancia(), instance)
62 except Exception as e:
62 except Exception as e:
63 return False
63 return False
64 clean = clean_modules(possible)
64 clean = clean_modules(possible)
65 return [x for x in clean if check(x)]
65 return [x for x in clean if check(x)]
66
66
67
67
68 def clean_modules(module):
68 def clean_modules(module):
69 noEndsUnder = [x for x in module if not x.endswith('__')]
69 noEndsUnder = [x for x in module if not x.endswith('__')]
70 noStartUnder = [x for x in noEndsUnder if not x.startswith('__')]
70 noStartUnder = [x for x in noEndsUnder if not x.startswith('__')]
71 noFullUpper = [x for x in noStartUnder if not x.isupper()]
71 noFullUpper = [x for x in noStartUnder if not x.isupper()]
72 return noFullUpper
72 return noFullUpper
73
73
74
74
75 def search(nextcommand):
75 def search(nextcommand):
76 if nextcommand is None:
76 if nextcommand is None:
77 log.error('There is no Operation/ProcessingUnit to search')
77 log.error('There is no Operation/ProcessingUnit to search')
78 elif nextcommand == 'procs':
78 elif nextcommand == 'procs':
79 procs = paramsFinder.getProcs()
79 procs = paramsFinder.getProcs()
80 log.success('Current ProcessingUnits are:\n\033[1m{}\033[0m'.format('\n'.join(procs)))
80 log.success('Current ProcessingUnits are:\n\033[1m{}\033[0m'.format('\n'.join(procs)))
81
81
82 elif nextcommand == 'operations':
82 elif nextcommand == 'operations':
83 operations = paramsFinder.getOperations()
83 operations = paramsFinder.getOperations()
84 log.success('Current Operations are:\n\033[1m{}\033[0m'.format('\n'.join(operations)))
84 log.success('Current Operations are:\n\033[1m{}\033[0m'.format('\n'.join(operations)))
85 else:
85 else:
86 try:
86 try:
87 args = paramsFinder.getArgs(nextcommand)
87 args = paramsFinder.getArgs(nextcommand)
88 log.warning('Use this feature with caution. It may not return all the allowed arguments')
88 log.warning('Use this feature with caution. It may not return all the allowed arguments')
89 if len(args) == 0:
89 if len(args) == 0:
90 log.success('{} has no arguments'.format(nextcommand))
90 log.success('{} has no arguments'.format(nextcommand))
91 else:
91 else:
92 log.success('Showing arguments of {} are:\n\033[1m{}\033[0m'.format(nextcommand, '\n'.join(args)))
92 log.success('Showing arguments of {} are:\n\033[1m{}\033[0m'.format(nextcommand, '\n'.join(args)))
93 except Exception as e:
93 except Exception as e:
94 log.error('Module {} does not exists'.format(nextcommand))
94 log.error('Module {} does not exists'.format(nextcommand))
95 allModules = paramsFinder.getAll()
95 allModules = paramsFinder.getAll()
96 similar = process.extractOne(nextcommand, allModules)[0]
96 similar = process.extractOne(nextcommand, allModules)[0]
97 log.success('Showing {} instead'.format(similar))
97 log.success('Showing {} instead'.format(similar))
98 search(similar)
98 search(similar)
99
99
100
100
101 def runschain(nextcommand):
101 def runschain(nextcommand):
102 if nextcommand is None:
102 if nextcommand is None:
103 currentfiles = glob.glob('./{}_*.py'.format(PREFIX))
103 currentfiles = glob.glob('./{}_*.py'.format(PREFIX))
104 numberfiles = len(currentfiles)
104 numberfiles = len(currentfiles)
105 if numberfiles > 1:
105 if numberfiles > 1:
106 log.error('There is more than one file to run')
106 log.error('There is more than one file to run')
107 elif numberfiles == 1:
107 elif numberfiles == 1:
108 subprocess.call(['python ' + currentfiles[0]], shell=True)
108 subprocess.call(['python ' + currentfiles[0]], shell=True)
109 else:
109 else:
110 log.error('There is no file to run')
110 log.error('There is no file to run')
111 else:
111 else:
112 try:
112 try:
113 subprocess.call(['python ' + nextcommand], shell=True)
113 subprocess.call(['python ' + nextcommand], shell=True)
114 except Exception as e:
114 except Exception as e:
115 log.error("I cannot run the file. Does it exists?")
115 log.error("I cannot run the file. Does it exists?")
116
116
117
117
118 def basicInputs():
118 def basicInputs():
119 inputs = {}
119 inputs = {}
120 inputs['desc'] = click.prompt('Enter a description', default="A schain project", type=str)
120 inputs['desc'] = click.prompt('Enter a description', default="A schain project", type=str)
121 inputs['name'] = click.prompt('Name of the project', default="project", type=str)
121 inputs['name'] = click.prompt('Name of the project', default="project", type=str)
122 inputs['path'] = click.prompt('Data path', default=os.getcwd(), type=click.Path(exists=True, resolve_path=True))
122 inputs['path'] = click.prompt('Data path', default=os.getcwd(), type=click.Path(exists=True, resolve_path=True))
123 inputs['startDate'] = click.prompt('Start date', default='1970/01/01', type=str)
123 inputs['startDate'] = click.prompt('Start date', default='1970/01/01', type=str)
124 inputs['endDate'] = click.prompt('End date', default='2017/12/31', type=str)
124 inputs['endDate'] = click.prompt('End date', default='2017/12/31', type=str)
125 inputs['startHour'] = click.prompt('Start hour', default='00:00:00', type=str)
125 inputs['startHour'] = click.prompt('Start hour', default='00:00:00', type=str)
126 inputs['endHour'] = click.prompt('End hour', default='23:59:59', type=str)
126 inputs['endHour'] = click.prompt('End hour', default='23:59:59', type=str)
127 inputs['figpath'] = inputs['path'] + '/figs'
127 inputs['figpath'] = inputs['path'] + '/figs'
128 return inputs
128 return inputs
129
129
130
130
131 def generate():
131 def generate():
132 inputs = basicInputs()
132 inputs = basicInputs()
133 inputs['multiprocess'] = click.confirm('Is this a multiprocess script?')
133 inputs['multiprocess'] = click.confirm('Is this a multiprocess script?')
134 if inputs['multiprocess']:
134 if inputs['multiprocess']:
135 inputs['nProcess'] = click.prompt('How many process?', default=cpu_count(), type=int)
135 inputs['nProcess'] = click.prompt('How many process?', default=cpu_count(), type=int)
136 current = templates.multiprocess.format(**inputs)
136 current = templates.multiprocess.format(**inputs)
137 else:
137 else:
138 current = templates.basic.format(**inputs)
138 current = templates.basic.format(**inputs)
139 scriptname = '{}_{}.py'.format(PREFIX, inputs['name'])
139 scriptname = '{}_{}.py'.format(PREFIX, inputs['name'])
140 script = open(scriptname, 'w')
140 script = open(scriptname, 'w')
141 try:
141 try:
142 script.write(current)
142 script.write(current)
143 log.success('Script {} generated'.format(scriptname))
143 log.success('Script {} generated'.format(scriptname))
144 except Exception as e:
144 except Exception as e:
145 log.error('I cannot create the file. Do you have writing permissions?')
145 log.error('I cannot create the file. Do you have writing permissions?')
146
146
147
147
148 def test():
148 def test():
149 log.warning('testing')
149 log.warning('testing')
150
150
151
151
152 def runFromXML(filename):
152 def runFromXML(filename):
153 controller = controller_api.ControllerThread()
153 controller = Project()
154 if not controller.readXml(filename):
154 if not controller.readXml(filename):
155 return
155 return
156
157 plotterObj = controller.useExternalPlotter()
158
159 controller.start()
156 controller.start()
160 plotterObj.start()
161
162 cliLogger("Finishing all processes")
163
164 controller.join(5)
165
166 cliLogger("End of script")
167 return
157 return
Show file before | Show file after | Hide comments
@@ -1,1325 +1,1330
1 '''
1 '''
2 Created on September , 2012
2 Created on September , 2012
3 @author:
3 @author:
4 '''
4 '''
5
5
6 import sys
6 import sys
7
8 # save_stdout = sys.stdout
9 # logToFile = newLogger()
10 # sys.stdout = logToFile
11 # sys.stderr = logToFile
12
7 import ast
13 import ast
8 import datetime
14 import datetime
9 import traceback
15 import traceback
10 import math
16 import math
11 import time
17 import time
12 from multiprocessing import Process, Queue, cpu_count
18 from multiprocessing import Process, Queue, cpu_count
13
19
14 import schainpy
20 import schainpy
15 import schainpy.admin
21 import schainpy.admin
22 from schainpy.utils.log import logToFile
16
23
17 from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
24 from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
18 from xml.dom import minidom
25 from xml.dom import minidom
19
26
20 from schainpy.model import *
27 from schainpy.model import *
21 from time import sleep
28 from time import sleep
22
29
23
30
24
31
25 def prettify(elem):
32 def prettify(elem):
26 """Return a pretty-printed XML string for the Element.
33 """Return a pretty-printed XML string for the Element.
27 """
34 """
28 rough_string = tostring(elem, 'utf-8')
35 rough_string = tostring(elem, 'utf-8')
29 reparsed = minidom.parseString(rough_string)
36 reparsed = minidom.parseString(rough_string)
30 return reparsed.toprettyxml(indent=" ")
37 return reparsed.toprettyxml(indent=" ")
31
38
32 def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, by_day=False):
39 def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, by_day=False):
33 skip = 0
40 skip = 0
34 cursor = 0
41 cursor = 0
35 nFiles = None
42 nFiles = None
36 processes = []
43 processes = []
37 dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d')
44 dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d')
38 dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d')
45 dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d')
39 days = (dt2 - dt1).days
46 days = (dt2 - dt1).days
40
47
41 for day in range(days+1):
48 for day in range(days+1):
42 skip = 0
49 skip = 0
43 cursor = 0
50 cursor = 0
44 q = Queue()
51 q = Queue()
45 processes = []
52 processes = []
46 dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d')
53 dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d')
47 firstProcess = Process(target=child, args=(cursor, skip, q, dt))
54 firstProcess = Process(target=child, args=(cursor, skip, q, dt))
48 firstProcess.start()
55 firstProcess.start()
49 if by_day:
56 if by_day:
50 continue
57 continue
51 nFiles = q.get()
58 nFiles = q.get()
52 if nFiles==0:
59 if nFiles==0:
53 continue
60 continue
54 firstProcess.terminate()
61 firstProcess.terminate()
55 skip = int(math.ceil(nFiles/nProcess))
62 skip = int(math.ceil(nFiles/nProcess))
56 while True:
63 while True:
57 processes.append(Process(target=child, args=(cursor, skip, q, dt)))
64 processes.append(Process(target=child, args=(cursor, skip, q, dt)))
58 processes[cursor].start()
65 processes[cursor].start()
59 if nFiles < cursor*skip:
66 if nFiles < cursor*skip:
60 break
67 break
61 cursor += 1
68 cursor += 1
62
69
63 def beforeExit(exctype, value, trace):
70 def beforeExit(exctype, value, trace):
64 for process in processes:
71 for process in processes:
65 process.terminate()
72 process.terminate()
66 process.join()
73 process.join()
67 print traceback.print_tb(trace)
74 print traceback.print_tb(trace)
68
75
69 sys.excepthook = beforeExit
76 sys.excepthook = beforeExit
70
77
71 for process in processes:
78 for process in processes:
72 process.join()
79 process.join()
73 process.terminate()
80 process.terminate()
74
81
75 time.sleep(3)
82 time.sleep(3)
76
83
77
84
78 class ParameterConf():
85 class ParameterConf():
79
86
80 id = None
87 id = None
81 name = None
88 name = None
82 value = None
89 value = None
83 format = None
90 format = None
84
91
85 __formated_value = None
92 __formated_value = None
86
93
87 ELEMENTNAME = 'Parameter'
94 ELEMENTNAME = 'Parameter'
88
95
89 def __init__(self):
96 def __init__(self):
90
97
91 self.format = 'str'
98 self.format = 'str'
92
99
93 def getElementName(self):
100 def getElementName(self):
94
101
95 return self.ELEMENTNAME
102 return self.ELEMENTNAME
96
103
97 def getValue(self):
104 def getValue(self):
98
105
99 value = self.value
106 value = self.value
100 format = self.format
107 format = self.format
101
108
102 if self.__formated_value != None:
109 if self.__formated_value != None:
103
110
104 return self.__formated_value
111 return self.__formated_value
105
112
106 if format == 'obj':
113 if format == 'obj':
107 return value
114 return value
108
115
109 if format == 'str':
116 if format == 'str':
110 self.__formated_value = str(value)
117 self.__formated_value = str(value)
111 return self.__formated_value
118 return self.__formated_value
112
119
113 if value == '':
120 if value == '':
114 raise ValueError, "%s: This parameter value is empty" %self.name
121 raise ValueError, "%s: This parameter value is empty" %self.name
115
122
116 if format == 'list':
123 if format == 'list':
117 strList = value.split(',')
124 strList = value.split(',')
118
125
119 self.__formated_value = strList
126 self.__formated_value = strList
120
127
121 return self.__formated_value
128 return self.__formated_value
122
129
123 if format == 'intlist':
130 if format == 'intlist':
124 """
131 """
125 Example:
132 Example:
126 value = (0,1,2)
133 value = (0,1,2)
127 """
134 """
128
135
129 new_value = ast.literal_eval(value)
136 new_value = ast.literal_eval(value)
130
137
131 if type(new_value) not in (tuple, list):
138 if type(new_value) not in (tuple, list):
132 new_value = [int(new_value)]
139 new_value = [int(new_value)]
133
140
134 self.__formated_value = new_value
141 self.__formated_value = new_value
135
142
136 return self.__formated_value
143 return self.__formated_value
137
144
138 if format == 'floatlist':
145 if format == 'floatlist':
139 """
146 """
140 Example:
147 Example:
141 value = (0.5, 1.4, 2.7)
148 value = (0.5, 1.4, 2.7)
142 """
149 """
143
150
144 new_value = ast.literal_eval(value)
151 new_value = ast.literal_eval(value)
145
152
146 if type(new_value) not in (tuple, list):
153 if type(new_value) not in (tuple, list):
147 new_value = [float(new_value)]
154 new_value = [float(new_value)]
148
155
149 self.__formated_value = new_value
156 self.__formated_value = new_value
150
157
151 return self.__formated_value
158 return self.__formated_value
152
159
153 if format == 'date':
160 if format == 'date':
154 strList = value.split('/')
161 strList = value.split('/')
155 intList = [int(x) for x in strList]
162 intList = [int(x) for x in strList]
156 date = datetime.date(intList[0], intList[1], intList[2])
163 date = datetime.date(intList[0], intList[1], intList[2])
157
164
158 self.__formated_value = date
165 self.__formated_value = date
159
166
160 return self.__formated_value
167 return self.__formated_value
161
168
162 if format == 'time':
169 if format == 'time':
163 strList = value.split(':')
170 strList = value.split(':')
164 intList = [int(x) for x in strList]
171 intList = [int(x) for x in strList]
165 time = datetime.time(intList[0], intList[1], intList[2])
172 time = datetime.time(intList[0], intList[1], intList[2])
166
173
167 self.__formated_value = time
174 self.__formated_value = time
168
175
169 return self.__formated_value
176 return self.__formated_value
170
177
171 if format == 'pairslist':
178 if format == 'pairslist':
172 """
179 """
173 Example:
180 Example:
174 value = (0,1),(1,2)
181 value = (0,1),(1,2)
175 """
182 """
176
183
177 new_value = ast.literal_eval(value)
184 new_value = ast.literal_eval(value)
178
185
179 if type(new_value) not in (tuple, list):
186 if type(new_value) not in (tuple, list):
180 raise ValueError, "%s has to be a tuple or list of pairs" %value
187 raise ValueError, "%s has to be a tuple or list of pairs" %value
181
188
182 if type(new_value[0]) not in (tuple, list):
189 if type(new_value[0]) not in (tuple, list):
183 if len(new_value) != 2:
190 if len(new_value) != 2:
184 raise ValueError, "%s has to be a tuple or list of pairs" %value
191 raise ValueError, "%s has to be a tuple or list of pairs" %value
185 new_value = [new_value]
192 new_value = [new_value]
186
193
187 for thisPair in new_value:
194 for thisPair in new_value:
188 if len(thisPair) != 2:
195 if len(thisPair) != 2:
189 raise ValueError, "%s has to be a tuple or list of pairs" %value
196 raise ValueError, "%s has to be a tuple or list of pairs" %value
190
197
191 self.__formated_value = new_value
198 self.__formated_value = new_value
192
199
193 return self.__formated_value
200 return self.__formated_value
194
201
195 if format == 'multilist':
202 if format == 'multilist':
196 """
203 """
197 Example:
204 Example:
198 value = (0,1,2),(3,4,5)
205 value = (0,1,2),(3,4,5)
199 """
206 """
200 multiList = ast.literal_eval(value)
207 multiList = ast.literal_eval(value)
201
208
202 if type(multiList[0]) == int:
209 if type(multiList[0]) == int:
203 multiList = ast.literal_eval("(" + value + ")")
210 multiList = ast.literal_eval("(" + value + ")")
204
211
205 self.__formated_value = multiList
212 self.__formated_value = multiList
206
213
207 return self.__formated_value
214 return self.__formated_value
208
215
209 if format == 'bool':
216 if format == 'bool':
210 value = int(value)
217 value = int(value)
211
218
212 if format == 'int':
219 if format == 'int':
213 value = float(value)
220 value = float(value)
214
221
215 format_func = eval(format)
222 format_func = eval(format)
216
223
217 self.__formated_value = format_func(value)
224 self.__formated_value = format_func(value)
218
225
219 return self.__formated_value
226 return self.__formated_value
220
227
221 def updateId(self, new_id):
228 def updateId(self, new_id):
222
229
223 self.id = str(new_id)
230 self.id = str(new_id)
224
231
225 def setup(self, id, name, value, format='str'):
232 def setup(self, id, name, value, format='str'):
226 self.id = str(id)
233 self.id = str(id)
227 self.name = name
234 self.name = name
228 if format == 'obj':
235 if format == 'obj':
229 self.value = value
236 self.value = value
230 else:
237 else:
231 self.value = str(value)
238 self.value = str(value)
232 self.format = str.lower(format)
239 self.format = str.lower(format)
233
240
234 self.getValue()
241 self.getValue()
235
242
236 return 1
243 return 1
237
244
238 def update(self, name, value, format='str'):
245 def update(self, name, value, format='str'):
239
246
240 self.name = name
247 self.name = name
241 self.value = str(value)
248 self.value = str(value)
242 self.format = format
249 self.format = format
243
250
244 def makeXml(self, opElement):
251 def makeXml(self, opElement):
245 if self.name not in ('queue',):
252 if self.name not in ('queue',):
246 parmElement = SubElement(opElement, self.ELEMENTNAME)
253 parmElement = SubElement(opElement, self.ELEMENTNAME)
247 parmElement.set('id', str(self.id))
254 parmElement.set('id', str(self.id))
248 parmElement.set('name', self.name)
255 parmElement.set('name', self.name)
249 parmElement.set('value', self.value)
256 parmElement.set('value', self.value)
250 parmElement.set('format', self.format)
257 parmElement.set('format', self.format)
251
258
252 def readXml(self, parmElement):
259 def readXml(self, parmElement):
253
260
254 self.id = parmElement.get('id')
261 self.id = parmElement.get('id')
255 self.name = parmElement.get('name')
262 self.name = parmElement.get('name')
256 self.value = parmElement.get('value')
263 self.value = parmElement.get('value')
257 self.format = str.lower(parmElement.get('format'))
264 self.format = str.lower(parmElement.get('format'))
258
265
259 #Compatible with old signal chain version
266 #Compatible with old signal chain version
260 if self.format == 'int' and self.name == 'idfigure':
267 if self.format == 'int' and self.name == 'idfigure':
261 self.name = 'id'
268 self.name = 'id'
262
269
263 def printattr(self):
270 def printattr(self):
264
271
265 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
272 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
266
273
267 class OperationConf():
274 class OperationConf():
268
275
269 id = None
276 id = None
270 name = None
277 name = None
271 priority = None
278 priority = None
272 type = None
279 type = None
273
280
274 parmConfObjList = []
281 parmConfObjList = []
275
282
276 ELEMENTNAME = 'Operation'
283 ELEMENTNAME = 'Operation'
277
284
278 def __init__(self):
285 def __init__(self):
279
286
280 self.id = '0'
287 self.id = '0'
281 self.name = None
288 self.name = None
282 self.priority = None
289 self.priority = None
283 self.type = 'self'
290 self.type = 'self'
284
291
285
292
286 def __getNewId(self):
293 def __getNewId(self):
287
294
288 return int(self.id)*10 + len(self.parmConfObjList) + 1
295 return int(self.id)*10 + len(self.parmConfObjList) + 1
289
296
290 def updateId(self, new_id):
297 def updateId(self, new_id):
291
298
292 self.id = str(new_id)
299 self.id = str(new_id)
293
300
294 n = 1
301 n = 1
295 for parmObj in self.parmConfObjList:
302 for parmObj in self.parmConfObjList:
296
303
297 idParm = str(int(new_id)*10 + n)
304 idParm = str(int(new_id)*10 + n)
298 parmObj.updateId(idParm)
305 parmObj.updateId(idParm)
299
306
300 n += 1
307 n += 1
301
308
302 def getElementName(self):
309 def getElementName(self):
303
310
304 return self.ELEMENTNAME
311 return self.ELEMENTNAME
305
312
306 def getParameterObjList(self):
313 def getParameterObjList(self):
307
314
308 return self.parmConfObjList
315 return self.parmConfObjList
309
316
310 def getParameterObj(self, parameterName):
317 def getParameterObj(self, parameterName):
311
318
312 for parmConfObj in self.parmConfObjList:
319 for parmConfObj in self.parmConfObjList:
313
320
314 if parmConfObj.name != parameterName:
321 if parmConfObj.name != parameterName:
315 continue
322 continue
316
323
317 return parmConfObj
324 return parmConfObj
318
325
319 return None
326 return None
320
327
321 def getParameterObjfromValue(self, parameterValue):
328 def getParameterObjfromValue(self, parameterValue):
322
329
323 for parmConfObj in self.parmConfObjList:
330 for parmConfObj in self.parmConfObjList:
324
331
325 if parmConfObj.getValue() != parameterValue:
332 if parmConfObj.getValue() != parameterValue:
326 continue
333 continue
327
334
328 return parmConfObj.getValue()
335 return parmConfObj.getValue()
329
336
330 return None
337 return None
331
338
332 def getParameterValue(self, parameterName):
339 def getParameterValue(self, parameterName):
333
340
334 parameterObj = self.getParameterObj(parameterName)
341 parameterObj = self.getParameterObj(parameterName)
335
342
336 # if not parameterObj:
343 # if not parameterObj:
337 # return None
344 # return None
338
345
339 value = parameterObj.getValue()
346 value = parameterObj.getValue()
340
347
341 return value
348 return value
342
349
343
350
344 def getKwargs(self):
351 def getKwargs(self):
345
352
346 kwargs = {}
353 kwargs = {}
347
354
348 for parmConfObj in self.parmConfObjList:
355 for parmConfObj in self.parmConfObjList:
349 if self.name == 'run' and parmConfObj.name == 'datatype':
356 if self.name == 'run' and parmConfObj.name == 'datatype':
350 continue
357 continue
351
358
352 kwargs[parmConfObj.name] = parmConfObj.getValue()
359 kwargs[parmConfObj.name] = parmConfObj.getValue()
353
360
354 return kwargs
361 return kwargs
355
362
356 def setup(self, id, name, priority, type):
363 def setup(self, id, name, priority, type):
357
364
358 self.id = str(id)
365 self.id = str(id)
359 self.name = name
366 self.name = name
360 self.type = type
367 self.type = type
361 self.priority = priority
368 self.priority = priority
362
369
363 self.parmConfObjList = []
370 self.parmConfObjList = []
364
371
365 def removeParameters(self):
372 def removeParameters(self):
366
373
367 for obj in self.parmConfObjList:
374 for obj in self.parmConfObjList:
368 del obj
375 del obj
369
376
370 self.parmConfObjList = []
377 self.parmConfObjList = []
371
378
372 def addParameter(self, name, value, format='str'):
379 def addParameter(self, name, value, format='str'):
373
380
374 id = self.__getNewId()
381 id = self.__getNewId()
375
382
376 parmConfObj = ParameterConf()
383 parmConfObj = ParameterConf()
377 if not parmConfObj.setup(id, name, value, format):
384 if not parmConfObj.setup(id, name, value, format):
378 return None
385 return None
379
386
380 self.parmConfObjList.append(parmConfObj)
387 self.parmConfObjList.append(parmConfObj)
381
388
382 return parmConfObj
389 return parmConfObj
383
390
384 def changeParameter(self, name, value, format='str'):
391 def changeParameter(self, name, value, format='str'):
385
392
386 parmConfObj = self.getParameterObj(name)
393 parmConfObj = self.getParameterObj(name)
387 parmConfObj.update(name, value, format)
394 parmConfObj.update(name, value, format)
388
395
389 return parmConfObj
396 return parmConfObj
390
397
391 def makeXml(self, procUnitElement):
398 def makeXml(self, procUnitElement):
392
399
393 opElement = SubElement(procUnitElement, self.ELEMENTNAME)
400 opElement = SubElement(procUnitElement, self.ELEMENTNAME)
394 opElement.set('id', str(self.id))
401 opElement.set('id', str(self.id))
395 opElement.set('name', self.name)
402 opElement.set('name', self.name)
396 opElement.set('type', self.type)
403 opElement.set('type', self.type)
397 opElement.set('priority', str(self.priority))
404 opElement.set('priority', str(self.priority))
398
405
399 for parmConfObj in self.parmConfObjList:
406 for parmConfObj in self.parmConfObjList:
400 parmConfObj.makeXml(opElement)
407 parmConfObj.makeXml(opElement)
401
408
402 def readXml(self, opElement):
409 def readXml(self, opElement):
403
410
404 self.id = opElement.get('id')
411 self.id = opElement.get('id')
405 self.name = opElement.get('name')
412 self.name = opElement.get('name')
406 self.type = opElement.get('type')
413 self.type = opElement.get('type')
407 self.priority = opElement.get('priority')
414 self.priority = opElement.get('priority')
408
415
409 #Compatible with old signal chain version
416 #Compatible with old signal chain version
410 #Use of 'run' method instead 'init'
417 #Use of 'run' method instead 'init'
411 if self.type == 'self' and self.name == 'init':
418 if self.type == 'self' and self.name == 'init':
412 self.name = 'run'
419 self.name = 'run'
413
420
414 self.parmConfObjList = []
421 self.parmConfObjList = []
415
422
416 parmElementList = opElement.iter(ParameterConf().getElementName())
423 parmElementList = opElement.iter(ParameterConf().getElementName())
417
424
418 for parmElement in parmElementList:
425 for parmElement in parmElementList:
419 parmConfObj = ParameterConf()
426 parmConfObj = ParameterConf()
420 parmConfObj.readXml(parmElement)
427 parmConfObj.readXml(parmElement)
421
428
422 #Compatible with old signal chain version
429 #Compatible with old signal chain version
423 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
430 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
424 if self.type != 'self' and self.name == 'Plot':
431 if self.type != 'self' and self.name == 'Plot':
425 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
432 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
426 self.name = parmConfObj.value
433 self.name = parmConfObj.value
427 continue
434 continue
428
435
429 self.parmConfObjList.append(parmConfObj)
436 self.parmConfObjList.append(parmConfObj)
430
437
431 def printattr(self):
438 def printattr(self):
432
439
433 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
440 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
434 self.id,
441 self.id,
435 self.name,
442 self.name,
436 self.type,
443 self.type,
437 self.priority)
444 self.priority)
438
445
439 for parmConfObj in self.parmConfObjList:
446 for parmConfObj in self.parmConfObjList:
440 parmConfObj.printattr()
447 parmConfObj.printattr()
441
448
442 def createObject(self, plotter_queue=None):
449 def createObject(self, plotter_queue=None):
443
450
444
451
445 if self.type == 'self':
452 if self.type == 'self':
446 raise ValueError, "This operation type cannot be created"
453 raise ValueError, "This operation type cannot be created"
447
454
448 if self.type == 'plotter':
455 if self.type == 'plotter':
449 #Plotter(plotter_name)
456 #Plotter(plotter_name)
450 if not plotter_queue:
457 if not plotter_queue:
451 raise ValueError, "plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)"
458 raise ValueError, "plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)"
452
459
453 opObj = Plotter(self.name, plotter_queue)
460 opObj = Plotter(self.name, plotter_queue)
454
461
455 if self.type == 'external' or self.type == 'other':
462 if self.type == 'external' or self.type == 'other':
456
463
457 className = eval(self.name)
464 className = eval(self.name)
458 kwargs = self.getKwargs()
465 kwargs = self.getKwargs()
459
466
460 opObj = className(**kwargs)
467 opObj = className(**kwargs)
461
468
462 return opObj
469 return opObj
463
470
464
471
465 class ProcUnitConf():
472 class ProcUnitConf():
466
473
467 id = None
474 id = None
468 name = None
475 name = None
469 datatype = None
476 datatype = None
470 inputId = None
477 inputId = None
471 parentId = None
478 parentId = None
472
479
473 opConfObjList = []
480 opConfObjList = []
474
481
475 procUnitObj = None
482 procUnitObj = None
476 opObjList = []
483 opObjList = []
477
484
478 ELEMENTNAME = 'ProcUnit'
485 ELEMENTNAME = 'ProcUnit'
479
486
480 def __init__(self):
487 def __init__(self):
481
488
482 self.id = None
489 self.id = None
483 self.datatype = None
490 self.datatype = None
484 self.name = None
491 self.name = None
485 self.inputId = None
492 self.inputId = None
486
493
487 self.opConfObjList = []
494 self.opConfObjList = []
488
495
489 self.procUnitObj = None
496 self.procUnitObj = None
490 self.opObjDict = {}
497 self.opObjDict = {}
491
498
492 def __getPriority(self):
499 def __getPriority(self):
493
500
494 return len(self.opConfObjList)+1
501 return len(self.opConfObjList)+1
495
502
496 def __getNewId(self):
503 def __getNewId(self):
497
504
498 return int(self.id)*10 + len(self.opConfObjList) + 1
505 return int(self.id)*10 + len(self.opConfObjList) + 1
499
506
500 def getElementName(self):
507 def getElementName(self):
501
508
502 return self.ELEMENTNAME
509 return self.ELEMENTNAME
503
510
504 def getId(self):
511 def getId(self):
505
512
506 return self.id
513 return self.id
507
514
508 def updateId(self, new_id, parentId=parentId):
515 def updateId(self, new_id, parentId=parentId):
509
516
510
517
511 new_id = int(parentId)*10 + (int(self.id) % 10)
518 new_id = int(parentId)*10 + (int(self.id) % 10)
512 new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
519 new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
513
520
514 #If this proc unit has not inputs
521 #If this proc unit has not inputs
515 if self.inputId == '0':
522 if self.inputId == '0':
516 new_inputId = 0
523 new_inputId = 0
517
524
518 n = 1
525 n = 1
519 for opConfObj in self.opConfObjList:
526 for opConfObj in self.opConfObjList:
520
527
521 idOp = str(int(new_id)*10 + n)
528 idOp = str(int(new_id)*10 + n)
522 opConfObj.updateId(idOp)
529 opConfObj.updateId(idOp)
523
530
524 n += 1
531 n += 1
525
532
526 self.parentId = str(parentId)
533 self.parentId = str(parentId)
527 self.id = str(new_id)
534 self.id = str(new_id)
528 self.inputId = str(new_inputId)
535 self.inputId = str(new_inputId)
529
536
530
537
531 def getInputId(self):
538 def getInputId(self):
532
539
533 return self.inputId
540 return self.inputId
534
541
535 def getOperationObjList(self):
542 def getOperationObjList(self):
536
543
537 return self.opConfObjList
544 return self.opConfObjList
538
545
539 def getOperationObj(self, name=None):
546 def getOperationObj(self, name=None):
540
547
541 for opConfObj in self.opConfObjList:
548 for opConfObj in self.opConfObjList:
542
549
543 if opConfObj.name != name:
550 if opConfObj.name != name:
544 continue
551 continue
545
552
546 return opConfObj
553 return opConfObj
547
554
548 return None
555 return None
549
556
550 def getOpObjfromParamValue(self, value=None):
557 def getOpObjfromParamValue(self, value=None):
551
558
552 for opConfObj in self.opConfObjList:
559 for opConfObj in self.opConfObjList:
553 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
560 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
554 continue
561 continue
555 return opConfObj
562 return opConfObj
556 return None
563 return None
557
564
558 def getProcUnitObj(self):
565 def getProcUnitObj(self):
559
566
560 return self.procUnitObj
567 return self.procUnitObj
561
568
562 def setup(self, id, name, datatype, inputId, parentId=None):
569 def setup(self, id, name, datatype, inputId, parentId=None):
563
570
564 #Compatible with old signal chain version
571 #Compatible with old signal chain version
565 if datatype==None and name==None:
572 if datatype==None and name==None:
566 raise ValueError, "datatype or name should be defined"
573 raise ValueError, "datatype or name should be defined"
567
574
568 if name==None:
575 if name==None:
569 if 'Proc' in datatype:
576 if 'Proc' in datatype:
570 name = datatype
577 name = datatype
571 else:
578 else:
572 name = '%sProc' %(datatype)
579 name = '%sProc' %(datatype)
573
580
574 if datatype==None:
581 if datatype==None:
575 datatype = name.replace('Proc','')
582 datatype = name.replace('Proc','')
576
583
577 self.id = str(id)
584 self.id = str(id)
578 self.name = name
585 self.name = name
579 self.datatype = datatype
586 self.datatype = datatype
580 self.inputId = inputId
587 self.inputId = inputId
581 self.parentId = parentId
588 self.parentId = parentId
582
589
583 self.opConfObjList = []
590 self.opConfObjList = []
584
591
585 self.addOperation(name='run', optype='self')
592 self.addOperation(name='run', optype='self')
586
593
587 def removeOperations(self):
594 def removeOperations(self):
588
595
589 for obj in self.opConfObjList:
596 for obj in self.opConfObjList:
590 del obj
597 del obj
591
598
592 self.opConfObjList = []
599 self.opConfObjList = []
593 self.addOperation(name='run')
600 self.addOperation(name='run')
594
601
595 def addParameter(self, **kwargs):
602 def addParameter(self, **kwargs):
596 '''
603 '''
597 Add parameters to "run" operation
604 Add parameters to "run" operation
598 '''
605 '''
599 opObj = self.opConfObjList[0]
606 opObj = self.opConfObjList[0]
600
607
601 opObj.addParameter(**kwargs)
608 opObj.addParameter(**kwargs)
602
609
603 return opObj
610 return opObj
604
611
605 def addOperation(self, name, optype='self'):
612 def addOperation(self, name, optype='self'):
606
613
607 id = self.__getNewId()
614 id = self.__getNewId()
608 priority = self.__getPriority()
615 priority = self.__getPriority()
609
616
610 opConfObj = OperationConf()
617 opConfObj = OperationConf()
611 opConfObj.setup(id, name=name, priority=priority, type=optype)
618 opConfObj.setup(id, name=name, priority=priority, type=optype)
612
619
613 self.opConfObjList.append(opConfObj)
620 self.opConfObjList.append(opConfObj)
614
621
615 return opConfObj
622 return opConfObj
616
623
617 def makeXml(self, projectElement):
624 def makeXml(self, projectElement):
618
625
619 procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
626 procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
620 procUnitElement.set('id', str(self.id))
627 procUnitElement.set('id', str(self.id))
621 procUnitElement.set('name', self.name)
628 procUnitElement.set('name', self.name)
622 procUnitElement.set('datatype', self.datatype)
629 procUnitElement.set('datatype', self.datatype)
623 procUnitElement.set('inputId', str(self.inputId))
630 procUnitElement.set('inputId', str(self.inputId))
624
631
625 for opConfObj in self.opConfObjList:
632 for opConfObj in self.opConfObjList:
626 opConfObj.makeXml(procUnitElement)
633 opConfObj.makeXml(procUnitElement)
627
634
628 def readXml(self, upElement):
635 def readXml(self, upElement):
629
636
630 self.id = upElement.get('id')
637 self.id = upElement.get('id')
631 self.name = upElement.get('name')
638 self.name = upElement.get('name')
632 self.datatype = upElement.get('datatype')
639 self.datatype = upElement.get('datatype')
633 self.inputId = upElement.get('inputId')
640 self.inputId = upElement.get('inputId')
634
641
635 if self.ELEMENTNAME == "ReadUnit":
642 if self.ELEMENTNAME == "ReadUnit":
636 self.datatype = self.datatype.replace("Reader", "")
643 self.datatype = self.datatype.replace("Reader", "")
637
644
638 if self.ELEMENTNAME == "ProcUnit":
645 if self.ELEMENTNAME == "ProcUnit":
639 self.datatype = self.datatype.replace("Proc", "")
646 self.datatype = self.datatype.replace("Proc", "")
640
647
641 if self.inputId == 'None':
648 if self.inputId == 'None':
642 self.inputId = '0'
649 self.inputId = '0'
643
650
644 self.opConfObjList = []
651 self.opConfObjList = []
645
652
646 opElementList = upElement.iter(OperationConf().getElementName())
653 opElementList = upElement.iter(OperationConf().getElementName())
647
654
648 for opElement in opElementList:
655 for opElement in opElementList:
649 opConfObj = OperationConf()
656 opConfObj = OperationConf()
650 opConfObj.readXml(opElement)
657 opConfObj.readXml(opElement)
651 self.opConfObjList.append(opConfObj)
658 self.opConfObjList.append(opConfObj)
652
659
653 def printattr(self):
660 def printattr(self):
654
661
655 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
662 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
656 self.id,
663 self.id,
657 self.name,
664 self.name,
658 self.datatype,
665 self.datatype,
659 self.inputId)
666 self.inputId)
660
667
661 for opConfObj in self.opConfObjList:
668 for opConfObj in self.opConfObjList:
662 opConfObj.printattr()
669 opConfObj.printattr()
663
670
664
671
665 def getKwargs(self):
672 def getKwargs(self):
666
673
667 opObj = self.opConfObjList[0]
674 opObj = self.opConfObjList[0]
668 kwargs = opObj.getKwargs()
675 kwargs = opObj.getKwargs()
669
676
670 return kwargs
677 return kwargs
671
678
672 def createObjects(self, plotter_queue=None):
679 def createObjects(self, plotter_queue=None):
673
680
674 className = eval(self.name)
681 className = eval(self.name)
675 kwargs = self.getKwargs()
682 kwargs = self.getKwargs()
676 procUnitObj = className(**kwargs)
683 procUnitObj = className(**kwargs)
677
684
678 for opConfObj in self.opConfObjList:
685 for opConfObj in self.opConfObjList:
679
686
680 if opConfObj.type=='self' and self.name=='run':
687 if opConfObj.type=='self' and self.name=='run':
681 continue
688 continue
682 elif opConfObj.type=='self':
689 elif opConfObj.type=='self':
683 procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
690 procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
684 continue
691 continue
685
692
686 opObj = opConfObj.createObject(plotter_queue)
693 opObj = opConfObj.createObject(plotter_queue)
687
694
688 self.opObjDict[opConfObj.id] = opObj
695 self.opObjDict[opConfObj.id] = opObj
689
696
690 procUnitObj.addOperation(opObj, opConfObj.id)
697 procUnitObj.addOperation(opObj, opConfObj.id)
691
698
692 self.procUnitObj = procUnitObj
699 self.procUnitObj = procUnitObj
693
700
694 return procUnitObj
701 return procUnitObj
695
702
696 def run(self):
703 def run(self):
697
704
698 is_ok = False
705 is_ok = False
699
706
700 for opConfObj in self.opConfObjList:
707 for opConfObj in self.opConfObjList:
701
708
702 kwargs = {}
709 kwargs = {}
703 for parmConfObj in opConfObj.getParameterObjList():
710 for parmConfObj in opConfObj.getParameterObjList():
704 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
711 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
705 continue
712 continue
706
713
707 kwargs[parmConfObj.name] = parmConfObj.getValue()
714 kwargs[parmConfObj.name] = parmConfObj.getValue()
708
715
709 #ini = time.time()
716 #ini = time.time()
710
717
711 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
718 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
712 sts = self.procUnitObj.call(opType = opConfObj.type,
719 sts = self.procUnitObj.call(opType = opConfObj.type,
713 opName = opConfObj.name,
720 opName = opConfObj.name,
714 opId = opConfObj.id)
721 opId = opConfObj.id)
715
722
716 # total_time = time.time() - ini
723 # total_time = time.time() - ini
717 #
724 #
718 # if total_time > 0.002:
725 # if total_time > 0.002:
719 # print "%s::%s took %f seconds" %(self.name, opConfObj.name, total_time)
726 # print "%s::%s took %f seconds" %(self.name, opConfObj.name, total_time)
720
727
721 is_ok = is_ok or sts
728 is_ok = is_ok or sts
722
729
723 return is_ok
730 return is_ok
724
731
725 def close(self):
732 def close(self):
726
733
727 for opConfObj in self.opConfObjList:
734 for opConfObj in self.opConfObjList:
728 if opConfObj.type == 'self':
735 if opConfObj.type == 'self':
729 continue
736 continue
730
737
731 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
738 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
732 opObj.close()
739 opObj.close()
733
740
734 self.procUnitObj.close()
741 self.procUnitObj.close()
735
742
736 return
743 return
737
744
738 class ReadUnitConf(ProcUnitConf):
745 class ReadUnitConf(ProcUnitConf):
739
746
740 path = None
747 path = None
741 startDate = None
748 startDate = None
742 endDate = None
749 endDate = None
743 startTime = None
750 startTime = None
744 endTime = None
751 endTime = None
745
752
746 ELEMENTNAME = 'ReadUnit'
753 ELEMENTNAME = 'ReadUnit'
747
754
748 def __init__(self):
755 def __init__(self):
749
756
750 self.id = None
757 self.id = None
751 self.datatype = None
758 self.datatype = None
752 self.name = None
759 self.name = None
753 self.inputId = None
760 self.inputId = None
754
761
755 self.parentId = None
762 self.parentId = None
756
763
757 self.opConfObjList = []
764 self.opConfObjList = []
758 self.opObjList = []
765 self.opObjList = []
759
766
760 def getElementName(self):
767 def getElementName(self):
761
768
762 return self.ELEMENTNAME
769 return self.ELEMENTNAME
763
770
764 def setup(self, id, name, datatype, path='', startDate="", endDate="", startTime="",
771 def setup(self, id, name, datatype, path='', startDate="", endDate="", startTime="",
765 endTime="", parentId=None, queue=None, server=None, **kwargs):
772 endTime="", parentId=None, queue=None, server=None, **kwargs):
766 #Compatible with old signal chain version
773 #Compatible with old signal chain version
767 if datatype==None and name==None:
774 if datatype==None and name==None:
768 raise ValueError, "datatype or name should be defined"
775 raise ValueError, "datatype or name should be defined"
769
776
770 if name==None:
777 if name==None:
771 if 'Reader' in datatype:
778 if 'Reader' in datatype:
772 name = datatype
779 name = datatype
773 else:
780 else:
774 name = '%sReader' %(datatype)
781 name = '%sReader' %(datatype)
775 if datatype==None:
782 if datatype==None:
776 datatype = name.replace('Reader','')
783 datatype = name.replace('Reader','')
777
784
778 self.id = id
785 self.id = id
779 self.name = name
786 self.name = name
780 self.datatype = datatype
787 self.datatype = datatype
781 if path != '':
788 if path != '':
782 self.path = os.path.abspath(path)
789 self.path = os.path.abspath(path)
783 self.startDate = startDate
790 self.startDate = startDate
784 self.endDate = endDate
791 self.endDate = endDate
785 self.startTime = startTime
792 self.startTime = startTime
786 self.endTime = endTime
793 self.endTime = endTime
787
794
788 self.inputId = '0'
795 self.inputId = '0'
789 self.parentId = parentId
796 self.parentId = parentId
790 self.queue = queue
797 self.queue = queue
791 self.server = server
798 self.server = server
792 self.addRunOperation(**kwargs)
799 self.addRunOperation(**kwargs)
793
800
794 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
801 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
795
802
796 #Compatible with old signal chain version
803 #Compatible with old signal chain version
797 if datatype==None and name==None:
804 if datatype==None and name==None:
798 raise ValueError, "datatype or name should be defined"
805 raise ValueError, "datatype or name should be defined"
799
806
800 if name==None:
807 if name==None:
801 if 'Reader' in datatype:
808 if 'Reader' in datatype:
802 name = datatype
809 name = datatype
803 else:
810 else:
804 name = '%sReader' %(datatype)
811 name = '%sReader' %(datatype)
805
812
806 if datatype==None:
813 if datatype==None:
807 datatype = name.replace('Reader','')
814 datatype = name.replace('Reader','')
808
815
809 self.datatype = datatype
816 self.datatype = datatype
810 self.name = name
817 self.name = name
811 self.path = path
818 self.path = path
812 self.startDate = startDate
819 self.startDate = startDate
813 self.endDate = endDate
820 self.endDate = endDate
814 self.startTime = startTime
821 self.startTime = startTime
815 self.endTime = endTime
822 self.endTime = endTime
816
823
817 self.inputId = '0'
824 self.inputId = '0'
818 self.parentId = parentId
825 self.parentId = parentId
819
826
820 self.updateRunOperation(**kwargs)
827 self.updateRunOperation(**kwargs)
821
828
822 def removeOperations(self):
829 def removeOperations(self):
823
830
824 for obj in self.opConfObjList:
831 for obj in self.opConfObjList:
825 del obj
832 del obj
826
833
827 self.opConfObjList = []
834 self.opConfObjList = []
828
835
829 def addRunOperation(self, **kwargs):
836 def addRunOperation(self, **kwargs):
830
837
831 opObj = self.addOperation(name = 'run', optype = 'self')
838 opObj = self.addOperation(name = 'run', optype = 'self')
832
839
833 if self.server is None:
840 if self.server is None:
834 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
841 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
835 opObj.addParameter(name='path' , value=self.path, format='str')
842 opObj.addParameter(name='path' , value=self.path, format='str')
836 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
843 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
837 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
844 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
838 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
845 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
839 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
846 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
840 opObj.addParameter(name='queue' , value=self.queue, format='obj')
847 opObj.addParameter(name='queue' , value=self.queue, format='obj')
841 for key, value in kwargs.items():
848 for key, value in kwargs.items():
842 opObj.addParameter(name=key, value=value, format=type(value).__name__)
849 opObj.addParameter(name=key, value=value, format=type(value).__name__)
843 else:
850 else:
844 opObj.addParameter(name='server' , value=self.server, format='str')
851 opObj.addParameter(name='server' , value=self.server, format='str')
845
852
846
853
847 return opObj
854 return opObj
848
855
849 def updateRunOperation(self, **kwargs):
856 def updateRunOperation(self, **kwargs):
850
857
851 opObj = self.getOperationObj(name = 'run')
858 opObj = self.getOperationObj(name = 'run')
852 opObj.removeParameters()
859 opObj.removeParameters()
853
860
854 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
861 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
855 opObj.addParameter(name='path' , value=self.path, format='str')
862 opObj.addParameter(name='path' , value=self.path, format='str')
856 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
863 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
857 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
864 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
858 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
865 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
859 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
866 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
860
867
861 for key, value in kwargs.items():
868 for key, value in kwargs.items():
862 opObj.addParameter(name=key, value=value, format=type(value).__name__)
869 opObj.addParameter(name=key, value=value, format=type(value).__name__)
863
870
864 return opObj
871 return opObj
865
872
866 # def makeXml(self, projectElement):
873 # def makeXml(self, projectElement):
867 #
874 #
868 # procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
875 # procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
869 # procUnitElement.set('id', str(self.id))
876 # procUnitElement.set('id', str(self.id))
870 # procUnitElement.set('name', self.name)
877 # procUnitElement.set('name', self.name)
871 # procUnitElement.set('datatype', self.datatype)
878 # procUnitElement.set('datatype', self.datatype)
872 # procUnitElement.set('inputId', str(self.inputId))
879 # procUnitElement.set('inputId', str(self.inputId))
873 #
880 #
874 # for opConfObj in self.opConfObjList:
881 # for opConfObj in self.opConfObjList:
875 # opConfObj.makeXml(procUnitElement)
882 # opConfObj.makeXml(procUnitElement)
876
883
877 def readXml(self, upElement):
884 def readXml(self, upElement):
878
885
879 self.id = upElement.get('id')
886 self.id = upElement.get('id')
880 self.name = upElement.get('name')
887 self.name = upElement.get('name')
881 self.datatype = upElement.get('datatype')
888 self.datatype = upElement.get('datatype')
882 self.inputId = upElement.get('inputId')
889 self.inputId = upElement.get('inputId')
883
890
884 if self.ELEMENTNAME == "ReadUnit":
891 if self.ELEMENTNAME == "ReadUnit":
885 self.datatype = self.datatype.replace("Reader", "")
892 self.datatype = self.datatype.replace("Reader", "")
886
893
887 if self.inputId == 'None':
894 if self.inputId == 'None':
888 self.inputId = '0'
895 self.inputId = '0'
889
896
890 self.opConfObjList = []
897 self.opConfObjList = []
891
898
892 opElementList = upElement.iter(OperationConf().getElementName())
899 opElementList = upElement.iter(OperationConf().getElementName())
893
900
894 for opElement in opElementList:
901 for opElement in opElementList:
895 opConfObj = OperationConf()
902 opConfObj = OperationConf()
896 opConfObj.readXml(opElement)
903 opConfObj.readXml(opElement)
897 self.opConfObjList.append(opConfObj)
904 self.opConfObjList.append(opConfObj)
898
905
899 if opConfObj.name == 'run':
906 if opConfObj.name == 'run':
900 self.path = opConfObj.getParameterValue('path')
907 self.path = opConfObj.getParameterValue('path')
901 self.startDate = opConfObj.getParameterValue('startDate')
908 self.startDate = opConfObj.getParameterValue('startDate')
902 self.endDate = opConfObj.getParameterValue('endDate')
909 self.endDate = opConfObj.getParameterValue('endDate')
903 self.startTime = opConfObj.getParameterValue('startTime')
910 self.startTime = opConfObj.getParameterValue('startTime')
904 self.endTime = opConfObj.getParameterValue('endTime')
911 self.endTime = opConfObj.getParameterValue('endTime')
905
912
906 class Project(Process):
913 class Project(Process):
907
908 id = None
914 id = None
909 name = None
915 name = None
910 description = None
916 description = None
911 filename = None
917 filename = None
912
918
913 procUnitConfObjDict = None
919 procUnitConfObjDict = None
914
920
915 ELEMENTNAME = 'Project'
921 ELEMENTNAME = 'Project'
916
922
917 plotterQueue = None
923 plotterQueue = None
918
924
919 def __init__(self, plotter_queue=None):
925 def __init__(self, plotter_queue=None, logfile=None):
920 Process.__init__(self)
926 Process.__init__(self)
921 self.id = None
927 self.id = None
922 self.name = None
928 self.name = None
923 self.description = None
929 self.description = None
924
930 if logfile is not None:
931 logToFile(logfile)
925 self.plotterQueue = plotter_queue
932 self.plotterQueue = plotter_queue
926
933
927 self.procUnitConfObjDict = {}
934 self.procUnitConfObjDict = {}
928
935
929 def __getNewId(self):
936 def __getNewId(self):
930
937
931 idList = self.procUnitConfObjDict.keys()
938 idList = self.procUnitConfObjDict.keys()
932
939
933 id = int(self.id)*10
940 id = int(self.id)*10
934
941
935 while True:
942 while True:
936 id += 1
943 id += 1
937
944
938 if str(id) in idList:
945 if str(id) in idList:
939 continue
946 continue
940
947
941 break
948 break
942
949
943 return str(id)
950 return str(id)
944
951
945 def getElementName(self):
952 def getElementName(self):
946
953
947 return self.ELEMENTNAME
954 return self.ELEMENTNAME
948
955
949 def getId(self):
956 def getId(self):
950
957
951 return self.id
958 return self.id
952
959
953 def updateId(self, new_id):
960 def updateId(self, new_id):
954
961
955 self.id = str(new_id)
962 self.id = str(new_id)
956
963
957 keyList = self.procUnitConfObjDict.keys()
964 keyList = self.procUnitConfObjDict.keys()
958 keyList.sort()
965 keyList.sort()
959
966
960 n = 1
967 n = 1
961 newProcUnitConfObjDict = {}
968 newProcUnitConfObjDict = {}
962
969
963 for procKey in keyList:
970 for procKey in keyList:
964
971
965 procUnitConfObj = self.procUnitConfObjDict[procKey]
972 procUnitConfObj = self.procUnitConfObjDict[procKey]
966 idProcUnit = str(int(self.id)*10 + n)
973 idProcUnit = str(int(self.id)*10 + n)
967 procUnitConfObj.updateId(idProcUnit, parentId = self.id)
974 procUnitConfObj.updateId(idProcUnit, parentId = self.id)
968
975
969 newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
976 newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
970 n += 1
977 n += 1
971
978
972 self.procUnitConfObjDict = newProcUnitConfObjDict
979 self.procUnitConfObjDict = newProcUnitConfObjDict
973
980
974 def setup(self, id, name, description):
981 def setup(self, id, name, description):
975
982
976 self.id = str(id)
983 self.id = str(id)
977 self.name = name
984 self.name = name
978 self.description = description
985 self.description = description
979
986
980 def update(self, name, description):
987 def update(self, name, description):
981
988
982 self.name = name
989 self.name = name
983 self.description = description
990 self.description = description
984
991
985 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
992 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
986 if id is None:
993 if id is None:
987 idReadUnit = self.__getNewId()
994 idReadUnit = self.__getNewId()
988 else:
995 else:
989 idReadUnit = str(id)
996 idReadUnit = str(id)
990
997
991 readUnitConfObj = ReadUnitConf()
998 readUnitConfObj = ReadUnitConf()
992 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
999 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
993
1000
994 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
1001 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
995
1002
996 return readUnitConfObj
1003 return readUnitConfObj
997
1004
998 def addProcUnit(self, inputId='0', datatype=None, name=None):
1005 def addProcUnit(self, inputId='0', datatype=None, name=None):
999
1006
1000 idProcUnit = self.__getNewId()
1007 idProcUnit = self.__getNewId()
1001
1008
1002 procUnitConfObj = ProcUnitConf()
1009 procUnitConfObj = ProcUnitConf()
1003 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
1010 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
1004
1011
1005 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1012 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1006
1013
1007 return procUnitConfObj
1014 return procUnitConfObj
1008
1015
1009 def removeProcUnit(self, id):
1016 def removeProcUnit(self, id):
1010
1017
1011 if id in self.procUnitConfObjDict.keys():
1018 if id in self.procUnitConfObjDict.keys():
1012 self.procUnitConfObjDict.pop(id)
1019 self.procUnitConfObjDict.pop(id)
1013
1020
1014 def getReadUnitId(self):
1021 def getReadUnitId(self):
1015
1022
1016 readUnitConfObj = self.getReadUnitObj()
1023 readUnitConfObj = self.getReadUnitObj()
1017
1024
1018 return readUnitConfObj.id
1025 return readUnitConfObj.id
1019
1026
1020 def getReadUnitObj(self):
1027 def getReadUnitObj(self):
1021
1028
1022 for obj in self.procUnitConfObjDict.values():
1029 for obj in self.procUnitConfObjDict.values():
1023 if obj.getElementName() == "ReadUnit":
1030 if obj.getElementName() == "ReadUnit":
1024 return obj
1031 return obj
1025
1032
1026 return None
1033 return None
1027
1034
1028 def getProcUnitObj(self, id=None, name=None):
1035 def getProcUnitObj(self, id=None, name=None):
1029
1036
1030 if id != None:
1037 if id != None:
1031 return self.procUnitConfObjDict[id]
1038 return self.procUnitConfObjDict[id]
1032
1039
1033 if name != None:
1040 if name != None:
1034 return self.getProcUnitObjByName(name)
1041 return self.getProcUnitObjByName(name)
1035
1042
1036 return None
1043 return None
1037
1044
1038 def getProcUnitObjByName(self, name):
1045 def getProcUnitObjByName(self, name):
1039
1046
1040 for obj in self.procUnitConfObjDict.values():
1047 for obj in self.procUnitConfObjDict.values():
1041 if obj.name == name:
1048 if obj.name == name:
1042 return obj
1049 return obj
1043
1050
1044 return None
1051 return None
1045
1052
1046 def procUnitItems(self):
1053 def procUnitItems(self):
1047
1054
1048 return self.procUnitConfObjDict.items()
1055 return self.procUnitConfObjDict.items()
1049
1056
1050 def makeXml(self):
1057 def makeXml(self):
1051
1058
1052 projectElement = Element('Project')
1059 projectElement = Element('Project')
1053 projectElement.set('id', str(self.id))
1060 projectElement.set('id', str(self.id))
1054 projectElement.set('name', self.name)
1061 projectElement.set('name', self.name)
1055 projectElement.set('description', self.description)
1062 projectElement.set('description', self.description)
1056
1063
1057 for procUnitConfObj in self.procUnitConfObjDict.values():
1064 for procUnitConfObj in self.procUnitConfObjDict.values():
1058 procUnitConfObj.makeXml(projectElement)
1065 procUnitConfObj.makeXml(projectElement)
1059
1066
1060 self.projectElement = projectElement
1067 self.projectElement = projectElement
1061
1068
1062 def writeXml(self, filename=None):
1069 def writeXml(self, filename=None):
1063
1070
1064 if filename == None:
1071 if filename == None:
1065 if self.filename:
1072 if self.filename:
1066 filename = self.filename
1073 filename = self.filename
1067 else:
1074 else:
1068 filename = "schain.xml"
1075 filename = "schain.xml"
1069
1076
1070 if not filename:
1077 if not filename:
1071 print "filename has not been defined. Use setFilename(filename) for do it."
1078 print "filename has not been defined. Use setFilename(filename) for do it."
1072 return 0
1079 return 0
1073
1080
1074 abs_file = os.path.abspath(filename)
1081 abs_file = os.path.abspath(filename)
1075
1082
1076 if not os.access(os.path.dirname(abs_file), os.W_OK):
1083 if not os.access(os.path.dirname(abs_file), os.W_OK):
1077 print "No write permission on %s" %os.path.dirname(abs_file)
1084 print "No write permission on %s" %os.path.dirname(abs_file)
1078 return 0
1085 return 0
1079
1086
1080 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
1087 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
1081 print "File %s already exists and it could not be overwriten" %abs_file
1088 print "File %s already exists and it could not be overwriten" %abs_file
1082 return 0
1089 return 0
1083
1090
1084 self.makeXml()
1091 self.makeXml()
1085
1092
1086 ElementTree(self.projectElement).write(abs_file, method='xml')
1093 ElementTree(self.projectElement).write(abs_file, method='xml')
1087
1094
1088 self.filename = abs_file
1095 self.filename = abs_file
1089
1096
1090 return 1
1097 return 1
1091
1098
1092 def readXml(self, filename = None):
1099 def readXml(self, filename = None):
1093
1100
1094 if not filename:
1101 if not filename:
1095 print "filename is not defined"
1102 print "filename is not defined"
1096 return 0
1103 return 0
1097
1104
1098 abs_file = os.path.abspath(filename)
1105 abs_file = os.path.abspath(filename)
1099
1106
1100 if not os.path.isfile(abs_file):
1107 if not os.path.isfile(abs_file):
1101 print "%s file does not exist" %abs_file
1108 print "%s file does not exist" %abs_file
1102 return 0
1109 return 0
1103
1110
1104 self.projectElement = None
1111 self.projectElement = None
1105 self.procUnitConfObjDict = {}
1112 self.procUnitConfObjDict = {}
1106
1113
1107 try:
1114 try:
1108 self.projectElement = ElementTree().parse(abs_file)
1115 self.projectElement = ElementTree().parse(abs_file)
1109 except:
1116 except:
1110 print "Error reading %s, verify file format" %filename
1117 print "Error reading %s, verify file format" %filename
1111 return 0
1118 return 0
1112
1119
1113 self.project = self.projectElement.tag
1120 self.project = self.projectElement.tag
1114
1121
1115 self.id = self.projectElement.get('id')
1122 self.id = self.projectElement.get('id')
1116 self.name = self.projectElement.get('name')
1123 self.name = self.projectElement.get('name')
1117 self.description = self.projectElement.get('description')
1124 self.description = self.projectElement.get('description')
1118
1125
1119 readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
1126 readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
1120
1127
1121 for readUnitElement in readUnitElementList:
1128 for readUnitElement in readUnitElementList:
1122 readUnitConfObj = ReadUnitConf()
1129 readUnitConfObj = ReadUnitConf()
1123 readUnitConfObj.readXml(readUnitElement)
1130 readUnitConfObj.readXml(readUnitElement)
1124
1131
1125 if readUnitConfObj.parentId == None:
1132 if readUnitConfObj.parentId == None:
1126 readUnitConfObj.parentId = self.id
1133 readUnitConfObj.parentId = self.id
1127
1134
1128 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
1135 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
1129
1136
1130 procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
1137 procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
1131
1138
1132 for procUnitElement in procUnitElementList:
1139 for procUnitElement in procUnitElementList:
1133 procUnitConfObj = ProcUnitConf()
1140 procUnitConfObj = ProcUnitConf()
1134 procUnitConfObj.readXml(procUnitElement)
1141 procUnitConfObj.readXml(procUnitElement)
1135
1142
1136 if procUnitConfObj.parentId == None:
1143 if procUnitConfObj.parentId == None:
1137 procUnitConfObj.parentId = self.id
1144 procUnitConfObj.parentId = self.id
1138
1145
1139 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1146 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1140
1147
1141 self.filename = abs_file
1148 self.filename = abs_file
1142
1149
1143 return 1
1150 return 1
1144
1151
1145 def printattr(self):
1152 def printattr(self):
1146
1153
1147 print "Project[%s]: name = %s, description = %s" %(self.id,
1154 print "Project[%s]: name = %s, description = %s" %(self.id,
1148 self.name,
1155 self.name,
1149 self.description)
1156 self.description)
1150
1157
1151 for procUnitConfObj in self.procUnitConfObjDict.values():
1158 for procUnitConfObj in self.procUnitConfObjDict.values():
1152 procUnitConfObj.printattr()
1159 procUnitConfObj.printattr()
1153
1160
1154 def createObjects(self):
1161 def createObjects(self):
1155
1162
1156 for procUnitConfObj in self.procUnitConfObjDict.values():
1163 for procUnitConfObj in self.procUnitConfObjDict.values():
1157 procUnitConfObj.createObjects(self.plotterQueue)
1164 procUnitConfObj.createObjects(self.plotterQueue)
1158
1165
1159 def __connect(self, objIN, thisObj):
1166 def __connect(self, objIN, thisObj):
1160
1167
1161 thisObj.setInput(objIN.getOutputObj())
1168 thisObj.setInput(objIN.getOutputObj())
1162
1169
1163 def connectObjects(self):
1170 def connectObjects(self):
1164
1171
1165 for thisPUConfObj in self.procUnitConfObjDict.values():
1172 for thisPUConfObj in self.procUnitConfObjDict.values():
1166
1173
1167 inputId = thisPUConfObj.getInputId()
1174 inputId = thisPUConfObj.getInputId()
1168
1175
1169 if int(inputId) == 0:
1176 if int(inputId) == 0:
1170 continue
1177 continue
1171
1178
1172 #Get input object
1179 #Get input object
1173 puConfINObj = self.procUnitConfObjDict[inputId]
1180 puConfINObj = self.procUnitConfObjDict[inputId]
1174 puObjIN = puConfINObj.getProcUnitObj()
1181 puObjIN = puConfINObj.getProcUnitObj()
1175
1182
1176 #Get current object
1183 #Get current object
1177 thisPUObj = thisPUConfObj.getProcUnitObj()
1184 thisPUObj = thisPUConfObj.getProcUnitObj()
1178
1185
1179 self.__connect(puObjIN, thisPUObj)
1186 self.__connect(puObjIN, thisPUObj)
1180
1187
1181 def __handleError(self, procUnitConfObj, send_email=True):
1188 def __handleError(self, procUnitConfObj, send_email=True):
1182
1189
1183 import socket
1190 import socket
1184
1191
1185 err = traceback.format_exception(sys.exc_info()[0],
1192 err = traceback.format_exception(sys.exc_info()[0],
1186 sys.exc_info()[1],
1193 sys.exc_info()[1],
1187 sys.exc_info()[2])
1194 sys.exc_info()[2])
1188
1195
1189 print "***** Error occurred in %s *****" %(procUnitConfObj.name)
1196 print "***** Error occurred in %s *****" %(procUnitConfObj.name)
1190 print "***** %s" %err[-1]
1197 print "***** %s" %err[-1]
1191
1198
1192 message = "".join(err)
1199 message = "".join(err)
1193
1200
1194 sys.stderr.write(message)
1201 sys.stderr.write(message)
1195
1202
1196 if not send_email:
1203 if not send_email:
1197 return
1204 return
1198
1205
1199 subject = "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
1206 subject = "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
1200
1207
1201 subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
1208 subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
1202 subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
1209 subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
1203 subtitle += "Working directory: %s\n" %os.path.abspath("./")
1210 subtitle += "Working directory: %s\n" %os.path.abspath("./")
1204 subtitle += "Configuration file: %s\n" %self.filename
1211 subtitle += "Configuration file: %s\n" %self.filename
1205 subtitle += "Time: %s\n" %str(datetime.datetime.now())
1212 subtitle += "Time: %s\n" %str(datetime.datetime.now())
1206
1213
1207 readUnitConfObj = self.getReadUnitObj()
1214 readUnitConfObj = self.getReadUnitObj()
1208 if readUnitConfObj:
1215 if readUnitConfObj:
1209 subtitle += "\nInput parameters:\n"
1216 subtitle += "\nInput parameters:\n"
1210 subtitle += "[Data path = %s]\n" %readUnitConfObj.path
1217 subtitle += "[Data path = %s]\n" %readUnitConfObj.path
1211 subtitle += "[Data type = %s]\n" %readUnitConfObj.datatype
1218 subtitle += "[Data type = %s]\n" %readUnitConfObj.datatype
1212 subtitle += "[Start date = %s]\n" %readUnitConfObj.startDate
1219 subtitle += "[Start date = %s]\n" %readUnitConfObj.startDate
1213 subtitle += "[End date = %s]\n" %readUnitConfObj.endDate
1220 subtitle += "[End date = %s]\n" %readUnitConfObj.endDate
1214 subtitle += "[Start time = %s]\n" %readUnitConfObj.startTime
1221 subtitle += "[Start time = %s]\n" %readUnitConfObj.startTime
1215 subtitle += "[End time = %s]\n" %readUnitConfObj.endTime
1222 subtitle += "[End time = %s]\n" %readUnitConfObj.endTime
1216
1223
1217 adminObj = schainpy.admin.SchainNotify()
1224 adminObj = schainpy.admin.SchainNotify()
1218 adminObj.sendAlert(message=message,
1225 adminObj.sendAlert(message=message,
1219 subject=subject,
1226 subject=subject,
1220 subtitle=subtitle,
1227 subtitle=subtitle,
1221 filename=self.filename)
1228 filename=self.filename)
1222
1229
1223 def isPaused(self):
1230 def isPaused(self):
1224 return 0
1231 return 0
1225
1232
1226 def isStopped(self):
1233 def isStopped(self):
1227 return 0
1234 return 0
1228
1235
1229 def runController(self):
1236 def runController(self):
1230 """
1237 """
1231 returns 0 when this process has been stopped, 1 otherwise
1238 returns 0 when this process has been stopped, 1 otherwise
1232 """
1239 """
1233
1240
1234 if self.isPaused():
1241 if self.isPaused():
1235 print "Process suspended"
1242 print "Process suspended"
1236
1243
1237 while True:
1244 while True:
1238 sleep(0.1)
1245 sleep(0.1)
1239
1246
1240 if not self.isPaused():
1247 if not self.isPaused():
1241 break
1248 break
1242
1249
1243 if self.isStopped():
1250 if self.isStopped():
1244 break
1251 break
1245
1252
1246 print "Process reinitialized"
1253 print "Process reinitialized"
1247
1254
1248 if self.isStopped():
1255 if self.isStopped():
1249 print "Process stopped"
1256 print "Process stopped"
1250 return 0
1257 return 0
1251
1258
1252 return 1
1259 return 1
1253
1260
1254 def setFilename(self, filename):
1261 def setFilename(self, filename):
1255
1262
1256 self.filename = filename
1263 self.filename = filename
1257
1264
1258 def setPlotterQueue(self, plotter_queue):
1265 def setPlotterQueue(self, plotter_queue):
1259
1266
1260 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1267 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1261
1268
1262 def getPlotterQueue(self):
1269 def getPlotterQueue(self):
1263
1270
1264 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1271 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1265
1272
1266 def useExternalPlotter(self):
1273 def useExternalPlotter(self):
1267
1274
1268 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1275 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1269
1276
1270
1277
1271 def run(self, filename=None):
1278 def run(self, filename=None):
1272
1279
1273 # self.writeXml(filename)
1280 # self.writeXml(filename)
1274 self.createObjects()
1281 self.createObjects()
1275 self.connectObjects()
1282 self.connectObjects()
1276
1283
1277 print
1284 print
1278 print "*"*60
1285 print "*"*60
1279 print " Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
1286 print " Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
1280 print "*"*60
1287 print "*"*60
1281 print
1288 print
1282
1289
1283 keyList = self.procUnitConfObjDict.keys()
1290 keyList = self.procUnitConfObjDict.keys()
1284 keyList.sort()
1291 keyList.sort()
1285
1292
1286 while(True):
1293 while(True):
1287
1294
1288 is_ok = False
1295 is_ok = False
1289
1296
1290 for procKey in keyList:
1297 for procKey in keyList:
1291 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
1298 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
1292
1299
1293 procUnitConfObj = self.procUnitConfObjDict[procKey]
1300 procUnitConfObj = self.procUnitConfObjDict[procKey]
1294
1301
1295 try:
1302 try:
1296 sts = procUnitConfObj.run()
1303 sts = procUnitConfObj.run()
1297 is_ok = is_ok or sts
1304 is_ok = is_ok or sts
1298 except KeyboardInterrupt:
1305 except KeyboardInterrupt:
1299 is_ok = False
1306 is_ok = False
1300 break
1307 break
1301 except ValueError, e:
1308 except ValueError, e:
1302 sleep(0.5)
1309 sleep(0.5)
1303 self.__handleError(procUnitConfObj, send_email=True)
1310 self.__handleError(procUnitConfObj, send_email=True)
1304 is_ok = False
1311 is_ok = False
1305 break
1312 break
1306 except:
1313 except:
1307 sleep(0.5)
1314 sleep(0.5)
1308 self.__handleError(procUnitConfObj)
1315 self.__handleError(procUnitConfObj)
1309 is_ok = False
1316 is_ok = False
1310 break
1317 break
1311
1318
1312 #If every process unit finished so end process
1319 #If every process unit finished so end process
1313 if not(is_ok):
1320 if not(is_ok):
1314 # print "Every process unit have finished"
1321 # print "Every process unit have finished"
1315 break
1322 break
1316
1323
1317 if not self.runController():
1324 if not self.runController():
1318 break
1325 break
1319
1326
1320 #Closing every process
1327 #Closing every process
1321 for procKey in keyList:
1328 for procKey in keyList:
1322 procUnitConfObj = self.procUnitConfObjDict[procKey]
1329 procUnitConfObj = self.procUnitConfObjDict[procKey]
1323 procUnitConfObj.close()
1330 procUnitConfObj.close()
1324
1325 print "Process finished"
Show file before | Show file after | Hide comments
@@ -1,39 +1,59
1 """.
1 """
2 SCHAINPY - LOG
2 SCHAINPY - LOG
3 Simple helper for log standarization
3 Simple helper for log standarization
4 Usage:
4 Usage:
5 from schainpy.utils import log
5 from schainpy.utils import log
6 log.error('A kitten died beacuse of you')
6 log.error('A kitten died beacuse of you')
7 log.warning('You are doing it wrong but what the heck, I'll allow it)
7 log.warning('You are doing it wrong but what the heck, I'll allow it)
8 log.succes('YOU ROCK!')
8 log.succes('YOU ROCK!')
9 To create your own logger inside your class do it like this:
9 To create your own logger inside your class do it like this:
10 from schainpy.utils import log
10 from schainpy.utils import log
11 awesomeLogger = log.makelogger("never gonna", bg="red", fg="white")
11 awesomeLogger = log.makelogger("never gonna", bg="red", fg="white")
12 awesomeLogger('give you up')
12 awesomeLogger('give you up')
13 which will look like this:
13 which will look like this:
14 [NEVER GONNA] - give you up
14 [NEVER GONNA] - give you up
15 with color red as background and white as foreground.
15 with color red as background and white as foreground.
16 """
16 """
17
17 import os
18 import sys
18 import click
19 import click
19
20
20 def warning(message):
21 def warning(message):
21 click.echo(click.style('[WARNING] - ' + message, fg='yellow'))
22 click.echo(click.style('[WARNING] - ' + message, fg='yellow'))
22
23
23
24
24 def error(message):
25 def error(message):
25 click.echo(click.style('[ERROR] - ' + message, fg='red', bg='black'))
26 click.echo(click.style('[ERROR] - ' + message, fg='red', bg='black'))
26
27
27
28
28 def success(message):
29 def success(message):
29 click.echo(click.style(message, fg='green'))
30 click.echo(click.style(message, fg='green'))
30
31
31
32
32 def log(message, topic='LOG'):
33 def log(message, topic='LOG'):
33 click.echo('[{}] - {}'.format(topic, message))
34 click.echo('[{}] - {}'.format(topic, message))
34
35
35 def makelogger(topic, bg='reset', fg='reset'):
36 def makelogger(topic, bg='reset', fg='reset'):
36 def func(message):
37 def func(message):
37 click.echo(click.style('[{}] - '.format(topic.upper()) + message,
38 click.echo(click.style('[{}] - '.format(topic.upper()) + message,
38 bg=bg, fg=fg))
39 bg=bg, fg=fg))
39 return func
40 return func
41
42 class LoggerForFile():
43 def __init__(self, filename):
44 self.old_stdout=sys.stdout
45 cwd = os.getcwd()
46 self.log_file = open(os.path.join(cwd, filename), 'w+')
47 def write(self, text):
48 text = text.rstrip()
49 if not text:
50 return
51 self.log_file.write(text + '\n')
52 self.old_stdout.write(text + '\n')
53 def flush(self):
54 self.old_stdout.flush()
55
56 def logToFile(filename='log.log'):
57 logger = LoggerForFile(filename)
58 sys.stdout = logger
59
General Comments 0
You need to be logged in to leave comments. Login now