schain Commit - r681:a13b962c6023 · Jicamarca Repository

Miguel Valdez -

r681:a13b962c6023

parent child

Context file:

r681:a13b962c6023

schainpy/admin.py created 644 +346 0

@@ -0,0 +1,346
	1	"""The admin module contains all administrative classes relating to the schain python api.
	2
	3	The main role of this module is to send some reports. It contains a
	4	notification class and a standard error handing class.
	5
	6	$Id: admin.py 3966 2015-12-01 14:32:29Z miguel.urco $
	7	"""
	8	import os
	9	import smtplib
	10	import ConfigParser
	11	import StringIO
	12
	13	from email.mime.text import MIMEText
	14	from email.mime.application import MIMEApplication
	15	from email.mime.multipart import MIMEMultipart
	16
	17	class SchainConfigure():
	18
	19	__DEFAULT_SENDER_EMAIL = "notifier-schain@jro.igp.gob.pe"
	20	__DEFAULT_ADMINISTRATOR_EMAIL = "miguel.urco@jro.igp.gob.pe"
	21	__DEFAULT_EMAIL_SERVER = "jro-zimbra.igp.gob.pe"
	22
	23	__SCHAIN_ADMINISTRATOR_EMAIL = "CONTACT"
	24	__SCHAIN_EMAIL_SERVER = "MAILSERVER"
	25	__SCHAIN_SENDER_EMAIL = "MAILSERVER_ACCOUNT"
	26
	27	def __init__(self, initFile = None):
	28
	29	# Set configuration file
	30	if (initFile == None):
	31	self.__confFilePath = "/etc/schain.conf"
	32	else:
	33	self.__confFilePath = initFile
	34
	35	# open configuration file
	36	try:
	37	self.__confFile = open(self.__confFilePath, "r")
	38	except IOError:
	39	# can't read from file - use all hard-coded values
	40	self.__initFromHardCode()
	41	return
	42
	43	# create Parser using standard module ConfigParser
	44	self.__parser = ConfigParser.ConfigParser()
	45
	46	# read conf file into a StringIO with "[madrigal]\n" section heading prepended
	47	strConfFile = StringIO.StringIO("[schain]\n" + self.__confFile.read())
	48
	49	# parse StringIO configuration file
	50	self.__parser.readfp(strConfFile)
	51
	52	# read information from configuration file
	53	self.__readConfFile()
	54
	55	# close conf file
	56	self.__confFile.close()
	57
	58
	59	def __initFromHardCode(self):
	60
	61	self.__sender_email = self.__DEFAULT_SENDER_EMAIL
	62	self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
	63	self.__email_server = self.__DEFAULT_EMAIL_SERVER
	64
	65	def __readConfFile(self):
	66	"""__readConfFile is a private helper function that reads information from the parsed config file.
	67
	68	Inputs: None
	69
	70	Returns: Void.
	71
	72	Affects: Initializes class member variables that are found in the config file.
	73
	74	Exceptions: MadrigalError thrown if any key not found.
	75	"""
	76
	77	# get the sender email
	78	try:
	79	self.__sender_email = self.__parser.get("schain", self.__SCHAIN_SENDER_EMAIL)
	80	except:
	81	self.__sender_email = self.__DEFAULT_SENDER_EMAIL
	82
	83	# get the administrator email
	84	try:
	85	self.__admin_email = self.__parser.get("schain", self.__SCHAIN_ADMINISTRATOR_EMAIL)
	86	except:
	87	self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
	88
	89	# get the server email
	90	try:
	91	self.__email_server = self.__parser.get("schain", self.__SCHAIN_EMAIL_SERVER)
	92	except:
	93	self.__email_server = self.__DEFAULT_EMAIL_SERVER
	94
	95	def getEmailServer(self):
	96
	97	return self.__email_server
	98
	99	def getSenderEmail(self):
	100
	101	return self.__sender_email
	102
	103	def getAdminEmail(self):
	104
	105	return self.__admin_email
	106
	107	class SchainNotify:
	108	"""SchainNotify is an object used to send messages to an administrator about a Schain software.
	109
	110	This object provides functions needed to send messages to an administrator about a Schain , for now
	111	only sendAlert, which sends an email to the site administrator found is ADMIN_EMAIL
	112
	113	Usage example:
	114
	115	import schainpy.admin
	116
	117	try:
	118
	119	adminObj = schainpy.admin.SchainNotify()
	120	adminObj.sendAlert('This is important!', 'Important Message')
	121
	122	except schainpy.admin.SchainError, e:
	123
	124	print e.getExceptionStr()
	125
	126
	127	Non-standard Python modules used:
	128	None
	129
	130	Exceptions thrown: None - Note that SchainNotify tries every trick it knows to avoid
	131	throwing exceptions, since this is the class that will generally be called when there is a problem.
	132
	133	Change history:
	134
	135	Written by "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe Dec. 1, 2015
	136	"""
	137
	138	#constants
	139
	140	def __init__(self):
	141	"""__init__ initializes SchainNotify by getting some basic information from SchainDB and SchainSite.
	142
	143	Note that SchainNotify tries every trick it knows to avoid throwing exceptions, since
	144	this is the class that will generally be called when there is a problem.
	145
	146	Inputs: Existing SchainDB object, by default = None.
	147
	148	Returns: void
	149
	150	Affects: Initializes self.__binDir.
	151
	152	Exceptions: None.
	153	"""
	154
	155	# note that the main configuration file is unavailable
	156	# the best that can be done is send an email to root using localhost mailserver
	157	confObj = SchainConfigure()
	158
	159	self.__emailFromAddress = confObj.getSenderEmail()
	160	self.__emailToAddress = confObj.getAdminEmail()
	161	self.__emailServer = confObj.getEmailServer()
	162
	163	def sendEmail(self, email_from, email_to, subject='Error running ...', message="", subtitle="", filename="", html_format=True):
	164
	165	msg = MIMEMultipart()
	166	msg['Subject'] = subject
	167	msg['From'] = "(Python SChain API): " + email_from
	168	msg['Reply-to'] = email_from
	169	msg['To'] = email_to
	170
	171	# That is what u see if dont have an email reader:
	172	msg.preamble = 'SChainPy'
	173
	174	if html_format:
	175	message = "<h1> %s </h1>" %subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
	176	message = "<html>\n" + message + '</html>'
	177
	178	# This is the textual part:
	179	part = MIMEText(message, "html")
	180	else:
	181	message = subject + "\n" + subtitle + "\n" + message
	182	part = MIMEText(message)
	183
	184	msg.attach(part)
	185
	186	if os.path.isfile(filename):
	187	# This is the binary part(The Attachment):
	188	part = MIMEApplication(open(filename,"rb").read())
	189	part.add_header('Content-Disposition',
	190	'attachment',
	191	filename=os.path.basename(filename))
	192	msg.attach(part)
	193
	194	# Create an instance in SMTP server
	195	smtp = smtplib.SMTP(self.__emailServer)
	196	# Start the server:
	197	# smtp.ehlo()
	198	# smtp.login(email_from, email_from_pass)
	199
	200	# Send the email
	201	smtp.sendmail(msg['From'], msg['To'], msg.as_string())
	202	smtp.quit()
	203
	204
	205	def sendAlert(self, message, subject = "", subtitle="", filename=""):
	206	"""sendAlert sends an email with the given message and optional title.
	207
	208	Inputs: message (string), and optional title (string)
	209
	210	Returns: void
	211
	212	Affects: none
	213
	214	Exceptions: None.
	215	"""
	216	print "*** Sending alert to %s ***" %self.__emailToAddress
	217	# set up message
	218
	219	self.sendEmail(email_from=self.__emailFromAddress,
	220	email_to=self.__emailToAddress,
	221	subject=subject,
	222	message=message,
	223	subtitle=subtitle,
	224	filename=filename)
	225
	226	print "*** Your system administrator has been notified ***"
	227
	228
	229	def notify(self, email, message, subject = "", subtitle="", filename=""):
	230	"""notify sends an email with the given message and title to email.
	231
	232	Inputs: email (string), message (string), and subject (string)
	233
	234	Returns: void
	235
	236	Affects: none
	237
	238	Exceptions: None.
	239	"""
	240
	241	print "Notifying to %s ..." %email
	242
	243	self.sendEmail(email_from=self.__emailFromAddress,
	244	email_to=email,
	245	subject=subject,
	246	message=message,
	247	subtitle=subtitle,
	248	filename=filename)
	249
	250	print "*** Your system administrator has been notified ***"
	251
	252	class SchainError:
	253	"""SchainError is an exception class that is thrown for all known errors in using Schain Py lib.
	254
	255	Usage example:
	256
	257	import sys, traceback
	258	import schainpy.admin
	259
	260	try:
	261
	262	test = open('ImportantFile.txt', 'r')
	263
	264	except:
	265
	266	raise schainpy.admin.SchainError('ImportantFile.txt not opened!',
	267	traceback.format_exception(sys.exc_info()[0],
	268	sys.exc_info()[1],
	269	sys.exc_info()[2]))
	270	"""
	271
	272
	273	def __init__(self, strInterpretation, exceptionList):
	274	""" __init__ gathers the interpretation string along with all information from sys.exc_info().
	275
	276	Inputs: strIntepretation - A string representing the programmer's interpretation of
	277	why the exception occurred
	278
	279	exceptionList - a list of strings completely describing the exception.
	280	Generated by traceback.format_exception(sys.exc_info()[0],
	281	sys.exc_info()[1],
	282	sys.exc_info()[2])
	283
	284	Returns: Void.
	285
	286	Affects: Initializes class member variables _strInterp, _strExcList.
	287
	288	Exceptions: None.
	289	"""
	290
	291	self._strInterp = strInterpretation
	292	self._strExcList = exceptionList
	293
	294
	295	def getExceptionStr(self):
	296	""" getExceptionStr returns a formatted string ready for printing completely describing the exception.
	297
	298	Inputs: None
	299
	300	Returns: A formatted string ready for printing completely describing the exception.
	301
	302	Affects: None
	303
	304	Exceptions: None.
	305	"""
	306	excStr = 'The following Schain Python exception has occurred:\n'
	307	excStr = excStr + self._strInterp + '\n\n'
	308
	309	if self._strExcList != None:
	310	for item in self._strExcList:
	311	excStr = excStr + str(item) + '\n'
	312
	313	return excStr
	314
	315	def __str__(self):
	316	return(self.getExceptionStr())
	317
	318
	319	def getExceptionHtml(self):
	320	""" getExceptionHtml returns an Html formatted string completely describing the exception.
	321
	322	Inputs: None
	323
	324	Returns: A formatted string ready for printing completely describing the exception.
	325
	326	Affects: None
	327
	328	Exceptions: None.
	329	"""
	330
	331	excStr = '<BR>The following Schain Python exception has occurred:\n<BR>'
	332	excStr = excStr + self._strInterp + '\n<BR>\n'
	333
	334	if self._strExcList != None:
	335	for item in self._strExcList:
	336	excStr = excStr + str(item) + '\n<BR>'
	337
	338	return excStr
	339
	340	if __name__ == '__main__':
	341
	342	test = SchainNotify()
	343
	344	test.sendAlert('This is a message from the python module SchainNotify', 'Test from SchainNotify')
	345
	346	print 'Hopefully message sent - check.'

schainpy/schain.conf.template created 644 +5 0

@@ -0,0 +1,5
	1	#Copy this file to /etc/schain.conf
	2	[schain]
	3	CONTACT = miguel.urco@jro.igp.gob.pe
	4	MAILSERVER = jro-zimbra.igp.gob.pe
	5	MALSERVER_ACCOUNT = notifier-schain@jro.igp.gob.pe No newline at end of file

schainpy/VERSION +4 -1

             VERSIONS:
 .1.2:
             -jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
             				  Server thread opens and closes remote server each time file list is sent
             -jroplot_spectra.py: Noise path was not being created saving noise data.
             -jroIO_base.py: startTime can be greater than endTime
 .1.3:
             -jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
             -jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
             					 Bug fixed selecting heights by block (selecting profiles instead heights)
             -jroproc_voltage.py: New feature added: decoding data by block using FFT.
             -jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits object instead schainpy.mode.data.jrodata.Fits object.
             -jroIO_heispectra.py: Channel index list does not exist.
 .1.3.1:
             -GUI: every icon were resized
             -jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
 .1.3.2:
             -GUI: user interaction enhanced
             -controller_api.py: Safe access to ControllerThead
 .1.3.3:
-            -Colored Button Icons were added to GUI
  No newline at end of file
+            -Colored Button Icons were added to GUI
+.1.4:
+            -Sending error notifications to signal chain administrator
  No newline at end of file

schainpy/__init__.py +1 -1

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
-            __version__ = "2.1.3.3"
  No newline at end of file
+            __version__ = "2.1.4"
  No newline at end of file

schainpy/controller.py +104 -48

             '''
             Created on September , 2012
             @author:
             '''
-            from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
-            from xml.dom import minidom
-            from model import *
-            from time import sleep
             import sys
             import ast
             import traceback
+            import schainpy
+            import schainpy.admin
-            SCHAIN_MAIL = "miguel.urco@jro.igp.gob.pe"
+            from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
-            EMAIL_SERVER = "jro.igp.gob.pe"
+            from xml.dom import minidom
+            from schainpy.model import *
+            from time import sleep
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
                 rough_string = tostring(elem, 'utf-8')
                 reparsed = minidom.parseString(rough_string)
                 return reparsed.toprettyxml(indent="  ")
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError, "%s: This parameter value is empty" %self.name
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         """
                         Example:
                             value = (0,1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(float(x)) for x in strList]
                         self.__formated_value = intList
                         return self.__formated_value
                     if format == 'floatlist':
                         """
                         Example:
                             value = (0.5, 1.4, 2.7)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         floatList = [float(x) for x in strList]
                         self.__formated_value = floatList
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         """
                         Example:
                             value = (0,1),(1,2)
                         """
                         value = value.replace('(', '')
                         value = value.replace(')', '')
                         value = value.replace('[', '')
                         value = value.replace(']', '')
                         strList = value.split(',')
                         intList = [int(item) for item in strList]
                         pairList = []
                         for i in range(len(intList)/2):
                             pairList.append((intList[i*2], intList[i*2 + 1]))
                         self.__formated_value = pairList
                         return self.__formated_value
                     if format == 'multilist':
                         """
                         Example:
                             value = (0,1,2),(3,4,5)
                         """
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval("(" + value + ")")
                         self.__formated_value = multiList
                         return self.__formated_value
                     if format == 'bool':
                         value = int(value)
                     if format == 'int':
                         value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     self.value = str(value)
                     self.format = str.lower(format)
                     try:
                         self.getValue()
                     except:
                         return 0
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     parmElement = SubElement(opElement, self.ELEMENTNAME)
                     parmElement.set('id', str(self.id))
                     parmElement.set('name', self.name)
                     parmElement.set('value', self.value)
                     parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     #Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
             class OperationConf():
                 id = None
                 name = None
                 priority = None
                 type = None
                 parmConfObjList = []
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.type = 'self'
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.parmConfObjList) + 1
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id)*10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
             #         if not parameterObj:
             #             return None
                     value = parameterObj.getValue()
                     return value
                 def setup(self, id, name, priority, type):
                     self.id = str(id)
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
-                def makeXml(self, upElement):
+                def makeXml(self, procUnitElement):
-                    opElement = SubElement(upElement, self.ELEMENTNAME)
+                    opElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     #Compatible with old signal chain version
                     #Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         #Compatible with old signal chain version
                         #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
                                                                           self.id,
                                                                           self.name,
                                                                           self.type,
                                                                           self.priority)
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         opObj = className()
                     return opObj
             class ProcUnitConf():
                 id = None
                 name = None
                 datatype = None
                 inputId = None
                 parentId = None
                 opConfObjList = []
                 procUnitObj = None
                 opObjList = []
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList)+1
                 def __getNewId(self):
                     return int(self.id)*10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id, parentId=parentId):
                     new_id = int(parentId)*10 + (int(self.id) % 10)
                     new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
                     #If this proc unit has not inputs
                     if self.inputId == '0':
                         new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id)*10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     self.inputId = str(new_inputId)
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, id, name, datatype, inputId, parentId=None):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Proc','')
                     self.id = str(id)
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.parentId = parentId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to "run" operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     id = self.__getNewId()
                     priority = self.__getPriority()
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
-                def makeXml(self, procUnitElement):
+                def makeXml(self, projectElement):
-                    upElement = SubElement(procUnitElement, self.ELEMENTNAME)
+                    procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
-                    upElement.set('id', str(self.id))
+                    procUnitElement.set('id', str(self.id))
-                    upElement.set('name', self.name)
+                    procUnitElement.set('name', self.name)
-                    upElement.set('datatype', self.datatype)
+                    procUnitElement.set('datatype', self.datatype)
-                    upElement.set('inputId', str(self.inputId))
+                    procUnitElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
-                        opConfObj.makeXml(upElement)
+                        opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     if self.ELEMENTNAME == "ReadUnit":
                         self.datatype = self.datatype.replace("Reader", "")
                     if self.ELEMENTNAME == "ProcUnit":
                         self.datatype = self.datatype.replace("Proc", "")
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.getiterator(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
                                                                          self.id,
                                                                          self.name,
                                                                          self.datatype,
                                                                          self.inputId)
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def createObjects(self):
                     className = eval(self.name)
                     procUnitObj = className()
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = opConfObj.createObject()
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                     self.procUnitObj = procUnitObj
                     return procUnitObj
                 def run(self):
                     is_ok = False
                     for opConfObj in self.opConfObjList:
                         kwargs = {}
                         for parmConfObj in opConfObj.getParameterObjList():
                             if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
                                 continue
                             kwargs[parmConfObj.name] = parmConfObj.getValue()
                         #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
                         sts = self.procUnitObj.call(opType = opConfObj.type,
                                                     opName = opConfObj.name,
                                                     opId = opConfObj.id,
                                                      **kwargs)
                         is_ok = is_ok or sts
                     return is_ok
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.parentId = None
                     self.opConfObjList = []
                     self.opObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.id = id
                     self.name = name
                     self.datatype = datatype
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.addRunOperation(**kwargs)
                 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
                     #Compatible with old signal chain version
                     if datatype==None and name==None:
                         raise ValueError, "datatype or name should be defined"
                     if name==None:
                         if 'Reader' in datatype:
                             name = datatype
                         else:
                             name = '%sReader' %(datatype)
                     if datatype==None:
                         datatype = name.replace('Reader','')
                     self.datatype = datatype
                     self.name = name
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.inputId = '0'
                     self.parentId = parentId
                     self.updateRunOperation(**kwargs)
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name = 'run', optype = 'self')
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name = 'run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype' , value=self.datatype, format='str')
                     opObj.addParameter(name='path'     , value=self.path, format='str')
                     opObj.addParameter(name='startDate' , value=self.startDate, format='date')
                     opObj.addParameter(name='endDate'   , value=self.endDate, format='date')
                     opObj.addParameter(name='startTime' , value=self.startTime, format='time')
                     opObj.addParameter(name='endTime'   , value=self.endTime, format='time')
                     for key, value in kwargs.items():
                         opObj.addParameter(name=key, value=value, format=type(value).__name__)
                     return opObj
+            #     def makeXml(self, projectElement):
+            #
+            #         procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
+            #         procUnitElement.set('id', str(self.id))
+            #         procUnitElement.set('name', self.name)
+            #         procUnitElement.set('datatype', self.datatype)
+            #         procUnitElement.set('inputId', str(self.inputId))
+            #
+            #         for opConfObj in self.opConfObjList:
+            #             opConfObj.makeXml(procUnitElement)
+                def readXml(self, upElement):
+                    self.id = upElement.get('id')
+                    self.name = upElement.get('name')
+                    self.datatype = upElement.get('datatype')
+                    self.inputId = upElement.get('inputId')
+                    if self.ELEMENTNAME == "ReadUnit":
+                        self.datatype = self.datatype.replace("Reader", "")
+                    if self.inputId == 'None':
+                        self.inputId = '0'
+                    self.opConfObjList = []
+                    opElementList = upElement.getiterator(OperationConf().getElementName())
+                    for opElement in opElementList:
+                        opConfObj = OperationConf()
+                        opConfObj.readXml(opElement)
+                        self.opConfObjList.append(opConfObj)
+                        if opConfObj.name == 'run':
+                            self.path = opConfObj.getParameterValue('path')
+                            self.startDate = opConfObj.getParameterValue('startDate')
+                            self.endDate = opConfObj.getParameterValue('endDate')
+                            self.startTime = opConfObj.getParameterValue('startTime')
+                            self.endTime = opConfObj.getParameterValue('endTime')
             class Project():
                 id = None
                 name = None
                 description = None
-            #    readUnitConfObjList = None
+                filename = None
                 procUnitConfObjDict = None
                 ELEMENTNAME = 'Project'
                 def __init__(self):
                     self.id = None
                     self.name = None
                     self.description = None
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id)*10 + n)
                         procUnitConfObj.updateId(idProcUnit, parentId = self.id)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id, name, description):
                     self.id = str(id)
                     self.name = name
                     self.description = description
                 def update(self, name, description):
                     self.name = name
                     self.description = description
                 def addReadUnit(self, datatype=None, name=None, **kwargs):
                     idReadUnit = self.__getNewId()
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     idProcUnit = self.__getNewId()
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in self.procUnitConfObjDict.keys():
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.getElementName() == "ReadUnit":
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in self.procUnitConfObjDict.values():
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return self.procUnitConfObjDict.items()
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename):
-                    self.makeXml()
+                    if not os.access(os.path.dirname(filename), os.W_OK):
+                        return 0
-                    #print prettify(self.projectElement)
+                    if os.path.isfile(filename) and not(os.access(filename, os.W_OK)):
+                        return 0
+                    self.makeXml()
                     ElementTree(self.projectElement).write(filename, method='xml')
+                    self.filename = filename
+                    return 1
                 def readXml(self, filename):
+                    if not os.path.isfile(filename):
+                        print "%s does not exist" %filename
+                        return 0
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement)
                         if readUnitConfObj.parentId == None:
                             readUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement)
                         if procUnitConfObj.parentId == None:
                             procUnitConfObj.parentId = self.id
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
+                    return 1
                 def printattr(self):
                     print "Project[%s]: name = %s, description = %s" %(self.id,
                                                                           self.name,
                                                                           self.description)
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.printattr()
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects()
                 def __connect(self, objIN, thisObj):
                     thisObj.setInput(objIN.getOutputObj())
                 def connectObjects(self):
                     for thisPUConfObj in self.procUnitConfObjDict.values():
                         inputId = thisPUConfObj.getInputId()
                         if int(inputId) == 0:
                             continue
                         #Get input object
                         puConfINObj = self.procUnitConfObjDict[inputId]
                         puObjIN = puConfINObj.getProcUnitObj()
                         #Get current object
                         thisPUObj = thisPUConfObj.getProcUnitObj()
                         self.__connect(puObjIN, thisPUObj)
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
                     """
                     returns 0 when this process has been stopped, 1 otherwise
                     """
                     if self.isPaused():
                         print "Process suspended"
                         while True:
                             sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
                         print "Process reinitialized"
                     if self.isStopped():
                         print "Process stopped"
                         return 0
                     return 1
                 def run(self):
                     print
                     print "*"*60
-                    print "   Starting SIGNAL CHAIN PROCESSING  "
+                    print "   Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
                     print "*"*60
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         is_ok = False
                         for procKey in keyList:
             #                 print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
                             procUnitConfObj = self.procUnitConfObjDict[procKey]
-                            message = ""
                             try:
                                 sts = procUnitConfObj.run()
                                 is_ok = is_ok or sts
                             except:
-                                print "***** Error running %s *****" %procUnitConfObj.name
+                                print "***** Error occurred in %s *****" %(procUnitConfObj.name)
-                                sleep(1)
+                                sleep(0.5)
                                 err = traceback.format_exception(sys.exc_info()[0],
                                                                  sys.exc_info()[1],
                                                                  sys.exc_info()[2])
-                                for thisLine in err:
+                                import socket
-                                    message += thisLine
+                                subject =  "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
+                                subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
+                                subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
+                                subtitle += "Working directory: %s\n" %os.path.abspath("./")
+                                subtitle += "Configuration file: %s\n" %self.filename
+                                readUnitConfObj = self.getReadUnitObj()
+                                if readUnitConfObj:
+                                    subtitle += "Data path: %s\n" %readUnitConfObj.path
+                                    subtitle += "Data type: %s\n" %readUnitConfObj.datatype
+                                    subtitle += "Start date: %s\n" %readUnitConfObj.startDate
+                                    subtitle += "End date: %s\n" %readUnitConfObj.endDate
+                                    subtitle += "Start time: %s\n" %readUnitConfObj.startTime
+                                    subtitle += "End time: %s\n" %readUnitConfObj.endTime
+                                message = "".join(err)
                                 sys.stderr.write(message)
-            #                     print "*"*60
-            #                     print message
+                                adminObj = schainpy.admin.SchainNotify()
-            #                     print "*"*60
+                                adminObj.sendAlert(message=message,
+                                                   subject=subject,
+                                                   subtitle=subtitle,
+                                                   filename=self.filename)
-            #                     self.sendReport(message)
-                                sleep(0.1)
                                 is_ok = False
                                 break
                         #If every process unit finished so end process
                         if not(is_ok):
                             print "Every process unit have finished"
                             break
                         if not self.runController():
                             break
                     #Closing every process
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         procUnitConfObj.close()
                     print "Process finished"
                 def start(self, filename):
                     self.writeXml(filename)
                     self.readXml(filename)
                     self.createObjects()
                     self.connectObjects()
                     self.run()
-                def sendReport(self, message, subject="Error occurred in Signal Chain", email=SCHAIN_MAIL):
-                    import smtplib
-                    print subject
-                    print "Sending report to %s ..." %email
-                    message = 'From: (Python Signal Chain API) ' + email + '\n' + \
-                    'To: ' + email + '\n' + \
-                    'Subject: ' + str(subject) + '\n' + \
-                    'Content-type: text/html\n\n' + message
-                    server = smtplib.SMTP(EMAIL_SERVER)
-                    server.sendmail(email.split(',')[0],
-                                    email.split(','), message)
-                    server.quit()
             if __name__ == '__main__':
                 desc = "Segundo Test"
                 filename = "schain.xml"
                 controllerObj = Project()
                 controllerObj.setup(id = '191', name='test01', description=desc)
                 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
                                                             path='data/rawdata/',
                                                             startDate='2011/01/01',
                                                             endDate='2012/12/31',
                                                             startTime='00:00:00',
                                                             endTime='23:59:59',
                                                             online=1,
                                                             walk=1)
                 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
                 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
                 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
                 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
                 opObj10.addParameter(name='minHei', value='90', format='float')
                 opObj10.addParameter(name='maxHei', value='180', format='float')
                 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
                 opObj12.addParameter(name='n', value='10', format='int')
                 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
                 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
             #    procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
                 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
                 opObj11.addParameter(name='idfigure', value='1', format='int')
                 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
                 opObj11.addParameter(name='zmin', value='40', format='int')
                 opObj11.addParameter(name='zmax', value='90', format='int')
                 opObj11.addParameter(name='showprofile', value='1', format='int')
                 print "Escribiendo el archivo XML"
                 controllerObj.writeXml(filename)
                 print "Leyendo el archivo XML"
                 controllerObj.readXml(filename)
                 #controllerObj.printattr()
                 controllerObj.createObjects()
                 controllerObj.connectObjects()
                 controllerObj.run()
   No newline at end of file

schainpy/controller_api.py +68 -68

             import threading
-            from PyQt4 import QtCore
-            from PyQt4.QtCore import SIGNAL
             from schainpy.controller import Project
             class ControllerThread(threading.Thread, Project):
                 def __init__(self, filename):
                     threading.Thread.__init__(self)
                     Project.__init__(self)
                     self.setDaemon(True)
                     self.filename = filename
                     self.lock = threading.Lock()
                     self.control = {'stop':False, 'pause':False}
                 def __del__(self):
                     self.control['stop'] = True
                 def stop(self):
                     self.lock.acquire()
                     self.control['stop'] = True
                     self.lock.release()
                 def pause(self):
                     self.lock.acquire()
                     self.control['pause'] = not(self.control['pause'])
                     paused = self.control['pause']
                     self.lock.release()
                     return paused
                 def isPaused(self):
                     self.lock.acquire()
                     paused = self.control['pause']
                     self.lock.release()
                     return paused
                 def isStopped(self):
                     self.lock.acquire()
                     stopped = self.control['stop']
                     self.lock.release()
                     return stopped
                 def run(self):
                     self.control['stop'] = False
                     self.control['pause'] = False
                     self.readXml(self.filename)
                     self.createObjects()
                     self.connectObjects()
                     Project.run(self)
                 def isRunning(self):
                     return self.is_alive()
                 def isFinished(self):
                     return not self.is_alive()
-            class ControllerQThread(QtCore.QThread, Project):
+            # from PyQt4 import QtCore
+            # from PyQt4.QtCore import SIGNAL
-                def __init__(self, filename):
+            # class ControllerQThread(QtCore.QThread, Project):
-                    QtCore.QThread.__init__(self)
-                    Project.__init__(self)
+            #     def __init__(self, filename):
+            #
-                    self.filename = filename
+            #         QtCore.QThread.__init__(self)
+            #         Project.__init__(self)
-                    self.lock = threading.Lock()
-                    self.control = {'stop':False, 'pause':False}
+            #         self.filename = filename
+            #
-                def __del__(self):
+            #         self.lock = threading.Lock()
+            #         self.control = {'stop':False, 'pause':False}
-                    self.control['stop'] = True
-                    self.wait()
+            #     def __del__(self):
+            #
-                def stop(self):
+            #         self.control['stop'] = True
+            #         self.wait()
-                    self.lock.acquire()
+            #     def stop(self):
-                    self.control['stop'] = True
+            #         self.lock.acquire()
-                    self.lock.release()
+            #         self.control['stop'] = True
-                def pause(self):
+            #         self.lock.release()
-                    self.lock.acquire()
+            #     def pause(self):
-                    self.control['pause'] = not(self.control['pause'])
-                    paused = self.control['pause']
+            #         self.lock.acquire()
+            #
-                    self.lock.release()
+            #         self.control['pause'] = not(self.control['pause'])
+            #         paused = self.control['pause']
-                    return paused
+            #         self.lock.release()
-                def isPaused(self):
+            #         return paused
-                    self.lock.acquire()
-                    paused = self.control['pause']
+            #     def isPaused(self):
-                    self.lock.release()
+            #         self.lock.acquire()
-                    return paused
+            #         paused = self.control['pause']
+            #         self.lock.release()
-                def isStopped(self):
+            #         return paused
-                    self.lock.acquire()
-                    stopped = self.control['stop']
+            #     def isStopped(self):
-                    self.lock.release()
+            #         self.lock.acquire()
-                    return stopped
+            #         stopped = self.control['stop']
+            #         self.lock.release()
-                def run(self):
+            #         return stopped
-                    self.control['stop'] = False
-                    self.control['pause'] = False
+            #     def run(self):
+            #
-                    self.readXml(self.filename)
+            #         self.control['stop'] = False
-                    self.createObjects()
+            #         self.control['pause'] = False
-                    self.connectObjects()
-                    self.emit( SIGNAL( "jobStarted( PyQt_PyObject )" ), 1)
+            #         self.readXml(self.filename)
-                    Project.run(self)
+            #         self.createObjects()
-                    self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
+            #         self.connectObjects()
-  No newline at end of file
+            #         self.emit( SIGNAL( "jobStarted( PyQt_PyObject )" ), 1)
+            #         Project.run(self)
+            #         self.emit( SIGNAL( "jobFinished( PyQt_PyObject )" ), 1)
+            #         
  No newline at end of file

setup.py +3 -1

             '''
             Created on Jul 16, 2014
             @author: roj-idl71
             '''
             from schainpy import __version__
             from setuptools import setup, Extension
             setup(name="schainpy",
                     version=__version__,
                     description="Python tools to read, write and process Jicamarca data",
                     author="Miguel Urco",
                     author_email="miguel.urco@jro.igp.gob.pe",
                     url="http://jro.igp.gob.pe",
                     packages = {'schainpy',
                                 'schainpy.model',
                                 'schainpy.model.data',
                                 'schainpy.model.graphics',
                                 'schainpy.model.io',
                                 'schainpy.model.proc',
                                 'schainpy.model.utils',
                                 'schainpy.gui',
                                 'schainpy.gui.figures',
                                 'schainpy.gui.viewcontroller',
                                 'schainpy.gui.viewer',
                                 'schainpy.gui.viewer.windows'},
                     py_modules=['schainpy.serializer.DataTranslate',
                                 'schainpy.serializer.JROSerializer'],
-                    package_data={'schainpy.gui.figures': ['*.png','*.jpg']},
+                    package_data={'schainpy': ['*.cfg'],
+                                  'schainpy.gui.figures': ['*.png','*.jpg']
+                                  },
                     include_package_data=True,
                     scripts =['schainpy/gui/schainGUI'],
                     install_requires=["numpy >= 1.6.0",
                                       "scipy >= 0.9.0",
                                       "h5py >= 2.0.1",
                                       "wxpython >= 2.8",
                                       "matplotlib >= 1.0.0"
                                       ],
                   )

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages