schain-jc Commit - r1167:1f521b07c958

Python 2to3, Spectra (all operations) working

George Yong -

r1167:1f521b07c958

parent child

Context file:

r1167:1f521b07c958

Expand all files

schainpy/__init__.py +2 -2

             '''
-            Created on Feb 7, 2012
+            Created on Jul 3, 2018
             @author $Author$
             @version $Id$
             '''
-            __version__ = '2.3'
+            __version__ = '3.0'

schainpy/admin.py +7 -7

             import time
             import traceback
             import smtplib
-            import ConfigParser
+            import configparser
-            import StringIO
+            import io
             from threading import Thread
             from multiprocessing import Process
             from email.mime.text import MIMEText
                 @staticmethod
                 def send_email(**kwargs):
                     notifier = SchainNotify()
-                    print kwargs
+                    print(kwargs)
                     notifier.notify(**kwargs)
                 @staticmethod
                         return
                     # create Parser using standard module ConfigParser
-                    self.__parser = ConfigParser.ConfigParser()
+                    self.__parser = configparser.ConfigParser()
                     # read conf file into a StringIO with "[madrigal]\n" section heading prepended
-                    strConfFile = StringIO.StringIO("[schain]\n" + self.__confFile.read())
+                    strConfFile = io.StringIO("[schain]\n" + self.__confFile.read())
                     # parse StringIO configuration file
                     self.__parser.readfp(strConfFile)
                     if not self.__emailToAddress:
                         return 0
-                    print "***** Sending alert to %s *****" %self.__emailToAddress
+                    print("***** Sending alert to %s *****" %self.__emailToAddress)
                     # set up message
                     sent=self.sendEmail(email_from=self.__emailFromAddress,
                 test.sendAlert('This is a message from the python module SchainNotify', 'Test from SchainNotify')
-                print 'Hopefully message sent - check.'
+                print('Hopefully message sent - check.')
  No newline at end of file

schainpy/controller.py +48 -48

                         for process in processes:
                             process.terminate()
                             process.join()
-                        print traceback.print_tb(trace)
+                        print(traceback.print_tb(trace))
                     sys.excepthook = beforeExit
                         return self.__formated_value
                     if value == '':
-                        raise ValueError, '%s: This parameter value is empty' % self.name
+                        raise ValueError('%s: This parameter value is empty' % self.name)
                     if format == 'list':
                         strList = value.split(',')
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
-                            raise ValueError, '%s has to be a tuple or list of pairs' % value
+                            raise ValueError('%s has to be a tuple or list of pairs' % value)
                         if type(new_value[0]) not in (tuple, list):
                             if len(new_value) != 2:
-                                raise ValueError, '%s has to be a tuple or list of pairs' % value
+                                raise ValueError('%s has to be a tuple or list of pairs' % value)
                             new_value = [new_value]
                         for thisPair in new_value:
                             if len(thisPair) != 2:
-                                raise ValueError, '%s has to be a tuple or list of pairs' % value
+                                raise ValueError('%s has to be a tuple or list of pairs' % value)
                         self.__formated_value = new_value
                 def printattr(self):
-                    print 'Parameter[%s]: name = %s, value = %s, format = %s' % (self.id, self.name, self.value, self.format)
+                    print('Parameter[%s]: name = %s, value = %s, format = %s' % (self.id, self.name, self.value, self.format))
             class OperationConf():
                 def printattr(self):
-                    print '%s[%s]: name = %s, type = %s, priority = %s' % (self.ELEMENTNAME,
+                    print('%s[%s]: name = %s, type = %s, priority = %s' % (self.ELEMENTNAME,
                                                                            self.id,
                                                                            self.name,
                                                                            self.type,
-                                                                           self.priority)
+                                                                           self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self, plotter_queue=None):
                     if self.type == 'self':
-                        raise ValueError, 'This operation type cannot be created'
+                        raise ValueError('This operation type cannot be created')
                     if self.type == 'plotter':
                         if not plotter_queue:
-                            raise ValueError, 'plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)'
+                            raise ValueError('plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)')
                         opObj = Plotter(self.name, plotter_queue)
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
-                        raise ValueError, 'datatype or name should be defined'
+                        raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Proc' in datatype:
                 def printattr(self):
-                    print '%s[%s]: name = %s, datatype = %s, inputId = %s' % (self.ELEMENTNAME,
+                    print('%s[%s]: name = %s, datatype = %s, inputId = %s' % (self.ELEMENTNAME,
                                                                               self.id,
                                                                               self.name,
                                                                               self.datatype,
-                                                                              self.inputId)
+                                                                              self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
-                        raise ValueError, 'datatype or name should be defined'
+                        raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
                         opObj.addParameter(
                             name='endTime', value=self.endTime, format='time')
-                        for key, value in kwargs.items():
+                        for key, value in list(kwargs.items()):
                             opObj.addParameter(name=key, value=value,
                                                format=type(value).__name__)
                     else:
                         name='startTime', value=self.startTime, format='time')
                     opObj.addParameter(name='endTime', value=self.endTime, format='time')
-                    for key, value in kwargs.items():
+                    for key, value in list(kwargs.items()):
                         opObj.addParameter(name=key, value=value,
                                            format=type(value).__name__)
                 def __getNewId(self):
-                    idList = self.procUnitConfObjDict.keys()
+                    idList = list(self.procUnitConfObjDict.keys())
                     id = int(self.id) * 10
                     self.id = str(new_id)
-                    keyList = self.procUnitConfObjDict.keys()
+                    keyList = list(self.procUnitConfObjDict.keys())
                     keyList.sort()
                     n = 1
                 def setup(self, id, name='', description='', email=None, alarm=[]):
-                    print
+                    print()
-                    print '*' * 60
+                    print('*' * 60)
-                    print '   Starting SIGNAL CHAIN PROCESSING v%s ' % schainpy.__version__
+                    print('   Starting SIGNAL CHAIN PROCESSING v%s ' % schainpy.__version__)
-                    print '*' * 60
+                    print('*' * 60)
-                    print
+                    print()
                     self.id = str(id)
                     self.description = description
                     self.email = email
                 def update(self, **kwargs):
-                    for key, value in kwargs.items():
+                    for key, value in list(kwargs.items()):
                         setattr(self, key, value)
                 def clone(self):
                 def removeProcUnit(self, id):
-                    if id in self.procUnitConfObjDict.keys():
+                    if id in list(self.procUnitConfObjDict.keys()):
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                 def getReadUnitObj(self):
-                    for obj in self.procUnitConfObjDict.values():
+                    for obj in list(self.procUnitConfObjDict.values()):
                         if obj.getElementName() == 'ReadUnit':
                             return obj
                 def getProcUnitObjByName(self, name):
-                    for obj in self.procUnitConfObjDict.values():
+                    for obj in list(self.procUnitConfObjDict.values()):
                         if obj.name == name:
                             return obj
                 def procUnitItems(self):
-                    return self.procUnitConfObjDict.items()
+                    return list(self.procUnitConfObjDict.items())
                 def makeXml(self):
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
-                    for procUnitConfObj in self.procUnitConfObjDict.values():
+                    for procUnitConfObj in list(self.procUnitConfObjDict.values()):
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                             filename = 'schain.xml'
                     if not filename:
-                        print 'filename has not been defined. Use setFilename(filename) for do it.'
+                        print('filename has not been defined. Use setFilename(filename) for do it.')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.access(os.path.dirname(abs_file), os.W_OK):
-                        print 'No write permission on %s' % os.path.dirname(abs_file)
+                        print('No write permission on %s' % os.path.dirname(abs_file))
                         return 0
                     if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
-                        print 'File %s already exists and it could not be overwriten' % abs_file
+                        print('File %s already exists and it could not be overwriten' % abs_file)
                         return 0
                     self.makeXml()
                 def readXml(self, filename=None):
                     if not filename:
-                        print 'filename is not defined'
+                        print('filename is not defined')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.path.isfile(abs_file):
-                        print '%s file does not exist' % abs_file
+                        print('%s file does not exist' % abs_file)
                         return 0
                     self.projectElement = None
                     try:
                         self.projectElement = ElementTree().parse(abs_file)
                     except:
-                        print 'Error reading %s, verify file format' % filename
+                        print('Error reading %s, verify file format' % filename)
                         return 0
                     self.project = self.projectElement.tag
                 def printattr(self):
-                    print 'Project[%s]: name = %s, description = %s' % (self.id,
+                    print('Project[%s]: name = %s, description = %s' % (self.id,
                                                                         self.name,
-                                                                        self.description)
+                                                                        self.description))
-                    for procUnitConfObj in self.procUnitConfObjDict.values():
+                    for procUnitConfObj in list(self.procUnitConfObjDict.values()):
                         procUnitConfObj.printattr()
                 def createObjects(self):
-                    for procUnitConfObj in self.procUnitConfObjDict.values():
+                    for procUnitConfObj in list(self.procUnitConfObjDict.values()):
                         procUnitConfObj.createObjects(self.plotterQueue)
                 def __connect(self, objIN, thisObj):
                 def connectObjects(self):
-                    for thisPUConfObj in self.procUnitConfObjDict.values():
+                    for thisPUConfObj in list(self.procUnitConfObjDict.values()):
                         inputId = thisPUConfObj.getInputId()
                     '''
                     if self.isPaused():
-                        print 'Process suspended'
+                        print('Process suspended')
                         while True:
                             time.sleep(0.1)
                             if self.isStopped():
                                 break
-                        print 'Process reinitialized'
+                        print('Process reinitialized')
                     if self.isStopped():
-                        print 'Process stopped'
+                        print('Process stopped')
                         return 0
                     return 1
                 def setPlotterQueue(self, plotter_queue):
-                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
+                    raise NotImplementedError('Use schainpy.controller_api.ControllerThread instead Project class')
                 def getPlotterQueue(self):
-                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
+                    raise NotImplementedError('Use schainpy.controller_api.ControllerThread instead Project class')
                 def useExternalPlotter(self):
-                    raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
+                    raise NotImplementedError('Use schainpy.controller_api.ControllerThread instead Project class')
                 def run(self):
                     self.createObjects()
                     self.connectObjects()
-                    keyList = self.procUnitConfObjDict.keys()
+                    keyList = list(self.procUnitConfObjDict.keys())
                     keyList.sort()
                     err = None
                             except KeyboardInterrupt:
                                 is_ok = False
                                 break
-                            except ValueError, e:
+                            except ValueError as e:
                                 time.sleep(0.5)
                                 err = self.__handleError(procUnitConfObj)
                                 is_ok = False

schainpy/controller_api.py +2 -2

             import threading
-            from Queue import Queue
+            from queue import Queue
             from schainpy.controller import Project
             from schainpy.model.graphics.jroplotter import PlotManager
                     plotterList = PlotManager.plotterList
-                    for thisPUConfObj in self.procUnitConfObjDict.values():
+                    for thisPUConfObj in list(self.procUnitConfObjDict.values()):
                         inputId = thisPUConfObj.getInputId()

schainpy/model/__init__.py +5 -5

@@ -5,8 +5,8
5	# from schainpy.model.utils.jroutils import *	5	# from schainpy.model.utils.jroutils import *
6	# from schainpy.serializer import *	6	# from schainpy.serializer import *
7		7
8	from graphics import *	8	from .graphics import *
9	from data import *	9	from .data import *
10	from io import *	10	from .io import *
11	from proc import *	11	from .proc import *
12	from utils import *	12	from .utils import *

schainpy/model/data/BLTRheaderIO.py +8 -8

             import numpy
             import copy
             import datetime
-            from __builtin__ import None
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#"*50 + "\n"
-                    keyList = self.__dict__.keys()
+                    keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                         if attr:
                             message += "%s = %s" %("size", attr) + "\n"
-                    print message
+                    print(message)
             class FileHeader(Header):
                         '''
-                    except Exception, e:
+                    except Exception as e:
-                        print "FileHeader: "
+                        print("FileHeader: ")
-                        print eBasicHeader
+                        print(eBasicHeader)
                         return 0
                     self.FileMgcNumber= byte(header['FileMgcNumber'][0])
                     try:
                         header = numpy.fromfile(fp,RECORD_STRUCTURE,1)
-                    except Exception, e:
+                    except Exception as e:
-                        print "System Header: " + e
+                        print("System Header: " + e)
                         return 0
                     self.RecMgcNumber = header['RecMgcNumber'][0]     #0x23030001

schainpy/model/data/__init__.py +3 -3

@@ -1,3 +1,3
1	from jrodata import *	1	from .jrodata import *
2	from jroheaderIO import *	2	from .jroheaderIO import *
3	from jroamisr import * No newline at end of file	3	from .jroamisr import * No newline at end of file

schainpy/model/data/jroamisr.py +1 -1

                     if inputObj is None:
                         return copy.deepcopy(self)
-                    for key in inputObj.__dict__.keys():
+                    for key in list(inputObj.__dict__.keys()):
                         self.__dict__[key] = inputObj.__dict__[key]
                 def getNHeights(self):

schainpy/model/data/jrodata.py +47 -47

             import numpy
             import datetime
-            from jroheaderIO import SystemHeader, RadarControllerHeader
+            from .jroheaderIO import SystemHeader, RadarControllerHeader
-            from schainpy import cSchain
+            # from schainpy import cSchain
             def getNumpyDtype(dataTypeCode):
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                 else:
-                    raise ValueError, 'dataTypeCode was not defined'
+                    raise ValueError('dataTypeCode was not defined')
                 return numpyDtype
                 """
                 sortdata = numpy.sort(data, axis=None)
-            #     lenOfData = len(sortdata)
+                lenOfData = len(sortdata)
-            #     nums_min = lenOfData*0.2
+                nums_min = lenOfData*0.2
-            #     if nums_min <= 5:
+                if nums_min <= 5:
-            #         nums_min = 5
+                    nums_min = 5
-            #     sump = 0.
+                sump = 0.
-            #     sumq = 0.
+                sumq = 0.
-            #     j = 0
+                j = 0
-            #     cont = 1
+                cont = 1
-            #     while((cont==1)and(j<lenOfData)):
+                while((cont==1)and(j<lenOfData)):
-            #         sump += sortdata[j]
+                    sump += sortdata[j]
-            #         sumq += sortdata[j]**2
+                    sumq += sortdata[j]**2
-            #         if j > nums_min:
+                    if j > nums_min:
-            #             rtest = float(j)/(j-1) + 1.0/navg
+                        rtest = float(j)/(j-1) + 1.0/navg
-            #             if ((sumq*j) > (rtest*sump**2)):
+                        if ((sumq*j) > (rtest*sump**2)):
-            #                 j = j - 1
+                            j = j - 1
-            #                 sump  = sump - sortdata[j]
+                            sump  = sump - sortdata[j]
-            #                 sumq =  sumq - sortdata[j]**2
+                            sumq =  sumq - sortdata[j]**2
-            #                 cont = 0
+                            cont = 0
-            #         j += 1
+                    j += 1
-            #     lnoise = sump /j
+                lnoise = sump /j
-            #     return lnoise
+                return lnoise
-                return cSchain.hildebrand_sekhon(sortdata, navg)
+                # return cSchain.hildebrand_sekhon(sortdata, navg)
             class Beam:
                     if inputObj == None:
                         return copy.deepcopy(self)
-                    for key in inputObj.__dict__.keys():
+                    for key in list(inputObj.__dict__.keys()):
                         attribute = inputObj.__dict__[key]
                 def getChannelIndexList(self):
-                    return range(self.nChannels)
+                    return list(range(self.nChannels))
                 def getNHeights(self):
                 def getPairsIndexList(self):
-                    return range(self.nPairs)
+                    return list(range(self.nPairs))
                 def getNormFactor(self):
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
-                                raise ValueError, "Pair %s is not in dataOut.pairsList" % (
+                                raise ValueError("Pair %s is not in dataOut.pairsList" % (
-                                    pair)
+                                    pair))
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                 def setValue(self, value):
-                    print "This property should not be initialized"
+                    print("This property should not be initialized")
                     return
                 def getChannelIndexList(self):
-                    return range(self.nChannels)
+                    return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
-                        ind_vel[range(0, 1)] = ind_vel[range(0, 1)] + self.num_prof
+                        ind_vel[list(range(0, 1))] = ind_vel[list(range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
-                            xx[fil, :] = vel[fil]**numpy.asarray(range(4))
+                            xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                 def setValue(self, value):
-                    print "This property should not be initialized"
+                    print("This property should not be initialized")
                     return

schainpy/model/data/jroheaderIO.py +33 -31

             import copy
             import datetime
             import inspect
+            from schainpy.utils import log
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
-                    keyList = self.__dict__.keys()
+                    keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                         if attr:
                             message += "%s = %s" % ("size", attr) + "\n"
-                    print message
+                    print(message)
             class BasicHeader(Header):
                             header = numpy.fromfile(fp, BASIC_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, BASIC_STRUCTURE, 1)
-                    except Exception, e:
+                    except Exception as e:
-                        print "BasicHeader: "
+                        print("BasicHeader: ")
-                        print e
+                        print(e)
                         return 0
                     self.size = int(header['nSize'][0])
                     self.length = 0
                     try:
                         startFp = fp.tell()
-                    except Exception, e:
+                    except Exception as e:
                         startFp = None
                         pass
                             header = numpy.fromfile(fp, SYSTEM_STRUCTURE, 1)
                         else:
                             header = numpy.fromstring(fp, SYSTEM_STRUCTURE, 1)
-                    except Exception, e:
+                    except Exception as e:
-                        print "System Header: " + str(e)
+                        print("System Header: " + str(e))
                         return 0
                     self.size = header['nSize'][0]
                     self.length = 0
                     try:
                         startFp = fp.tell()
-                    except Exception, e:
+                    except Exception as e:
                         startFp = None
                         pass
                         else:
                             header = numpy.fromstring(fp, RADAR_STRUCTURE, 1)
                         self.length += header.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "RadarControllerHeader: " + str(e)
+                        print("RadarControllerHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "RadarControllerHeader: " + str(e)
+                        print("RadarControllerHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                     self.firstHeight = samplingWindow['h0']
                             self.Taus = numpy.fromstring(
                                 fp[self.length:], '<f4', self.numTaus)
                         self.length += self.Taus.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "RadarControllerHeader: " + str(e)
+                        print("RadarControllerHeader: " + str(e))
                         return 0
                     self.code_size = 0
                                 self.nBaud = numpy.fromstring(
                                     fp[self.length:], '<u4', 1)[0]
                                 self.length += self.nBaud.nbytes
-                        except Exception, e:
+                        except Exception as e:
-                            print "RadarControllerHeader: " + str(e)
+                            print("RadarControllerHeader: " + str(e))
                             return 0
                         code = numpy.empty([self.nCode, self.nBaud], dtype='i1')
                                     temp = numpy.fromstring(
                                         fp, 'u4', int(numpy.ceil(self.nBaud / 32.)))
                                 self.length += temp.nbytes
-                            except Exception, e:
+                            except Exception as e:
-                                print "RadarControllerHeader: " + str(e)
+                                print("RadarControllerHeader: " + str(e))
                                 return 0
                             for ib in range(self.nBaud - 1, -1, -1):
-                                code[ic, ib] = temp[ib / 32] % 2
+                                log.error(ib / 32)
-                                temp[ib / 32] = temp[ib / 32] / 2
+                                code[ic, ib] = temp[int(ib / 32)] % 2
+                                temp[int(ib / 32)] = temp[int(ib / 32)] / 2
                         self.code = 2.0 * code - 1.0
                         self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
                         if fp.tell() != endFp:
                             #             fp.seek(endFp)
-                            print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size)
+                            print("%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size))
                 #             return 0
                         if fp.tell() > endFp:
                 def set_size(self, value):
-                    raise IOError, "size is a property and it cannot be set, just read"
+                    raise IOError("size is a property and it cannot be set, just read")
                     return
                     self.length = 0
                     try:
                         startFp = fp.tell()
-                    except Exception, e:
+                    except Exception as e:
                         startFp = None
                         pass
                         else:
                             header = numpy.fromstring(fp, PROCESSING_STRUCTURE, 1)
                         self.length += header.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "ProcessingHeader: " + str(e)
+                        print("ProcessingHeader: " + str(e))
                         return 0
                     size = int(header['nSize'][0])
                             samplingWindow = numpy.fromstring(
                                 fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
                         self.length += samplingWindow.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "ProcessingHeader: " + str(e)
+                        print("ProcessingHeader: " + str(e))
                         return 0
                     self.nHeights = int(numpy.sum(samplingWindow['nsa']))
                             self.spectraComb = numpy.fromstring(
                                 fp[self.length:], 'u1', 2 * self.totalSpectra)
                         self.length += self.spectraComb.nbytes
-                    except Exception, e:
+                    except Exception as e:
-                        print "ProcessingHeader: " + str(e)
+                        print("ProcessingHeader: " + str(e))
                         return 0
                     if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                 def set_size(self, value):
-                    raise IOError, "size is a property and it cannot be set, just read"
+                    raise IOError("size is a property and it cannot be set, just read")
                     return

schainpy/model/graphics/__init__.py +7 -7

@@ -1,7 +1,7
1	from jroplot_voltage import *	1	from .jroplot_voltage import *
2	from jroplot_spectra import *	2	from .jroplot_spectra import *
3	from jroplot_heispectra import *	3	from .jroplot_heispectra import *
4	from jroplot_correlation import *	4	from .jroplot_correlation import *
5	from jroplot_parameters import *	5	from .jroplot_parameters import *
6	from jroplot_data import *	6	from .jroplot_data import *
7	from jroplotter import *	7	from .jroplotter import *

schainpy/model/graphics/figure.py +5 -5

             import os
             import numpy
             import time, datetime
-            import mpldriver
+            from schainpy.model.graphics import mpldriver
             from schainpy.model.proc.jroproc_base import Operation
                 def init(self, id, nplots, wintitle):
-                    raise NotImplementedError, "This method has been replaced by createFigure"
+                    raise NotImplementedError("This method has been replaced by createFigure")
                 def createFigure(self, id, wintitle, widthplot=None, heightplot=None, show=True):
                 def setTextFromAxes(self, text):
-                    raise NotImplementedError, "This method has been replaced with Axes.setText"
+                    raise NotImplementedError("This method has been replaced with Axes.setText")
                 def makeAxes(self, nrow, ncol, xpos, ypos, colspan, rowspan):
-                    raise NotImplementedError, "This method has been replaced with Axes.addAxes"
+                    raise NotImplementedError("This method has been replaced with Axes.addAxes")
                 def addAxes(self, *args):
                     """
                         if not figfile:
                             if not thisDatetime:
-                                raise ValueError, "Saving figure: figfile or thisDatetime should be defined"
+                                raise ValueError("Saving figure: figfile or thisDatetime should be defined")
                                 return
                             str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")

schainpy/model/graphics/jroplot_correlation.py +3 -3

             import numpy
             import copy
             from schainpy.model import *
-            from figure import Figure, isRealtime
+            from .figure import Figure, isRealtime
             class CorrelationPlot(Figure):
                 isConfig = None
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
-                            print 'Skipping this plot function'
+                            print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor

schainpy/model/graphics/jroplot_data.py +5 -5

                     self.titles: list of axes title
                     '''
-                    raise(NotImplementedError, 'Implement this method in child class')
+                    raise NotImplementedError
                 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
                     '''
                             if self.save_labels:
                                 labels = self.save_labels
                             else:
-                                labels = range(self.nrows)
+                                labels = list(range(self.nrows))
                             if self.oneFigure:
                                 label = ''
                 def plot(self):
                     '''
                     '''
-                    raise(NotImplementedError, 'Implement this method in child class')
+                    raise NotImplementedError
                 def run(self):
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = self.data.parameters \
-                            if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
+                            if self.data.parameters else ['Param {}'.format(x) for x in range(self.nrows)]
                         if self.showSNR:
                             self.titles.append('SNR')
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
-                        self.channels = range(self.nplots)
+                        self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'

schainpy/model/graphics/jroplot_heispectra.py +5 -5

             import datetime
             import numpy
-            from figure import Figure, isRealtime
+            from .figure import Figure, isRealtime
-            from plotting_codes import *
+            from .plotting_codes import *
             class SpectraHeisScope(Figure):
                     if dataOut.realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
-                            print 'Skipping this plot function'
+                            print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
             #        x = dataOut.heightList
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if timerange != None:

schainpy/model/graphics/jroplot_parameters.py +10 -10

             import datetime
             import numpy
             import inspect
-            from figure import Figure, isRealtime, isTimeInHourRange
+            from .figure import Figure, isRealtime, isTimeInHourRange
-            from plotting_codes import *
+            from .plotting_codes import *
             class FitGauPlot(Figure):
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
-                            print 'Skipping this plot function'
+                            print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList" %channel
+                                raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
             #         if normFactor is None:
                     y = dataOut.getHeiRange()
                     z = dataOut.GauSPC[:,GauSelector,:,:] #GauSelector]    #dataOut.data_spc/factor
-                    print 'GausSPC', z[0,32,10:40]
+                    print('GausSPC', z[0,32,10:40])
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
-                            print 'Skipping this plot function'
+                            print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
-                        if zmax == None: zmax = numpy.nanmax(abs(z[range(2),:]))
+                        if zmax == None: zmax = numpy.nanmax(abs(z[list(range(2)),:]))
                         #if numpy.isnan(zmax): zmax = 50
                         if zmin == None: zmin = -zmax
                         return
                     if channelList == None:
-                        channelIndexList = range(dataOut.data_param.shape[0])
+                        channelIndexList = list(range(dataOut.data_param.shape[0]))
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange1(dataOut.paramInterval)

schainpy/model/graphics/jroplot_spectra.py +12 -12

             import datetime
             import numpy
-            from figure import Figure, isRealtime, isTimeInHourRange
+            from .figure import Figure, isRealtime, isTimeInHourRange
-            from plotting_codes import *
+            from .plotting_codes import *
             class SpectraPlot(Figure):
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
-                            print 'Skipping this plot function'
+                            print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList" %channel
+                                raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
-                                raise ValueError, "Pair %s is not in dataOut.pairsList" %str(pair)
+                                raise ValueError("Pair %s is not in dataOut.pairsList" %str(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if not pairsIndexList:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                     update_figfile = False
-                    if dataOut.ltctime >= self.xmax:
+                    if self.xmax is not None and dataOut.ltctime >= self.xmax: #yong
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
-                                raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
+                                raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange()
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
-                                raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
+                                raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:

schainpy/model/graphics/jroplot_voltage.py +2 -2

             import datetime
             import numpy
-            from figure import Figure
+            from .figure import Figure
             class Scope(Figure):
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
-                                raise ValueError, "Channel %d is not in dataOut.channelList"
+                                raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])

schainpy/model/graphics/jroplotter.py +11 -11

             from schainpy.model.proc.jroproc_base import Operation
             from schainpy.model.serializer.data import obj2Dict, dict2Obj
-            from jroplot_correlation import *
+            from .jroplot_correlation import *
-            from jroplot_heispectra import *
+            from .jroplot_heispectra import *
-            from jroplot_parameters import *
+            from .jroplot_parameters import *
-            from jroplot_spectra import *
+            from .jroplot_spectra import *
-            from jroplot_voltage import *
+            from .jroplot_voltage import *
             class Plotter(Operation):
                 def setup(self, **kwargs):
-                    print "Initializing ..."
+                    print("Initializing ...")
                 def run(self, dataOut, id=None, **kwargs):
                                                      sys.exc_info()[1],
                                                      sys.exc_info()[2])
-                    print "***** Error occurred in PlotManager *****"
+                    print("***** Error occurred in PlotManager *****")
-                    print "***** [%s]: %s" %(name, err[-1])
+                    print("***** [%s]: %s" %(name, err[-1]))
                     message = "\nError ocurred in %s:\n" %name
                     message += "".join(err)
                         dataPlot = serial_data['data']
-                        if plot_id not in self.plotInstanceDict.keys():
+                        if plot_id not in list(self.plotInstanceDict.keys()):
                             className = eval(plot_name)
                             self.plotInstanceDict[plot_id] = className(**kwargs)
                     self.__lock.acquire()
-                    for plot_id in self.plotInstanceDict.keys():
+                    for plot_id in list(self.plotInstanceDict.keys()):
                         plotter = self.plotInstanceDict[plot_id]
                         plotter.close()
                 def start(self):
                     if not self.controllerThreadObj.isRunning():
-                        raise RuntimeError, "controllerThreadObj has not been initialized. Use controllerThreadObj.start() before call this method"
+                        raise RuntimeError("controllerThreadObj has not been initialized. Use controllerThreadObj.start() before call this method")
                     self.join()

schainpy/model/graphics/mpldriver.py +11 -11

                 ######################################################
                 if '0.' in matplotlib.__version__[0:2]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                 ax_cb.yaxis.tick_right()
                 if '0.' in matplotlib.__version__[0:2]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return imesh
                 if '1.0.' in matplotlib.__version__[0:4]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return imesh
                 matplotlib.pyplot.tight_layout()
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
-                    print "The matplotlib version has to be updated to 1.1 or newer"
+                    print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
             #     if grid != None:
             def draw(fig):
                 if type(fig) == 'int':
-                    raise ValueError, "Error drawing: Fig parameter should be a matplotlib figure object figure"
+                    raise ValueError("Error drawing: Fig parameter should be a matplotlib figure object figure")
                 fig.canvas.draw()

schainpy/model/io/MIRAtest.py +4 -4

             # print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
             #OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
             #startFp.seek(OffRHeader, os.SEEK_SET)
-            print 'debe ser 48, RecCounter*811248', self.OffsetStartHeader, self.RecCounter, self.Off2StartNxtRec
+            print('debe ser 48, RecCounter*811248', self.OffsetStartHeader, self.RecCounter, self.Off2StartNxtRec)
-            print 'Posicion del bloque:        ', OffRHeader
+            print('Posicion del bloque:        ', OffRHeader)
             header = numpy.fromfile(startFp, SRVI_STRUCTURE, 1)
             # print 'Datasize',self.Datasize
             endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
-            print '=============================================='
+            print('==============================================')
-            print '=============================================='
+            print('==============================================')
  No newline at end of file

schainpy/model/io/__init__.py +14 -14

@@ -4,20 +4,20 $Author: murco $
4	$Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $	4	$Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
5	'''	5	'''
6		6
7	from jroIO_voltage import *	7	from .jroIO_voltage import *
8	from jroIO_spectra import *	8	from .jroIO_spectra import *
9	from jroIO_heispectra import *	9	from .jroIO_heispectra import *
10	from jroIO_usrp import *	10	from .jroIO_usrp import *
11	from jroIO_digitalRF import *	11	from .jroIO_digitalRF import *
12	from jroIO_kamisr import *	12	from .jroIO_kamisr import *
13	from jroIO_param import *	13	from .jroIO_param import *
14	from jroIO_hf import *	14	from .jroIO_hf import *
15		15
16	from jroIO_madrigal import *	16	from .jroIO_madrigal import *
17		17
18	from bltrIO_param import *	18	from .bltrIO_param import *
19	from jroIO_bltr import *	19	from .jroIO_bltr import *
20	from jroIO_mira35c import *	20	from .jroIO_mira35c import *
21	from julIO_param import *	21	from .julIO_param import *
22		22
23	from pxIO_param import * No newline at end of file	23	from .pxIO_param import * No newline at end of file

schainpy/model/io/bltrIO_param.py +4 -4

                     self.datatime = datetime.datetime(1900,1,1)
                     if self.path is None:
-                        raise ValueError, "The path is not valid"
+                        raise ValueError("The path is not valid")
                     if ext is None:
                         ext = self.ext
                     self.fileIndex = 0
                     if not self.fileList:
-                        raise Warning, "There is no files matching these date in the folder: %s. \n Check 'startDate' and 'endDate' " % (
+                        raise Warning("There is no files matching these date in the folder: %s. \n Check 'startDate' and 'endDate' " % (
-                            path)
+                            path))
                     self.setNextFile()
                     self.dataOut.sizeOfFile = self.sizeOfFile
                     self.dataOut.lat = self.lat
                     self.dataOut.lon = self.lon
-                    self.dataOut.channelList = range(self.nchannels)
+                    self.dataOut.channelList = list(range(self.nchannels))
                     self.dataOut.kchan = self.kchan
                     self.dataOut.delta = self.delta
                     self.dataOut.correction = self.correction

schainpy/model/io/jroIO_amisr.py +19 -19

                         self.status = 1
                     else:
                         self.status = 0
-                        print 'Path:%s does not exists'%self.path
+                        print('Path:%s does not exists'%self.path)
                     return
                     pat = '\d+.\d+'
                     dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
-                    dirnameList = filter(lambda x:x!=None,dirnameList)
+                    dirnameList = [x for x in dirnameList if x!=None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = filter(lambda x:x!=None,dirnameList)
+                        dirnameList = [x for x in dirnameList if x!=None]
                     if len(dirnameList)>0:
                         self.status = 1
                         self.dirnameList = dirnameList
                     startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
                     endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
-                    print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
+                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
-                    print '........................................'
+                    print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
                     for i in range(len(self.filenameList)-1):
                 def __getFilenameList(self, fileListInKeys, dirList):
                     for value in fileListInKeys:
-                        dirName = value.keys()[0]
+                        dirName = list(value.keys())[0]
                         for file in value[dirName]:
                             filename = os.path.join(dirName, file)
                             self.filenameList.append(filename)
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print "%s" %(self.filenameList[i])
+                        print("%s" %(self.filenameList[i]))
                     return
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
-                            print "No more Files"
+                            print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
                     self.amisrFilePointer = amisrFilePointer
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.__filename_online == filename:
-                            print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
+                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
                             sleep(self.__waitForNewFile)
                             self.__selectDataForTimes(online=True)
                             filename = self.filenameList[0]
                     self.amisrFilePointer = h5py.File(filename,'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                     #looking index list for data
                     start_index = self.radacHeaderObj.pulseCount[0,:][0]
                     end_index = self.radacHeaderObj.npulses
-                    range4data = range(start_index, end_index)
+                    range4data = list(range(start_index, end_index))
                     self.index4_schain_datablock = numpy.array(range4data)
                     buffer_start_index = 0
                     buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
-                    range4buffer = range(buffer_start_index, buffer_end_index)
+                    range4buffer = list(range(buffer_start_index, buffer_end_index))
                     self.index4_buffer = numpy.array(range4buffer)
                     self.linear_pulseCount = numpy.array(range4data + range4buffer)
                     just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
-                    for i in range(len(self.beamCodeDict.values())):
+                    for i in range(len(list(self.beamCodeDict.values()))):
-                        xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0])
+                        xx = numpy.where(just4record0==list(self.beamCodeDict.values())[i][0])
                         indexPulseByBeam = self.linear_pulseCount[xx[0]]
                         self.beamRangeDict[i] = indexPulseByBeam
                         self.searchFilesOnLine(path, walk)
                     if not(self.filenameList):
-                        print "There is no files into the folder: %s"%(path)
+                        print("There is no files into the folder: %s"%(path))
                         sys.exit(-1)
                     return 0
                 def printUTC(self):
-                    print self.dataOut.utctime
+                    print(self.dataOut.utctime)
-                    print ''
+                    print('')
                 def setObjProperties(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     if self.__hasNotDataInBuffer():

schainpy/model/io/jroIO_base.py +44 -44

                 try:
                     fp = open(filename, 'rb')
                 except IOError:
-                    print "The file %s can't be opened" % (filename)
+                    print("The file %s can't be opened" % (filename))
                     return 0
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
-                    print "Skipping the file %s because it has not a valid header" % (filename)
+                    print("Skipping the file %s because it has not a valid header" % (filename))
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
-                    print "The file %s can't be opened" % (filename)
+                    print("The file %s can't be opened" % (filename))
                     return None
                 firstBasicHeaderObj = BasicHeader(LOCALTIME)
                 sts = firstBasicHeaderObj.read(fp)
                 if not(sts):
-                    print "[Reading] Skipping the file %s because it has not a valid header" % (filename)
+                    print("[Reading] Skipping the file %s because it has not a valid header" % (filename))
                     return None
                 if not systemHeaderObj.read(fp):
                 offset = processingHeaderObj.blockSize + 24  # header size
                 if filesize <= offset:
-                    print "[Reading] %s: This file has not enough data" % filename
+                    print("[Reading] %s: This file has not enough data" % filename)
                     return None
                 fp.seek(-offset, 2)
                 basename = os.path.basename(folder)
                 if not isRadarFolder(basename):
-                    print "The folder %s has not the rigth format" % folder
+                    print("The folder %s has not the rigth format" % folder)
                     return 0
                 if startDate and endDate:
                 basename = os.path.basename(filename)
                 if not isRadarFile(basename):
-                    print "The filename %s has not the rigth format" % filename
+                    print("The filename %s has not the rigth format" % filename)
                     return 0
                 if startDate and endDate:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s' % (year, doy, set, ext.lower())
-                    print 'the filename %s does not exist' % filename
+                    print('the filename %s does not exist' % filename)
-                    print '...going to the last file: '
+                    print('...going to the last file: ')
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                         return [], []
                     if len(dateList) > 1:
-                        print "[Reading] Data found for date range [%s - %s]: total days = %d" % (startDate, endDate, len(dateList))
+                        print("[Reading] Data found for date range [%s - %s]: total days = %d" % (startDate, endDate, len(dateList)))
                     else:
-                        print "[Reading] Data found for date range [%s - %s]: date = %s" % (startDate, endDate, dateList[0])
+                        print("[Reading] Data found for date range [%s - %s]: date = %s" % (startDate, endDate, dateList[0]))
                     filenameList = []
                     datetimeList = []
                         datetimeList = datetimeList[cursor * skip:cursor * skip + skip]
                     if not(filenameList):
-                        print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" % (startTime, endTime, ext, path)
+                        print("[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" % (startTime, endTime, ext, path))
                         return [], []
-                    print "[Reading] %d file(s) was(were) found in time range: %s - %s" % (len(filenameList), startTime, endTime)
+                    print("[Reading] %d file(s) was(were) found in time range: %s - %s" % (len(filenameList), startTime, endTime))
                     # for i in range(len(filenameList)):
                     #     print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                             doypath.split('_')) > 1 else 0
                         fullpath = os.path.join(path, doypath, expLabel)
-                    print "[Reading] %s folder was found: " % (fullpath)
+                    print("[Reading] %s folder was found: " % (fullpath))
                     if set == None:
                         filename = getlastFileFromPath(fullpath, ext)
                     if not(filename):
                         return None, None, None, None, None, None
-                    print "[Reading] %s file was found" % (filename)
+                    print("[Reading] %s file was found" % (filename))
                     if not(self.__verifyFile(os.path.join(fullpath, filename))):
                         return None, None, None, None, None, None
                             for nTries in range(tries):
                                 if firstTime_flag:
-                                    print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % (self.delay, filename, nTries + 1)
+                                    print("\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % (self.delay, filename, nTries + 1))
                                     sleep(self.delay)
                                 else:
-                                    print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
+                                    print("\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext))
                                 fullfilename, filename = checkForRealPath(
                                     self.path, self.foldercounter, self.year, self.doy, self.set, self.ext)
                         return 0
                     if self.verbose:
-                        print '[Reading] Setting the file: %s' % self.filename
+                        print('[Reading] Setting the file: %s' % self.filename)
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                             #                self.flagEoF = True
                             return 0
-                        print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1)
+                        print("[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
                         sleep(self.delay)
                     return 0
                         if (currentSize >= neededSize):
                             return 1
-                        print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1)
+                        print("[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
                         sleep(self.delay)
                     return 0
                     # Skip block out of startTime and endTime
                     while True:
                         if not(self.__setNewBlock()):
-                            raise(schainpy.admin.SchainWarning('No more files'))
+                            raise schainpy
                             return 0
                         if not(self.readBlock()):
                         self.getBasicHeader()
                         if (self.dataOut.datatime < datetime.datetime.combine(self.startDate, self.startTime)) or (self.dataOut.datatime > datetime.datetime.combine(self.endDate, self.endTime)):
-                            print "[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
+                            print("[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
                                                                                   self.processingHeaderObj.dataBlocksPerFile,
-                                                                                  self.dataOut.datatime.ctime())
+                                                                                  self.dataOut.datatime.ctime()))
                             continue
                         break
                     if self.verbose:
-                        print "[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
+                        print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
-                                                                   self.dataOut.datatime.ctime())
+                                                                   self.dataOut.datatime.ctime()))
                     return 1
                 def __readFirstHeader(self):
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
-                        raise ValueError, 'Data type was not defined'
+                        raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     except IOError:
                         if msgFlag:
-                            print "[Reading] File %s can't be opened" % (filename)
+                            print("[Reading] File %s can't be opened" % (filename))
                         return False
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
-                            print msg
+                            print(msg)
                         return False
                     return True
                         pattern_path = multi_path[0]
                     if path_empty:
-                        print "[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate)
+                        print("[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate))
                     else:
                         if not dateList:
-                            print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path)
+                            print("[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path))
                     if include_path:
                         return dateList, pathList
                         self.receiver = self.context.socket(zmq.PULL)
                         self.receiver.connect(self.server)
                         time.sleep(0.5)
-                        print '[Starting] ReceiverData from {}'.format(self.server)
+                        print('[Starting] ReceiverData from {}'.format(self.server))
                     else:
                         self.server = None
                         if path == None:
-                            raise ValueError, "[Reading] The path is not valid"
+                            raise ValueError("[Reading] The path is not valid")
                         if ext == None:
                             ext = self.ext
                         if online:
-                            print "[Reading] Searching files in online mode..."
+                            print("[Reading] Searching files in online mode...")
                             for nTries in range(self.nTries):
                                 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(
                                 if fullpath:
                                     break
-                                print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (delay, path, nTries + 1)
+                                print('[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (delay, path, nTries + 1))
                                 sleep(delay)
                             if not(fullpath):
                             self.foldercounter = foldercounter
                             last_set = None
                         else:
-                            print "[Reading] Searching files in offline mode ..."
+                            print("[Reading] Searching files in offline mode ...")
                             pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                              startTime=startTime, endTime=endTime,
                                                                              set=set, expLabel=expLabel, ext=ext,
                         if not(self.setNextFile()):
                             if (startDate != None) and (endDate != None):
-                                print "[Reading] No files in range: %s - %s" % (datetime.datetime.combine(startDate, startTime).ctime(), datetime.datetime.combine(endDate, endTime).ctime())
+                                print("[Reading] No files in range: %s - %s" % (datetime.datetime.combine(startDate, startTime).ctime(), datetime.datetime.combine(endDate, endTime).ctime()))
                             elif startDate != None:
-                                print "[Reading] No files in range: %s" % (datetime.datetime.combine(startDate, startTime).ctime())
+                                print("[Reading] No files in range: %s" % (datetime.datetime.combine(startDate, startTime).ctime()))
                             else:
-                                print "[Reading] No files"
+                                print("[Reading] No files")
                                 self.fileIndex = -1
                                 self.pathList = []
                 def printReadBlocks(self):
-                    print "[Reading] Number of read blocks per file %04d" % self.nReadBlocks
+                    print("[Reading] Number of read blocks per file %04d" % self.nReadBlocks)
                 def printTotalBlocks(self):
-                    print "[Reading] Number of read blocks %04d" % self.nTotalBlocks
+                    print("[Reading] Number of read blocks %04d" % self.nTotalBlocks)
                 def printNumberOfBlock(self):
                     'SPAM!'
                     self.writeBlock()
-                    print "[Writing] Block No. %d/%d" % (self.blockIndex,
+                    print("[Writing] Block No. %d/%d" % (self.blockIndex,
-                                                         self.processingHeaderObj.dataBlocksPerFile)
+                                                         self.processingHeaderObj.dataBlocksPerFile))
                     return 1
                     self.setFirstHeader()
-                    print '[Writing] Opening file: %s' % self.filename
+                    print('[Writing] Opening file: %s' % self.filename)
                     self.__writeFirstHeader()
                         self.dtype = get_numpy_dtype(datatype)
                     if not(self.setNextFile()):
-                        print "[Writing] There isn't a next file"
+                        print("[Writing] There isn't a next file")
                         return 0
                     self.setBlockDimension()

schainpy/model/io/jroIO_bltr.py +58 -58

             #from schainpy.model.io.jroIO_bltr import BLTRReader
             from numpy import imag, shape, NaN
-            from jroIO_base import JRODataReader
+            from .jroIO_base import JRODataReader
             class Header(object):
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
-                    keyList = self.__dict__.keys()
+                    keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                     header = numpy.fromfile(startFp, FILE_STRUCTURE, 1)
-                    print ' '
+                    print(' ')
-                    print 'puntero file header', startFp.tell()
+                    print('puntero file header', startFp.tell())
-                    print ' '
+                    print(' ')
                     '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                     # RecCounter=0
                     # Off2StartNxtRec=811248
                     OffRHeader = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
-                    print ' '
+                    print(' ')
-                    print 'puntero Record Header', startFp.tell()
+                    print('puntero Record Header', startFp.tell())
-                    print ' '
+                    print(' ')
                     startFp.seek(OffRHeader, os.SEEK_SET)
-                    print ' '
+                    print(' ')
-                    print 'puntero Record Header con seek', startFp.tell()
+                    print('puntero Record Header con seek', startFp.tell())
-                    print ' '
+                    print(' ')
                     # print 'Posicion del bloque:        ',OffRHeader
                     header = numpy.fromfile(startFp, RECORD_STRUCTURE, 1)
-                    print ' '
+                    print(' ')
-                    print 'puntero Record Header con seek', startFp.tell()
+                    print('puntero Record Header con seek', startFp.tell())
-                    print ' '
+                    print(' ')
-                    print ' '
+                    print(' ')
                     #
                     # print 'puntero Record Header despues de seek', header.tell()
-                    print ' '
+                    print(' ')
                     self.RecMgcNumber = hex(header['RecMgcNumber'][0])  # 0x23030001
                     self.RecCounter = int(header['RecCounter'][0])
                     # print 'Datasize',self.Datasize
                     endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
-                    print '=============================================='
+                    print('==============================================')
-                    print 'RecMgcNumber         ', self.RecMgcNumber
+                    print('RecMgcNumber         ', self.RecMgcNumber)
-                    print 'RecCounter           ', self.RecCounter
+                    print('RecCounter           ', self.RecCounter)
-                    print 'Off2StartNxtRec      ', self.Off2StartNxtRec
+                    print('Off2StartNxtRec      ', self.Off2StartNxtRec)
-                    print 'Off2StartData        ', self.Off2StartData
+                    print('Off2StartData        ', self.Off2StartData)
-                    print 'Range Resolution     ', self.SampResolution
+                    print('Range Resolution     ', self.SampResolution)
-                    print 'First Height         ', self.StartRangeSamp
+                    print('First Height         ', self.StartRangeSamp)
-                    print 'PRF (Hz)             ', self.PRFhz
+                    print('PRF (Hz)             ', self.PRFhz)
-                    print 'Heights (K)          ', self.nHeights
+                    print('Heights (K)          ', self.nHeights)
-                    print 'Channels (N)         ', self.nChannels
+                    print('Channels (N)         ', self.nChannels)
-                    print 'Profiles (J)         ', self.nProfiles
+                    print('Profiles (J)         ', self.nProfiles)
-                    print 'iCoh                 ', self.nCohInt
+                    print('iCoh                 ', self.nCohInt)
-                    print 'iInCoh               ', self.nIncohInt
+                    print('iInCoh               ', self.nIncohInt)
-                    print 'BeamAngleAzim        ', self.BeamAngleAzim
+                    print('BeamAngleAzim        ', self.BeamAngleAzim)
-                    print 'BeamAngleZen         ', self.BeamAngleZen
+                    print('BeamAngleZen         ', self.BeamAngleZen)
                     # print 'ModoEnUso            ',self.DualModeIndex
                     # print 'UtcTime              ',self.nUtime
                     # print 'Exp Comment          ',self.ExpComment
                     # print 'FFT Window Index     ',self.FFTwindowingInd
                     # print 'N Dig. Channels      ',self.nDigChannels
-                    print 'Size de bloque       ', self.RHsize
+                    print('Size de bloque       ', self.RHsize)
-                    print 'DataSize             ', self.Datasize
+                    print('DataSize             ', self.Datasize)
-                    print 'BeamAngleAzim        ', self.BeamAngleAzim
+                    print('BeamAngleAzim        ', self.BeamAngleAzim)
                     # print 'AntennaCoord0        ',self.AntennaCoord0
                     # print 'AntennaAngl0         ',self.AntennaAngl0
                     # print 'AntennaCoord1        ',self.AntennaCoord1
                     # print 'AntennaAngl1         ',self.AntennaAngl1
                     # print 'AntennaCoord2        ',self.AntennaCoord2
                     # print 'AntennaAngl2         ',self.AntennaAngl2
-                    print 'RecPhaseCalibr0      ', self.RecPhaseCalibr0
+                    print('RecPhaseCalibr0      ', self.RecPhaseCalibr0)
-                    print 'RecPhaseCalibr1      ', self.RecPhaseCalibr1
+                    print('RecPhaseCalibr1      ', self.RecPhaseCalibr1)
-                    print 'RecPhaseCalibr2      ', self.RecPhaseCalibr2
+                    print('RecPhaseCalibr2      ', self.RecPhaseCalibr2)
-                    print 'RecAmpCalibr0        ', self.RecAmpCalibr0
+                    print('RecAmpCalibr0        ', self.RecAmpCalibr0)
-                    print 'RecAmpCalibr1        ', self.RecAmpCalibr1
+                    print('RecAmpCalibr1        ', self.RecAmpCalibr1)
-                    print 'RecAmpCalibr2        ', self.RecAmpCalibr2
+                    print('RecAmpCalibr2        ', self.RecAmpCalibr2)
-                    print 'ReceiverGaindB0      ', self.ReceiverGaindB0
+                    print('ReceiverGaindB0      ', self.ReceiverGaindB0)
-                    print 'ReceiverGaindB1      ', self.ReceiverGaindB1
+                    print('ReceiverGaindB1      ', self.ReceiverGaindB1)
-                    print 'ReceiverGaindB2      ', self.ReceiverGaindB2
+                    print('ReceiverGaindB2      ', self.ReceiverGaindB2)
-                    print '=============================================='
+                    print('==============================================')
                     if OffRHeader > endFp:
                         sys.stderr.write(
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'NoData se vuelve true'
+                        print('NoData se vuelve true')
                         return 0
                     self.fp = self.path
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_output = self.data_output
-                    print 'self.dataOut.data_output', shape(self.dataOut.data_output)
+                    print('self.dataOut.data_output', shape(self.dataOut.data_output))
                     # self.removeDC()
                     return self.dataOut.data_spc
                     '''
                     # The address of the folder is generated the name of the .fdt file that will be read
-                    print "File:    ", self.fileSelector + 1
+                    print("File:    ", self.fileSelector + 1)
                     if self.fileSelector < len(self.filenameList):
                         self.readBlock()  # Block reading
                     else:
-                        print 'readFile FlagNoData becomes true'
+                        print('readFile FlagNoData becomes true')
                         self.flagNoMoreFiles = True
                         self.dataOut.flagNoData = True
                         return 0
                     '''
                     if self.BlockCounter < self.nFDTdataRecors - 2:
-                        print self.nFDTdataRecors, 'CONDICION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+                        print(self.nFDTdataRecors, 'CONDICION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
                         if self.ReadMode == 1:
                             rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter + 1)
                         elif self.ReadMode == 0:
                         self.__firstHeigth = rheader.StartRangeSamp
                         self.__deltaHeigth = rheader.SampResolution
                         self.dataOut.heightList = self.__firstHeigth + \
-                            numpy.array(range(self.nHeights)) * self.__deltaHeigth
+                            numpy.array(list(range(self.nHeights))) * self.__deltaHeigth
-                        self.dataOut.channelList = range(self.nChannels)
+                        self.dataOut.channelList = list(range(self.nChannels))
                         self.dataOut.nProfiles = rheader.nProfiles
                         self.dataOut.nIncohInt = rheader.nIncohInt
                         self.dataOut.nCohInt = rheader.nCohInt
                             self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
                         self.data_output = numpy.ones([3, rheader.nHeights]) * numpy.NaN
-                        print 'self.data_output', shape(self.data_output)
+                        print('self.data_output', shape(self.data_output))
                         self.dataOut.velocityX = []
                         self.dataOut.velocityY = []
                         self.dataOut.velocityV = []
                             z = self.data_spc.copy()  # /factor
                             z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                             #zdB = 10*numpy.log10(z)
-                            print ' '
+                            print(' ')
-                            print 'Z: '
+                            print('Z: ')
-                            print shape(z)
+                            print(shape(z))
-                            print ' '
+                            print(' ')
-                            print ' '
+                            print(' ')
                             self.dataOut.data_spc = self.data_spc
                     else:
                         self.fileSelector += 1
                         self.BlockCounter = 0
-                        print "Next File"
+                        print("Next File")
  No newline at end of file

schainpy/model/io/jroIO_digitalRF.py +33 -33

             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from time import time
-            import cPickle
+            import pickle
             try:
                 import digital_rf
             except:
-                print 'You should install "digital_rf" module if you want to read Digital RF data'
+                print('You should install "digital_rf" module if you want to read Digital RF data')
             class DigitalRFReader(ProcessingUnit):
                     self.oldAverage = None
                 def close(self):
-                    print 'Average of writing to digital rf format is ', self.oldAverage * 1000
+                    print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     return
                 def __getCurrentSecond(self):
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
-                    self.dataOut.channelList = range(self.__num_subchannels)
+                    self.dataOut.channelList = list(range(self.__num_subchannels))
                     self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
                     self.flagDecodeData = flagDecodeData
                     self.i = 0
                     if not os.path.isdir(path):
-                        raise ValueError, "[Reading] Directory %s does not exist" % path
+                        raise ValueError("[Reading] Directory %s does not exist" % path)
                     try:
                         self.digitalReadObj = digital_rf.DigitalRFReader(
                     channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
-                        raise ValueError, "[Reading] Directory %s does not have any files" % path
+                        raise ValueError("[Reading] Directory %s does not have any files" % path)
                     if not channelList:
-                        channelList = range(len(channelNameList))
+                        channelList = list(range(len(channelNameList)))
                     ##########  Reading metadata ######################
                         self.__processingHeader = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
                         self.__systemHeader = self.fixed_metadata_dict['systemHeader']
-                        self.dtype = cPickle.loads(self.fixed_metadata_dict['dtype'])
+                        self.dtype = pickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                         endUTCSecond = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
-                            raise ValueError, "[Reading] nSamples or ippKm should be defined"
+                            raise ValueError("[Reading] nSamples or ippKm should be defined")
                         nSamples = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
                     channelBoundList = []
                     channelNameListFiltered = []
                     self.__channelNameList = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples = nSamples
-                    self.__samples_to_read = long(nSamples)  # FIJO: AHORA 40
+                    self.__samples_to_read = int(nSamples)  # FIJO: AHORA 40
                     self.__nChannels = len(self.__channelList)
                     self.__startUTCSecond = startUTCSecond
                         startUTCSecond = numpy.floor(endUTCSecond)
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
-                    self.__thisUnixSample = long(
+                    self.__thisUnixSample = int(
                         startUTCSecond * self.__sample_rate) - self.__samples_to_read
                     self.__data_buffer = numpy.zeros(
                     self.__setFileHeader()
                     self.isConfig = True
-                    print "[Reading] Digital RF Data was found from %s to %s " % (
+                    print("[Reading] Digital RF Data was found from %s to %s " % (
                         datetime.datetime.utcfromtimestamp(
                             self.__startUTCSecond - self.__timezone),
                         datetime.datetime.utcfromtimestamp(
                             self.__endUTCSecond - self.__timezone)
+                    ))
-                    print "[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
+                    print("[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
+                    ))
                     self.oldAverage = None
                     self.count = 0
                     self.executionTime = 0
                     #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                     #                                           )
-                    print "[Reading] reloading metadata ..."
+                    print("[Reading] reloading metadata ...")
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     if end_index > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
-                        print
+                        print()
-                        print "[Reading] New timerange found [%s, %s] " % (
+                        print("[Reading] New timerange found [%s, %s] " % (
                             datetime.datetime.utcfromtimestamp(
                                 self.__startUTCSecond - self.__timezone),
                             datetime.datetime.utcfromtimestamp(
                                 self.__endUTCSecond - self.__timezone)
+                        ))
                         return True
                     self.__thisUnixSample += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
-                        print "[Reading] There are no more data into selected time-range"
+                        print("[Reading] There are no more data into selected time-range")
                         if self.__online:
                             self.__reload()
                         else:
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
-                            except IOError, e:
+                            except IOError as e:
                                 # read next profile
                                 self.__flagDiscontinuousBlock = True
-                                print "[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e
+                                print("[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                                 break
                             if result.shape[0] != self.__samples_to_read:
                                 self.__flagDiscontinuousBlock = True
-                                print "[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                                print("[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                                          result.shape[0],
-                                                                                                         self.__samples_to_read)
+                                                                                                         self.__samples_to_read))
                                 break
                             self.__data_buffer[indexSubchannel, :] = result * volt_scale
                     if not dataOk:
                         return False
-                    print "[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                    print("[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                   self.__samples_to_read,
-                                                                  self.__timeInterval)
+                                                                  self.__timeInterval))
                     self.__bufferIndex = 0
                                 return False
                             if self.__flagDiscontinuousBlock:
-                                print '[Reading] discontinuous block found ... continue with the next block'
+                                print('[Reading] discontinuous block found ... continue with the next block')
                                 continue
                             if not self.__online:
                             if err_counter > nTries:
                                 return False
-                            print '[Reading] waiting %d seconds to read a new block' % seconds
+                            print('[Reading] waiting %d seconds to read a new block' % seconds)
                             sleep(seconds)
                     self.dataOut.data = self.__data_buffer[:,
                     self.metadata_dict['frequency'] = self.dataOut.frequency
                     self.metadata_dict['timezone'] = self.dataOut.timeZone
-                    self.metadata_dict['dtype'] = cPickle.dumps(self.dataOut.dtype)
+                    self.metadata_dict['dtype'] = pickle.dumps(self.dataOut.dtype)
                     self.metadata_dict['nProfiles'] = self.dataOut.nProfiles
                     self.metadata_dict['heightList'] = self.dataOut.heightList
                     self.metadata_dict['channelList'] = self.dataOut.channelList
                     file_cadence_millisecs = 1000
                     sample_rate_fraction = Fraction(self.__sample_rate).limit_denominator()
-                    sample_rate_numerator = long(sample_rate_fraction.numerator)
+                    sample_rate_numerator = int(sample_rate_fraction.numerator)
-                    sample_rate_denominator = long(sample_rate_fraction.denominator)
+                    sample_rate_denominator = int(sample_rate_fraction.denominator)
                     start_global_index = dataOut.utctime * self.__sample_rate
                     uuid = 'prueba'
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                 def close(self):
-                    print '[Writing] - Closing files '
+                    print('[Writing] - Closing files ')
-                    print 'Average of writing to digital rf format is ', self.oldAverage * 1000
+                    print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     try:
                         self.digitalWriteObj.close()
                     except:

schainpy/model/io/jroIO_heispectra.py +25 -25

             try:
                 import pyfits
-            except ImportError, e:
+            except ImportError as e:
-                print "Fits data cannot be used. Install pyfits module"
+                print("Fits data cannot be used. Install pyfits module")
             from xml.etree.ElementTree import ElementTree
-            from jroIO_base import isRadarFolder, isNumber
+            from .jroIO_base import isRadarFolder, isNumber
             from schainpy.model.data.jrodata import Fits
             from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
                     self.setFile = setFile
                     self.flagIsNewFile = 1
-                    print 'Writing the file: %s'%self.filename
+                    print('Writing the file: %s'%self.filename)
                     self.setFitsHeader(self.dataOut, self.metadatafile)
                     try:
                         fitsObj = pyfits.open(filename,'readonly')
                     except:
-                        print "File %s can't be opened" %(filename)
+                        print("File %s can't be opened" %(filename))
                         return None
                     header = fitsObj[0].header
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
-                            print "No more Files"
+                            print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
                     self.fileSize = fileSize
                     self.fitsObj = fitsObj
                     self.blockIndex = 0
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                     headerObj = self.fitsObj[0]
                     self.header_dict = headerObj.header
-                    if 'EXPNAME' in headerObj.header.keys():
+                    if 'EXPNAME' in list(headerObj.header.keys()):
                         self.expName = headerObj.header['EXPNAME']
-                    if 'DATATYPE' in headerObj.header.keys():
+                    if 'DATATYPE' in list(headerObj.header.keys()):
                         self.dataType = headerObj.header['DATATYPE']
                     self.datetimestr = headerObj.header['DATETIME']
             #         self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
-                    if 'COMMENT' in headerObj.header.keys():
+                    if 'COMMENT' in list(headerObj.header.keys()):
                         self.comments = headerObj.header['COMMENT']
                     self.readHeightList()
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
-                        print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
+                        print("Any folder was found for the date range: %s-%s" %(startDate, endDate))
                         return None, None
-                    print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
+                    print("%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate))
                     filenameList = []
                     datetimeList = []
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
-                        print "Any file was found for the time range %s - %s" %(startTime, endTime)
+                        print("Any file was found for the time range %s - %s" %(startTime, endTime))
                         return None, None
-                    print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
+                    print("%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime))
-                    print
+                    print()
                     for i in range(len(filenameList)):
-                        print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
+                        print("%s -> [%s]" %(filenameList[i], datetimeList[i].ctime()))
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                             walk = True):
                     if path == None:
-                        raise ValueError, "The path is not valid"
+                        raise ValueError("The path is not valid")
                     if ext == None:
                         ext = self.ext
                     if not(online):
-                        print "Searching files in offline mode ..."
+                        print("Searching files in offline mode ...")
                         pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            set=set, expLabel=expLabel, ext=ext,
                                                                            walk=walk)
                         if not(pathList):
-                            print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
+                            print("No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
-                                                                    datetime.datetime.combine(endDate,endTime).ctime())
+                                                                    datetime.datetime.combine(endDate,endTime).ctime()))
                             sys.exit(-1)
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
-                            print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
+                            print("No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()))
                         elif startDate != None:
-                            print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
+                            print("No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime()))
                         else:
-                            print "No files"
+                            print("No files")
                         sys.exit(-1)
                             self.__rdBasicHeader()
                             return 1
-                        print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
+                        print("\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1))
                         sleep( self.delay )
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     self.flagDiscontinuousBlock = 0

schainpy/model/io/jroIO_hf.py +40 -40

                 if set == None:
                     return validFilelist[-1]
-                print "set =" ,set
+                print("set =" ,set)
                 for thisFile in validFilelist:
                     if set <= int(thisFile[6:16]):
-                        print thisFile,int(thisFile[6:16])
+                        print(thisFile,int(thisFile[6:16]))
                         return thisFile
                 return validFilelist[-1]
                     return myfile[0]
                 else:
                     filename = '*%10.10d%s'%(set,ext.lower())
-                    print 'the filename %s does not exist'%filename
+                    print('the filename %s does not exist'%filename)
-                    print '...going to the last file: '
+                    print('...going to the last file: ')
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     try:
                         number= int(thisFile[6:16])
                     except:
-                        print "There is a file or folder with different format"
+                        print("There is a file or folder with different format")
                     if not isNumber(number):
                         continue
                         self.status=1
                     else:
                         self.status=0
-                        print 'Path %s does not exits'%self.path
+                        print('Path %s does not exits'%self.path)
                         return
                     return
                     pat = '\d+.\d+'
                     dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
-                    dirnameList = filter(lambda x:x!=None,dirnameList)
+                    dirnameList = [x for x in dirnameList if x!=None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = filter(lambda x:x!=None,dirnameList)
+                        dirnameList = [x for x in dirnameList if x!=None]
                     if len(dirnameList)>0:
                             self.status = 1
                 def __getTimeFromData(self):
                     startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
                     endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
-                    print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
+                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
-                    print '........................................'
+                    print('........................................')
                     filter_filenameList=[]
                     self.filenameList.sort()
                     for i in range(len(self.filenameList)-1):
                                 self.flag_nextfile=False
                             else:
-                                print filename
+                                print(filename)
-                                print "PRIMERA CONDICION"
+                                print("PRIMERA CONDICION")
                                 #if self.filename_next_set== int(filename[6:16]):
-                                print "TODO BIEN"
+                                print("TODO BIEN")
                                 if filename == None:
-                                    raise ValueError, "corregir"
+                                    raise ValueError("corregir")
                                 self.dirnameList=[filename]
                                 fullfilename=self.path+"/"+filename
                                 self.filenameList=[fullfilename]
                                 self.filename_next_set=int(filename[6:16])+10
-                                print "Setting next file",self.filename_next_set
+                                print("Setting next file",self.filename_next_set)
                                 self.set=int(filename[6:16])
                                 if True:
                                     pass
                                 else:
-                                    print "ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO"
+                                    print("ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO")
                         else:
                             filename =getlastFileFromPath(self.path,self.ext)
                                 self.flag_nextfile=False
                             else:
                                filename=getFileFromSet(self.path,self.ext,self.set)
-                               print filename
+                               print(filename)
-                               print "PRIMERA CONDICION"
+                               print("PRIMERA CONDICION")
                                 #if self.filename_next_set== int(filename[6:16]):
-                               print "TODO BIEN"
+                               print("TODO BIEN")
                                if filename == None:
-                                   raise ValueError, "corregir"
+                                   raise ValueError("corregir")
                                self.dirnameList=[filename]
                                fullfilename=self.path+"/"+filename
                                self.filenameList=[fullfilename]
                                self.filename_next_set=int(filename[6:16])+10
-                               print "Setting next file",self.filename_next_set
+                               print("Setting next file",self.filename_next_set)
                                self.set=int(filename[6:16])
                                if True:
                                    pass
                                else:
-                                   print "ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO"
+                                   print("ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO")
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print "%s"% (self.filenameList[i])
+                        print("%s"% (self.filenameList[i]))
                     return
                     self.__checkPath()
                     fullpath=path
-                    print "%s folder was found: " %(fullpath )
+                    print("%s folder was found: " %(fullpath ))
                     if set == None:
                         self.set=None
                         idFile += 1
                         if not (idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
-                            print "No more Files"
+                            print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
                         hfFilePointer =h5py.File(filename,'r')
                     self.hfFilePointer = hfFilePointer
                     hfFilePointer.close()
                     self.__t0=epoc
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                 def __setNextFileOnline(self):
                     """
                     """
-                    print "SOY NONE",self.set
+                    print("SOY NONE",self.set)
                     if self.set==None:
                         pass
                     else:
                         self.__selectDataForTimes(online=True)
                         filename = self.filenameList[0]
                         while self.filename_online == filename:
-                            print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
+                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
                             time.sleep(self.__waitForNewFile)
                             #self.__findDataForDates(online=True)
                             self.set=self.filename_next_set
                     #print filename
                     sizeoffile=os.path.getsize(filename)
                     if sizeoffile<1670240:
-                        print "%s is not the rigth  size"%filename
+                        print("%s is not the rigth  size"%filename)
                         delay=50
-                        print 'waiting %d seconds for delay...'%(delay)
+                        print('waiting %d seconds for delay...'%(delay))
                         time.sleep(delay)
                     sizeoffile=os.path.getsize(filename)
                     if sizeoffile<1670240:
                         delay=50
-                        print 'waiting %d  more seconds for delay...'%(delay)
+                        print('waiting %d  more seconds for delay...'%(delay))
                         time.sleep(delay)
                     sizeoffile=os.path.getsize(filename)
                     if sizeoffile<1670240:
                         delay=50
-                        print 'waiting %d  more seconds for delay...'%(delay)
+                        print('waiting %d  more seconds for delay...'%(delay))
                         time.sleep(delay)
                     try:
                         hfFilePointer=h5py.File(filename,'r')
                     except:
-                        print "Error reading file %s"%filename
+                        print("Error reading file %s"%filename)
                     self.filename_online=filename
                     epoc=hfFilePointer['t'].value
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                 def __getExpParameters(self):
                     '''
                     if path==None:
-                        raise ValueError,"The path is not valid"
+                        raise ValueError("The path is not valid")
                     if ext==None:
                         ext = self.ext
                     #print set
                     if not(online):
-                        print "Searching files in offline mode..."
+                        print("Searching files in offline mode...")
                         self.searchFilesOffLine(path, startDate, endDate, ext, startTime, endTime, walk)
                     else:
-                        print "Searching files in online mode..."
+                        print("Searching files in online mode...")
                         self.searchFilesOnLine(path, walk,ext,set=set)
                         if set==None:
                             pass
                     if not(self.filenameList):
-                        print "There  is no files into the folder: %s"%(path)
+                        print("There  is no files into the folder: %s"%(path))
                         sys.exit(-1)
                     self.__getExpParameters()
                     self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
-                    self.dataOut.channelList = range(self.nChannels)
+                    self.dataOut.channelList = list(range(self.nChannels))
                     #self.dataOut.channelIndexList = None
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     if self.__hasNotDataInBuffer():

schainpy/model/io/jroIO_kamisr.py +14 -14

                         self.searchFilesOnLine(path, startDate, endDate, startTime,endTime,walk)
                     if not(self.filenameList):
-                        print "There is no files into the folder: %s"%(path)
+                        print("There is no files into the folder: %s"%(path))
                         sys.exit(-1)
                     #filling system header parameters
                     self.__nSamples = self.nsa
                     self.newProfiles = self.nprofiles/self.nchannels
-                    self.__channelList = range(self.nchannels)
+                    self.__channelList = list(range(self.nchannels))
                     self.__frequency = self.frequency[0][0]
                         self.status = 1
                     else:
                         self.status = 0
-                        print 'Path:%s does not exists'%self.path
+                        print('Path:%s does not exists'%self.path)
                     return
                     pat = '\d+.\d+'
                     dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
-                    dirnameList = filter(lambda x:x!=None,dirnameList)
+                    dirnameList = [x for x in dirnameList if x!=None]
                     dirnameList = [x.string for x in dirnameList]
                     if not(online):
                         dirnameList = [self.__selDates(x) for x in dirnameList]
-                        dirnameList = filter(lambda x:x!=None,dirnameList)
+                        dirnameList = [x for x in dirnameList if x!=None]
                     if len(dirnameList)>0:
                         self.status = 1
                         self.dirnameList = dirnameList
                     startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
                     endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
-                    print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
+                    print('Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader))
-                    print '........................................'
+                    print('........................................')
                     filter_filenameList = []
                     self.filenameList.sort()
                     #for i in range(len(self.filenameList)-1):
                 def __getFilenameList(self, fileListInKeys, dirList):
                     for value in fileListInKeys:
-                        dirName = value.keys()[0]
+                        dirName = list(value.keys())[0]
                         for file in value[dirName]:
                             filename = os.path.join(dirName, file)
                             self.filenameList.append(filename)
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
-                        print "%s" %(self.filenameList[i])
+                        print("%s" %(self.filenameList[i]))
                     return
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
-                            print "No more Files"
+                            print("No more Files")
                             return 0
                         filename = self.filenameList[idFile]
                     self.amisrFilePointer = amisrFilePointer
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                         filename = self.filenameList[0]
                         wait = 0
                         while self.__filename_online == filename:
-                            print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
+                            print('waiting %d seconds to get a new file...'%(self.__waitForNewFile))
                             if wait == 5:
                                 return 0
                             sleep(self.__waitForNewFile)
                     self.amisrFilePointer = h5py.File(filename,'r')
                     self.flagIsNewFile = 1
                     self.filename = filename
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
                     return 1
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     if self.__hasNotDataInBuffer():

schainpy/model/io/jroIO_madrigal.py +16 -16

                     iterable = obj
                 if isinstance(iterable, dict):
-                    return {str(k): load_json(v) if isinstance(v, dict) else str(v) if isinstance(v, unicode) else v
+                    return {str(k): load_json(v) if isinstance(v, dict) else str(v) if isinstance(v, str) else v
-                        for k, v in iterable.items()}
+                        for k, v in list(iterable.items())}
                 elif isinstance(iterable, (list, tuple)):
-                    return [str(v) if isinstance(v, unicode) else v for v in iterable]
+                    return [str(v) if isinstance(v, str) else v for v in iterable]
                 return iterable
                     self.ind2DList = load_json(kwargs.get('ind2DList',
                                                           "[\"GDALT\"]"))
                     if self.path is None:
-                        raise ValueError, 'The path is not valid'
+                        raise ValueError('The path is not valid')
                     if format is None:
-                        raise ValueError, 'The format is not valid choose simple or hdf5'
+                        raise ValueError('The format is not valid choose simple or hdf5')
                     elif format.lower() in ('simple', 'txt'):
                         self.ext = '.txt'
                     elif format.lower() in ('cedar',):
                     self.fileId = 0
                     if not self.fileList:
-                        raise  Warning, 'There is no files matching these date in the folder: {}. \n Check startDate and endDate'.format(path)
+                        raise  Warning('There is no files matching these date in the folder: {}. \n Check startDate and endDate'.format(path))
                     self.setNextFile()
                         log.success('Spatial parameters: {}'.format(','.join(s_parameters)),
                                     'MADReader')
-                    for param in self.oneDDict.keys():
+                    for param in list(self.oneDDict.keys()):
                         if param.lower() not in self.parameters:
                             log.warning(
                                 'Parameter {} not found will be ignored'.format(
                                 'MADReader')
                             self.oneDDict.pop(param, None)
-                    for param, value in self.twoDDict.items():
+                    for param, value in list(self.twoDDict.items()):
                         if param.lower() not in self.parameters:
                             log.warning(
                                 'Parameter {} not found, it will be ignored'.format(
                     parameters = [None for __ in self.parameters]
-                    for param, attr in self.oneDDict.items():
+                    for param, attr in list(self.oneDDict.items()):
                         x = self.parameters.index(param.lower())
                         setattr(self.dataOut, attr, self.buffer[0][x])
-                    for param, value in self.twoDDict.items():
+                    for param, value in list(self.twoDDict.items()):
                         x = self.parameters.index(param.lower())
                         if self.ext == '.txt':
                             y = self.parameters.index(self.ind2DList[0].lower())
                             self.output[value[0]][value[1]] = dummy
                             parameters[value[1]] = param
-                    for key, value in self.output.items():
+                    for key, value in list(self.output.items()):
                         setattr(self.dataOut, key, numpy.array(value))
                     self.dataOut.parameters = [s for s in parameters if s]
                             'Creating file: {}'.format(self.fullname),
                             'MADWriter')
                         self.fp = madrigal.cedar.MadrigalCedarFile(self.fullname, True)
-                    except ValueError, e:
+                    except ValueError as e:
                         log.error(
                             'Impossible to create a cedar object with "madrigal.cedar.MadrigalCedarFile"',
                             'MADWriter')
                     heights = self.dataOut.heightList
                     if self.ext == '.dat':
-                        for key, value in self.twoDDict.items():
+                        for key, value in list(self.twoDDict.items()):
                             if isinstance(value, str):
                                 data = getattr(self.dataOut, value)
                                 invalid = numpy.isnan(data)
                                 data[invalid] = self.missing
                     out = {}
-                    for key, value in self.twoDDict.items():
+                    for key, value in list(self.twoDDict.items()):
                         key = key.lower()
                         if isinstance(value, str):
                             if 'db' in value.lower():
                         endTime.minute,
                         endTime.second,
                         endTime.microsecond/10000,
-                        self.oneDDict.keys(),
+                        list(self.oneDDict.keys()),
-                        self.twoDDict.keys(),
+                        list(self.twoDDict.keys()),
                         len(index),
                         **self.extra_args
                     )

schainpy/model/io/jroIO_matlab.py +8 -8

                 def __setHeader(self, datastuff):
                     self.dataOut.pairsList=[(0,1)]
-                    self.dataOut.channelList =  range(np.array(datastuff.get('power')).shape[1])
+                    self.dataOut.channelList =  list(range(np.array(datastuff.get('power')).shape[1]))
                     self.dataOut.nProfiles = len(np.array(datastuff.get('vel')).flatten())     #this!
                     self.dataOut.nIncohInt = 20
                     self.dataOut.nCohInt = 1 #this!
                     self.dataOut.heightList = np.array(datastuff.get('hts')).flatten()
                 def __readFile(self, currentfile):
-                    print "Reading from this file:" + currentfile
+                    print("Reading from this file:" + currentfile)
                     #filesplit=currentfile.split("\\")
                     filesplit=currentfile.split("/")
             #             self.utcmatcounter=0
             #         print self.utcmatcounter
-                    print self.utcfirst
+                    print(self.utcfirst)
                     try:
                         datastuff=sio.loadmat(currentfile)
                     except:
                     utclist=[]
                     if not dirList:
-                        print "No directories found"
+                        print("No directories found")
                         return []
                     #if self.online:
                         utclist.append(utctime)
                     if not dirListFiltered:
-                        print "filtro"
+                        print("filtro")
                         return []
                     for thisDir in dirListFiltered:
                         if nTries > 3:
                             break
-                        print "Waiting %d seconds ..." %seconds
+                        print("Waiting %d seconds ..." %seconds)
                         time.sleep(40)
                     if not (len(filelist) > ncurrentfiles):
                     self.fileList = fileList
-                    print "fin setup"
+                    print("fin setup")
                 def run(self,path=None,startDate=None, endDate=None,
                         startTime=datetime.time(0,0,0),
                     if not self.fileList:
                         self.dataOut.flagNoData = True
-                        print "lista vacia"
+                        print("lista vacia")
                         return
                     currentfile = self.__getNextFile()

schainpy/model/io/jroIO_mira35c.py +13 -13

                     message += self.__class__.__name__.upper() + "\n"
                     message += "#" * 50 + "\n"
-                    keyList = self.__dict__.keys()
+                    keyList = list(self.__dict__.keys())
                     keyList.sort()
                     for key in keyList:
                     self.DataBlockTitleSRVI1 = str(header['DataBlockTitleSRVI1'][0])
                     self.SizeOfSRVI1 = header['SizeOfSRVI1'][0]
                     # 16
-                    print 'Pointer fp SRVIheader', fp.tell()
+                    print('Pointer fp SRVIheader', fp.tell())
             SRVI_STRUCTURE = numpy.dtype([
                     # print 'Datasize',self.Datasize
                     #endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
-                    print '=============================================='
+                    print('==============================================')
-                    print '=============================================='
+                    print('==============================================')
                     return 1
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'NoData se vuelve true'
+                        print('NoData se vuelve true')
                         return 0
                     self.fp = self.path
                     '''
                     # The address of the folder is generated the name of the .fdt file that will be read
-                    print "File:    ", self.fileSelector + 1
+                    print("File:    ", self.fileSelector + 1)
                     if self.fileSelector < len(self.filenameList):
                         self.readBlock()  # Block reading
                     else:
-                        print 'readFile FlagNoData becomes true'
+                        print('readFile FlagNoData becomes true')
                         self.flagNoMoreFiles = True
                         self.dataOut.flagNoData = True
                         self.FileHeaderFlag == True
                     self.blocksize = self.srviHeader.SizeOfDataBlock1  # Se obtiene el tamao del bloque
                     if self.blocksize == 148:
-                        print 'blocksize == 148 bug'
+                        print('blocksize == 148 bug')
                         jump = numpy.fromfile(self.fp, [('jump', numpy.str_, 140)], 1)
                         # Se obtiene la cabecera del SRVI
                     npw1 = self.recordheader.npw1
                     npw2 = self.recordheader.npw2
-                    self.dataOut.channelList = range(1)
+                    self.dataOut.channelList = list(range(1))
                     self.dataOut.nIncohInt = self.Num_inCoh
                     self.dataOut.nProfiles = self.Num_Bins
                     self.dataOut.nCohInt = 1
                     self.dataOut.outputInterval = self.dataOut.getTimeInterval()
                     self.dataOut.heightList = self.SPARrawGate1 * self.__deltaHeigth + \
-                        numpy.array(range(self.Num_Hei)) * self.__deltaHeigth
+                        numpy.array(list(range(self.Num_Hei))) * self.__deltaHeigth
                     self.HSDVsign = numpy.fromfile(self.fp, [('HSDV', numpy.str_, 4)], 1)
                     self.SizeHSDV = numpy.fromfile(self.fp, [('SizeHSDV', '<i4')], 1)
                     self.dataOut.COFA = numpy.array([self.COFA_Co, self.COFA_Cx])
-                    print ' '
+                    print(' ')
-                    print 'SPC', numpy.shape(self.dataOut.data_spc)
+                    print('SPC', numpy.shape(self.dataOut.data_spc))
                     # print 'SPC',self.dataOut.data_spc
                     noinor1 = 713031680
                     npw2 = 1  # 0**(npw2/10) * noinor1 * noinor2
                     self.dataOut.NPW = numpy.array([npw1, npw2])
-                    print ' '
+                    print(' ')
                     self.data_spc = numpy.transpose(self.data_spc, (2, 1, 0))
                     self.data_spc = numpy.fft.fftshift(self.data_spc, axes=1)

schainpy/model/io/jroIO_param.py +18 -18

             from schainpy.model.data.jrodata import *
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
-            # from jroIO_base import *
+            # from .jroIO_base import *
             from schainpy.model.io.jroIO_base import *
             import schainpy
                     startTime = kwargs['startTime']
                     endTime = kwargs['endTime']
                     walk = kwargs['walk']
-                    if kwargs.has_key('ext'):
+                    if 'ext' in kwargs:
                         ext = kwargs['ext']
                     else:
                         ext = '.hdf5'
-                    if kwargs.has_key('timezone'):
+                    if 'timezone' in kwargs:
                         self.timezone = kwargs['timezone']
                     else:
                         self.timezone = 'lt'
-                    print "[Reading] Searching files in offline mode ..."
+                    print("[Reading] Searching files in offline mode ...")
                     pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            ext=ext, walk=walk)
                     if not(filenameList):
-                        print "There is no files into the folder: %s"%(path)
+                        print("There is no files into the folder: %s"%(path))
                         sys.exit(-1)
                     self.fileIndex = -1
                     dateList, pathList = JRODataObj.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
                     if dateList == []:
-                        print "[Reading] No *%s files in %s from %s to %s)"%(ext, path,
+                        print("[Reading] No *%s files in %s from %s to %s)"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
-                                                                    datetime.datetime.combine(endDate,endTime).ctime())
+                                                                    datetime.datetime.combine(endDate,endTime).ctime()))
                         return None, None
                     if len(dateList) > 1:
-                        print "[Reading] %d days were found in date range: %s - %s" %(len(dateList), startDate, endDate)
+                        print("[Reading] %d days were found in date range: %s - %s" %(len(dateList), startDate, endDate))
                     else:
-                        print "[Reading] data was found for the date %s" %(dateList[0])
+                        print("[Reading] data was found for the date %s" %(dateList[0]))
                     filenameList = []
                     datetimeList = []
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
-                        print "[Reading] Any file was found int time range %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
+                        print("[Reading] Any file was found int time range %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()))
                         return None, None
-                    print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime)
+                    print("[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime))
-                    print
+                    print()
             #         for i in range(len(filenameList)):
             #             print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     except IOError:
                         traceback.print_exc()
-                        raise IOError, "The file %s can't be opened" %(filename)
+                        raise IOError("The file %s can't be opened" %(filename))
                     #chino rata
                     #In case has utctime attribute
                     grp2 = grp1['utctime']
                     idFile = self.fileIndex
                     if not(idFile < len(self.filenameList)):
-                        print "No more Files"
+                        print("No more Files")
                         return 0
                     filename = self.filenameList[idFile]
                     self.fp = filePointer
-                    print "Setting the file: %s"%self.filename
+                    print("Setting the file: %s"%self.filename)
             #         self.__readMetadata()
                     self.__setBlockList()
                     listMetaname = []
                     listMetadata = []
-                    for item in gp.items():
+                    for item in list(gp.items()):
                         name = item[0]
                         if name=='array dimensions':
                     listdataname = []
                     listdata = []
-                    for item in grp.items():
+                    for item in list(grp.items()):
                         name = item[0]
                         listdataname.append(name)
             #         self.nDims = nDims
             #         self.nDimsForDs = nDimsForDs
                     #Saving variables
-                    print 'Writing the file: %s'%filename
+                    print('Writing the file: %s'%filename)
                     self.filename = filename
             #         self.fp = fp
             #         self.grp = grp

schainpy/model/io/jroIO_spectra.py +3 -3

             '''
             import numpy
-            from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
+            from schainpy.model.io.jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Spectra
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.flagShiftFFT = True    #Data is always shifted
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     self.flagDiscontinuousBlock = 0

schainpy/model/io/jroIO_usrp.py +24 -24

             try:
                 import digital_rf_hdf5
             except:
-                print 'You should install "digital_rf_hdf5" module if you want to read USRP data'
+                print('You should install "digital_rf_hdf5" module if you want to read USRP data')
             class USRPReader(ProcessingUnit):
                 '''
                     '''
                     if not os.path.isdir(path):
-                        raise ValueError, "[Reading] Directory %s does not exist" %path
+                        raise ValueError("[Reading] Directory %s does not exist" %path)
                     try:
                         self.digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
                     channelNameList = self.digitalReadObj.get_channels()
                     if not channelNameList:
-                        raise ValueError, "[Reading] Directory %s does not have any files" %path
+                        raise ValueError("[Reading] Directory %s does not have any files" %path)
                     if not channelList:
-                        channelList = range(len(channelNameList))
+                        channelList = list(range(len(channelNameList)))
                     ##########  Reading metadata ######################
                         self.__frequency = this_metadata_file['fc'].value
                     if not self.__frequency:
-                        raise ValueError, "Center Frequency is not defined in metadata file"
+                        raise ValueError("Center Frequency is not defined in metadata file")
                     try:
                         self.__timezone = this_metadata_file['timezone'].value
                     if not nSamples:
                         if not ippKm:
-                            raise ValueError, "[Reading] nSamples or ippKm should be defined"
+                            raise ValueError("[Reading] nSamples or ippKm should be defined")
                         nSamples = int(ippKm / (1e6*0.15/self.__sample_rate))
                     self.__setFileHeader()
                     self.isConfig = True
-                    print "[Reading] USRP Data was found from %s to %s " %(
+                    print("[Reading] USRP Data was found from %s to %s " %(
                                                                   datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                                                                   datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
+                                                                  ))
-                    print "[Reading] Starting process from %s to %s" %(datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
+                    print("[Reading] Starting process from %s to %s" %(datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                        datetime.datetime.utcfromtimestamp(endUTCSecond - self.__timezone)
+                                                                       ))
                 def __reload(self):
             #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
             #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
             #                                           )
-                    print "[Reading] reloading metadata ..."
+                    print("[Reading] reloading metadata ...")
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     if end_index > self.__endUTCSecond*self.__sample_rate:
                         self.__endUTCSecond = 1.0*end_index/self.__sample_rate
-                        print
+                        print()
-                        print "[Reading] New timerange found [%s, %s] " %(
+                        print("[Reading] New timerange found [%s, %s] " %(
                                                                   datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                                                                   datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
+                                                                  ))
                         return True
                     self.__thisUnixSample += self.__samples_to_read
                     if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
-                        print "[Reading] There are no more data into selected time-range"
+                        print("[Reading] There are no more data into selected time-range")
                         self.__reload()
                                                                           self.__samples_to_read,
                                                                           thisChannelName)
-                        except IOError, e:
+                        except IOError as e:
                             #read next profile
                             self.__flagDiscontinuousBlock = True
-                            print "[Reading] %s" %datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e
+                            print("[Reading] %s" %datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                             break
                         if result.shape[0] != self.__samples_to_read:
                             self.__flagDiscontinuousBlock = True
-                            print "[Reading] %s: Too few samples were found, just %d/%d  samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                            print("[Reading] %s: Too few samples were found, just %d/%d  samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                             result.shape[0],
-                                                                                            self.__samples_to_read)
+                                                                                            self.__samples_to_read))
                             break
                         self.__data_buffer[indexChannel,:] = result*volt_scale
                     if not dataOk:
                         return False
-                    print "[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
+                    print("[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                      self.__samples_to_read,
-                                                                     self.__timeInterval)
+                                                                     self.__timeInterval))
                     self.__bufferIndex = 0
                                 return False
                             if self.__flagDiscontinuousBlock:
-                                print '[Reading] discontinuous block found ... continue with the next block'
+                                print('[Reading] discontinuous block found ... continue with the next block')
                                 continue
                             if not self.__online:
                             if err_counter > nTries:
                                 return False
-                            print '[Reading] waiting %d seconds to read a new block' %seconds
+                            print('[Reading] waiting %d seconds to read a new block' %seconds)
                             sleep(seconds)
                     self.dataOut.data = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex+self.__nSamples]
                     '''
                     '''
-                    print self.profileIndex
+                    print(self.profileIndex)
                 def run(self, **kwargs):
                     '''

schainpy/model/io/jroIO_usrp_api.py +5 -5

             '''
             import time
             import threading
-            import cPickle
+            import pickle
             # try:
             #     from gevent import sleep
                     '''
                     if not self.isConfig:
-                        raise RuntimeError, 'setup() method has to be called before start()'
+                        raise RuntimeError('setup() method has to be called before start()')
-                    print "Running ..."
+                    print("Running ...")
                     while True:
                         if not self.getData():
                             break
-                        print ".",
+                        print(".", end=' ')
                         self.__mySerial = obj2Serial(self.dataOut,
                                                      keyList = self.__DATAKEYLIST,
             #             sleep(0.1)
-                    print "Closing thread"
+                    print("Closing thread")
                     return

schainpy/model/io/jroIO_voltage.py +10 -10

             import numpy
-            from jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
+            from .jroIO_base import LOCALTIME, JRODataReader, JRODataWriter
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jrodata import Voltage
             import zmq
             import tempfile
-            from StringIO import StringIO
+            from io import StringIO
             # from _sha import blocksize
                     self.dataOut.heightList = numpy.arange(
                         self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
-                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                         return
                     if self.nTxs < 1 and self.processingHeaderObj.profilesPerBlock % (1. / self.nTxs) != 0:
-                        raise ValueError, "1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
+                        raise ValueError("1./nTxs (=%f), should be a multiple of nProfiles (=%d)" % (
-. / self.nTxs, self.processingHeaderObj.profilesPerBlock)
+. / self.nTxs, self.processingHeaderObj.profilesPerBlock))
                     if self.nTxs > 1 and self.processingHeaderObj.nHeights % self.nTxs != 0:
-                        raise ValueError, "nTxs (=%d), should be a multiple of nHeights (=%d)" % (
+                        raise ValueError("nTxs (=%d), should be a multiple of nHeights (=%d)" % (
-                            self.nTxs, self.processingHeaderObj.nHeights)
+                            self.nTxs, self.processingHeaderObj.nHeights))
                     self.datablock = self.datablock.reshape(
                         (self.systemHeaderObj.nChannels, self.processingHeaderObj.profilesPerBlock * self.nTxs, self.processingHeaderObj.nHeights / self.nTxs))
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
-                        raise ValueError, 'Data type was not defined'
+                        raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.readFirstHeaderFromServer()
                     timestamp = self.basicHeaderObj.get_datatime()
-                    print '[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp)
+                    print('[Reading] - Block {} - {}'.format(self.nTotalBlocks, timestamp))
                     current_pointer_location = self.blockPointer
                     junk = numpy.fromstring(
                         block[self.blockPointer:], self.dtype, self.blocksize)
                     """
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
-                        print 'Process finished'
+                        print('Process finished')
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0

schainpy/model/io/julIO_param.py +1 -1

                     self.format = format
                     if self.path is None:
-                        raise ValueError, "The path is not valid"
+                        raise ValueError("The path is not valid")
                     if ext is None:
                         ext = self.ext

schainpy/model/io/pxIO_param.py +5 -6

             import numpy
-            from utils import folder_in_range
+            from .utils import folder_in_range
             from schainpy.model.io.jroIO_base import JRODataReader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
                     self.ele = kwargs.get('ext', '')
                     if self.path is None:
-                        raise ValueError, 'The path is not valid'
+                        raise ValueError('The path is not valid')
                     self.search_files(path, startDate, endDate, startTime, endTime, walk)
                     self.cursor = 0
                     self.counter_records = 0
                     if not self.files:
-                        raise  Warning, 'There is no files matching these date in the folder: {}. \n Check startDate and endDate'.format(path)
+                        raise  Warning('There is no files matching these date in the folder: {}. \n Check startDate and endDate'.format(path))
                 def search_files(self, path, startDate, endDate, startTime, endTime, walk):
                     '''
                             self.files[dt] = []
                         self.files[dt].append(fullname)
-                    self.dates = self.files.keys()
+                    self.dates = list(self.files.keys())
                     self.dates.sort()
                     return
                     if not self.files:
                         return 0
-                    self.dates = self.files.keys()
+                    self.dates = list(self.files.keys())
                     self.dates.sort()
                     self.cursor = 0
                     self.set_output()
                     return 1

schainpy/model/proc/__init__.py +10 -10

@@ -4,13 +4,13 $Author: murco $
4	$Id: Processor.py 1 2012-11-12 18:56:07Z murco $	4	$Id: Processor.py 1 2012-11-12 18:56:07Z murco $
5	'''	5	'''
6		6
7	from jroproc_voltage import *	7	from .jroproc_voltage import *
8	from jroproc_spectra import *	8	from .jroproc_spectra import *
9	from jroproc_heispectra import *	9	from .jroproc_heispectra import *
10	from jroproc_amisr import *	10	from .jroproc_amisr import *
11	from jroproc_correlation import *	11	from .jroproc_correlation import *
12	from jroproc_parameters import *	12	from .jroproc_parameters import *
13	from jroproc_spectra_lags import *	13	from .jroproc_spectra_lags import *
14	from jroproc_spectra_acf import *	14	from .jroproc_spectra_acf import *
15	from bltrproc_parameters import *	15	from .bltrproc_parameters import *
16	from pxproc_parameters import *	16	from .pxproc_parameters import *

schainpy/model/proc/bltrproc_parameters.py +2 -3

             from numpy import transpose
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Parameters
                         npoints    - number of points for mask filter
                     '''
-                    print '    Outliers Filter {} {} / threshold = {}'.format(svalue, svalue, factor)
+                    print('    Outliers Filter {} {} / threshold = {}'.format(svalue, svalue, factor))
                     yaxis = self.dataOut.heightList
                     return startDTList, data_fHeigths_List, data_fZonal_List, data_fMeridional_List, data_fVertical_List
-  No newline at end of file

schainpy/model/proc/jroproc_amisr.py +13 -13

             @author: Daniel Suarez
             '''
             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jroamisr import AMISR
             class AMISRProc(ProcessingUnit):
                 def run(self, dataOut):
                     if not self.__isPrinted:
-                        print 'Number of Records by File: %d'%dataOut.nRecords
+                        print('Number of Records by File: %d'%dataOut.nRecords)
-                        print 'Number of Pulses: %d'%dataOut.nProfiles
+                        print('Number of Pulses: %d'%dataOut.nProfiles)
-                        print 'Number of Pulses by Frame: %d'%dataOut.npulseByFrame
+                        print('Number of Pulses by Frame: %d'%dataOut.npulseByFrame)
-                        print 'Number of Samples by Pulse: %d'%len(dataOut.heightList)
+                        print('Number of Samples by Pulse: %d'%len(dataOut.heightList))
-                        print 'Ipp Seconds: %f'%dataOut.ippSeconds
+                        print('Ipp Seconds: %f'%dataOut.ippSeconds)
-                        print 'Number of Beams: %d'%dataOut.nBeams
+                        print('Number of Beams: %d'%dataOut.nBeams)
-                        print 'BeamCodes:'
+                        print('BeamCodes:')
-                        beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f,  zenith=%2.2f, gain=%2.2f'%(k,v[0],v[1],v[2],v[3]) for k,v in dataOut.beamCodeDict.items()]
+                        beamStrList = ['Beam %d -> Code=%d, azimuth=%2.2f,  zenith=%2.2f, gain=%2.2f'%(k,v[0],v[1],v[2],v[3]) for k,v in list(dataOut.beamCodeDict.items())]
                         for b in beamStrList:
-                            print b
+                            print(b)
                         self.__isPrinted = True
                     return
                         return 1
                     else:
-                        raise ValueError, "BeamSelector needs beam value"
+                        raise ValueError("BeamSelector needs beam value")
                     return 0
                     dataOut.flagNoData = True
                     if not(self.__isConfig):
-                        nchannels = len(dataOut.beamRangeDict.keys())
+                        nchannels = len(list(dataOut.beamRangeDict.keys()))
                         nsamples = dataOut.nHeights
                         self.buffer = numpy.zeros((nchannels, nsamples), dtype = 'complex128')
                         dataOut.beam.codeList = [dataOut.beamCodeDict[x][0] for x in range(nchannels)]
                     if self.__counter_chan >= self.buffer.shape[0]:
                         self.__counter_chan = 0
                         dataOut.data = self.buffer.copy()
-                        dataOut.channelList = range(self.buffer.shape[0])
+                        dataOut.channelList = list(range(self.buffer.shape[0]))
                         self.__isConfig = False
                         dataOut.flagNoData = False
                     pass

schainpy/model/proc/jroproc_base.py +6 -6

                 def getOperationObj(self, objId):
-                    if objId not in self.operations2RunDict.keys():
+                    if objId not in list(self.operations2RunDict.keys()):
                         return None
                     return self.operations2RunDict[objId]
                     if opType == 'self':
                         if not opName:
-                            raise ValueError, "opName parameter should be defined"
+                            raise ValueError("opName parameter should be defined")
                         sts = self.callMethod(opName, opId)
                     elif opType == 'other' or opType == 'external' or opType == 'plotter':
                         if not opId:
-                            raise ValueError, "opId parameter should be defined"
+                            raise ValueError("opId parameter should be defined")
-                        if opId not in self.operations2RunDict.keys():
+                        if opId not in list(self.operations2RunDict.keys()):
-                            raise ValueError, "Any operation with id=%s has been added" %str(opId)
+                            raise ValueError("Any operation with id=%s has been added" %str(opId))
                         sts = self.callObject(opId)
                     else:
-                        raise ValueError, "opType should be 'self', 'external' or 'plotter'; and not '%s'" %opType
+                        raise ValueError("opType should be 'self', 'external' or 'plotter'; and not '%s'" %opType)
                     return sts

schainpy/model/proc/jroproc_correlation.py +1 -1

             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Correlation, hildebrand_sekhon
             class CorrelationProc(ProcessingUnit):

schainpy/model/proc/jroproc_heispectra.py +5 -5

             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import SpectraHeis
             class SpectraHeisProc(ProcessingUnit):
                         return
-                    raise ValueError, "The type object %s is not valid"%(self.dataIn.type)
+                    raise ValueError("The type object %s is not valid"%(self.dataIn.type))
                 def selectChannels(self, channelList):
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            print channelIndexList
+                            print(channelIndexList)
-                            raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
+                            raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
             #         nChannels = len(channelIndexList)
                     if n == None and timeInterval == None:
-                        raise ValueError, "n or timeInterval should be specified ..."
+                        raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n

schainpy/model/proc/jroproc_parameters.py +75 -77

             import itertools
             from multiprocessing import Pool, TimeoutError
             from multiprocessing.pool import ThreadPool
-            import copy_reg
-            import cPickle
             import types
             from functools import partial
             import time
             from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Parameters, hildebrand_sekhon
             from scipy import asarray as ar,exp
             from scipy.optimize import curve_fit
             '''solving pickling issue'''
             def _pickle_method(method):
-                func_name = method.im_func.__name__
+                func_name = method.__func__.__name__
-                obj = method.im_self
+                obj = method.__self__
-                cls = method.im_class
+                cls = method.__self__.__class__
                 return _unpickle_method, (func_name, obj, cls)
             def _unpickle_method(func_name, obj, cls):
                     self.spc = dataOut.data_pre[0].copy()
-                    print 'SelfSpectra Shape', numpy.asarray(self.spc).shape
+                    print('SelfSpectra Shape', numpy.asarray(self.spc).shape)
                     #plt.figure(50)
                     pool = Pool(processes=self.Num_Chn)
                     args = [(Vrange, Ch, pnoise, noise_, num_intg, SNRlimit) for Ch in range(self.Num_Chn)]
                     objs = [self for __ in range(self.Num_Chn)]
-                    attrs = zip(objs, args)
+                    attrs = list(zip(objs, args))
                     gauSPC = pool.map(target, attrs)
                     dataOut.GauSPC = numpy.asarray(gauSPC)
             #         ret = []
             #             print 'noise', noise
             #             print 's_noise', wnoise
-                    print '========================================================'
+                    print('========================================================')
-                    print 'total_time: ', time.time()-start_time
+                    print('total_time: ', time.time()-start_time)
                             # re-normalizing spc and noise
                             # This part differs from gg1
                     dataOut.data_output = Ze
                     dataOut.data_param = numpy.ones([2,self.Num_Hei])
                     dataOut.channelList = [0,1]
-                    print 'channelList', dataOut.channelList
+                    print('channelList', dataOut.channelList)
                     dataOut.data_param[0]=dBZe
                     dataOut.data_param[1]=dBRR
-                    print 'RR SHAPE', dBRR.shape
+                    print('RR SHAPE', dBRR.shape)
-                    print 'Ze SHAPE', dBZe.shape
+                    print('Ze SHAPE', dBZe.shape)
-                    print 'dataOut.data_param SHAPE', dataOut.data_param.shape
+                    print('dataOut.data_param SHAPE', dataOut.data_param.shape)
                 def dBZeMODE2(self, dataOut): #    Processing for MIRA35C
                     data_output = numpy.ones([self.Num_Chn , self.Num_Hei])*numpy.NaN
                     ETA = numpy.sum(SNR,1)
-                    print 'ETA' , ETA
+                    print('ETA' , ETA)
                     ETA = numpy.where(ETA is not 0. , ETA, numpy.NaN)
                     Ze = numpy.ones([self.Num_Chn, self.Num_Hei] )
                     data = dataOut.data_pre
                     noise = dataOut.noise
-                    print 'noise',noise
+                    print('noise',noise)
                     #SNRdB = 10*numpy.log10(dataOut.data_SNR)
                     FirstMoment = numpy.average(dataOut.data_param[:,1,:],0)
                             velocityX=numpy.append(velocityX, Vzon)#Vmag
                         else:
-                            print 'Vzon',Vzon
+                            print('Vzon',Vzon)
                             velocityX=numpy.append(velocityX, numpy.NaN)
                         if abs(Vmer)<100. and abs(Vmer) > 0.:
                             velocityY=numpy.append(velocityY, Vmer)#Vang
                         else:
-                            print 'Vmer',Vmer
+                            print('Vmer',Vmer)
                             velocityY=numpy.append(velocityY, numpy.NaN)
                         if dbSNR[Height] > SNRlimit:
                     data_output[1]=numpy.array(velocityY)
                     data_output[2]=-velocityV#FirstMoment
-                    print ' '
+                    print(' ')
                     #print 'FirstMoment'
                     #print FirstMoment
-                    print 'velocityX',data_output[0]
+                    print('velocityX',data_output[0])
-                    print ' '
+                    print(' ')
-                    print 'velocityY',data_output[1]
+                    print('velocityY',data_output[1])
                     #print numpy.array(velocityY)
-                    print ' '
+                    print(' ')
                     #print 'SNR'
                     #print 10*numpy.log10(dataOut.data_SNR)
                     #print numpy.shape(10*numpy.log10(dataOut.data_SNR))
-                    print ' '
+                    print(' ')
                     dataOut.data_output=data_output
                         SmoothSPC=self.moving_average(FactNorm,N=3)
-                        xSamples = ar(range(len(SmoothSPC)))
+                        xSamples = ar(list(range(len(SmoothSPC))))
                         ySamples[i] = SmoothSPC
                     #dbSNR=10*numpy.log10(dataSNR)
-                    print ' '
+                    print(' ')
-                    print ' '
+                    print(' ')
-                    print ' '
+                    print(' ')
                     #print 'dataSNR', dbSNR.shape, dbSNR[0,40:120]
-                    print 'SmoothSPC', SmoothSPC.shape, SmoothSPC[0:20]
+                    print('SmoothSPC', SmoothSPC.shape, SmoothSPC[0:20])
-                    print 'noise',noise
+                    print('noise',noise)
-                    print 'zline',zline.shape, zline[0:20]
+                    print('zline',zline.shape, zline[0:20])
-                    print 'FactNorm',FactNorm.shape, FactNorm[0:20]
+                    print('FactNorm',FactNorm.shape, FactNorm[0:20])
-                    print 'FactNorm suma', numpy.sum(FactNorm)
+                    print('FactNorm suma', numpy.sum(FactNorm))
                     for i in range(spc.shape[0]):
                         phase[i] = self.moving_average( numpy.arctan2(CSPCSamples[i].imag, CSPCSamples[i].real),N=1)#*180/numpy.pi
-                    print 'cspcLine', cspcLine.shape, cspcLine[0:20]
+                    print('cspcLine', cspcLine.shape, cspcLine[0:20])
-                    print 'CSPCFactor', CSPCFactor#, CSPCFactor[0:20]
+                    print('CSPCFactor', CSPCFactor)#, CSPCFactor[0:20]
-                    print numpy.sum(ySamples[chan_index0]), numpy.sum(ySamples[chan_index1]), -noise[i]
+                    print(numpy.sum(ySamples[chan_index0]), numpy.sum(ySamples[chan_index1]), -noise[i])
-                    print 'CSPCNorm', CSPCNorm.shape, CSPCNorm[0:20]
+                    print('CSPCNorm', CSPCNorm.shape, CSPCNorm[0:20])
-                    print 'CSPCNorm suma', numpy.sum(CSPCNorm)
+                    print('CSPCNorm suma', numpy.sum(CSPCNorm))
-                    print 'CSPCSamples', CSPCSamples.shape, CSPCSamples[0,0:20]
+                    print('CSPCSamples', CSPCSamples.shape, CSPCSamples[0,0:20])
                     '''****** Getting fij width ******'''
                     meanGauss=sum(xSamples*yMean) / len(xSamples)
                     sigma=sum(yMean*(xSamples-meanGauss)**2) / len(xSamples)
-                    print '****************************'
+                    print('****************************')
-                    print 'len(xSamples): ',len(xSamples)
+                    print('len(xSamples): ',len(xSamples))
-                    print 'yMean: ', yMean.shape, yMean[0:20]
+                    print('yMean: ', yMean.shape, yMean[0:20])
-                    print 'ySamples', ySamples.shape, ySamples[0,0:20]
+                    print('ySamples', ySamples.shape, ySamples[0,0:20])
-                    print 'xSamples: ',xSamples.shape, xSamples[0:20]
+                    print('xSamples: ',xSamples.shape, xSamples[0:20])
-                    print 'meanGauss',meanGauss
+                    print('meanGauss',meanGauss)
-                    print 'sigma',sigma
+                    print('sigma',sigma)
                     #if (abs(meanGauss/sigma**2) > 0.0001) : #0.000000001):
                     if dbSNR > SNRlimit :
                             else:
                                 FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
-                                print 'Verificador:     Dentro', Height
+                                print('Verificador:     Dentro', Height)
                         except :#RuntimeError:
                             FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
                     else:
                         Range = numpy.array([0,0])
-                    print ' '
+                    print(' ')
-                    print 'GCpos',GCpos, ( len(xFrec)- len(xFrec)*0.1)
+                    print('GCpos',GCpos, ( len(xFrec)- len(xFrec)*0.1))
-                    print 'Rangpos',Rangpos
+                    print('Rangpos',Rangpos)
-                    print 'RANGE: ', Range
+                    print('RANGE: ', Range)
                     FrecRange=xFrec[Range[0]:Range[1]]
                     '''****** Getting SCPC Slope ******'''
                         if len(FrecRange)>5 and len(FrecRange)<spc.shape[1]*0.5:
                             PhaseRange=self.moving_average(phase[i,Range[0]:Range[1]],N=3)
-                            print 'FrecRange', len(FrecRange) , FrecRange
+                            print('FrecRange', len(FrecRange) , FrecRange)
-                            print 'PhaseRange', len(PhaseRange), PhaseRange
+                            print('PhaseRange', len(PhaseRange), PhaseRange)
-                            print ' '
+                            print(' ')
                             if len(FrecRange) == len(PhaseRange):
                                 slope, intercept, r_value, p_value, std_err = stats.linregress(FrecRange,PhaseRange)
                                 PhaseSlope[i]=slope
                         Vmag=numpy.sqrt(Vzon**2+Vmer**2)
                         Vang=numpy.arctan2(Vmer,Vzon)
                         Vver=xFrec[Vpos]
-                    print 'vzon y vmer', Vzon, Vmer
+                    print('vzon y vmer', Vzon, Vmer)
                     return Vzon, Vmer, Vver, GaussCenter
             class SpectralMoments(Operation):
                         else:   spec2 = scipy.ndimage.filters.uniform_filter1d(spec,size=smooth)
                         #    Calculo de Momentos
-                        bb = spec2[range(m,spec2.size)]
+                        bb = spec2[list(range(m,spec2.size))]
                         bb = (bb<n0).nonzero()
                         bb = bb[0]
-                        ss = spec2[range(0,m + 1)]
+                        ss = spec2[list(range(0,m + 1))]
                         ss = (ss<n0).nonzero()
                         ss = ss[0]
                         if (ss1 > m):   ss1 = m
-                        valid = numpy.asarray(range(int(m + bb0 - ss1 + 1))) + ss1
+                        valid = numpy.asarray(list(range(int(m + bb0 - ss1 + 1)))) + ss1
                         power = ((spec2[valid] - n0)*fwindow[valid]).sum()
                         fd = ((spec2[valid]- n0)*freq[valid]*fwindow[valid]).sum()/power
                         w = math.sqrt(((spec2[valid] - n0)*fwindow[valid]*(freq[valid]- fd)**2).sum()/power)
                     maxid = listPhi.index(max(listPhi))
                     minid = listPhi.index(min(listPhi))
-                    rango = range(len(phi))
+                    rango = list(range(len(phi)))
                #     rango = numpy.delete(rango,maxid)
                     heiRang1 = heiRang*math.cos(phi[maxid])
                     heiRang = kwargs['heightList']
                     SNR0 = kwargs['SNR']
-                    if kwargs.has_key('dirCosx') and kwargs.has_key('dirCosy'):
+                    if 'dirCosx' in kwargs and 'dirCosy' in kwargs:
                         theta_x = numpy.array(kwargs['dirCosx'])
                         theta_y = numpy.array(kwargs['dirCosy'])
                     else:
                         azim = numpy.array(kwargs['azimuth'])
                         theta_x, theta_y = self.__calculateCosDir(elev, azim)
                     azimuth = kwargs['correctAzimuth']
-                    if kwargs.has_key('horizontalOnly'):
+                    if 'horizontalOnly' in kwargs:
                         horizontalOnly = kwargs['horizontalOnly']
                     else:   horizontalOnly = False
-                    if kwargs.has_key('correctFactor'):
+                    if 'correctFactor' in kwargs:
                         correctFactor = kwargs['correctFactor']
                     else:   correctFactor = 1
-                    if kwargs.has_key('channelList'):
+                    if 'channelList' in kwargs:
                         channelList = kwargs['channelList']
                         if len(channelList) == 2:
                             horizontalOnly = True
                     position_y = kwargs['positionY']
                     azimuth = kwargs['azimuth']
-                    if kwargs.has_key('correctFactor'):
+                    if 'correctFactor' in kwargs:
                         correctFactor = kwargs['correctFactor']
                     else:
                         correctFactor = 1
                         dataOut.flagNoData = True
                         self.__dataReady = False
-                        if kwargs.has_key('nHours'):
+                        if 'nHours' in kwargs:
                             nHours = kwargs['nHours']
                         else:
                             nHours = 1
-                        if kwargs.has_key('meteorsPerBin'):
+                        if 'meteorsPerBin' in kwargs:
                             meteorThresh = kwargs['meteorsPerBin']
                         else:
                             meteorThresh = 6
-                        if kwargs.has_key('hmin'):
+                        if 'hmin' in kwargs:
                             hmin = kwargs['hmin']
                         else:   hmin = 70
-                        if kwargs.has_key('hmax'):
+                        if 'hmax' in kwargs:
                             hmax = kwargs['hmax']
                         else:   hmax = 110
                         dataOut.flagNoData = True
                         self.__dataReady = False
-                        if kwargs.has_key('nMins'):
+                        if 'nMins' in kwargs:
                             nMins = kwargs['nMins']
                         else: nMins = 20
-                        if kwargs.has_key('rx_location'):
+                        if 'rx_location' in kwargs:
                             rx_location = kwargs['rx_location']
                         else: rx_location = [(0,1),(1,1),(1,0)]
-                        if kwargs.has_key('azimuth'):
+                        if 'azimuth' in kwargs:
                             azimuth = kwargs['azimuth']
                         else: azimuth = 51.06
-                        if kwargs.has_key('dfactor'):
+                        if 'dfactor' in kwargs:
                             dfactor = kwargs['dfactor']
-                        if kwargs.has_key('mode'):
+                        if 'mode' in kwargs:
                             mode = kwargs['mode']
-                        if kwargs.has_key('theta_x'):
+                        if 'theta_x' in kwargs:
                             theta_x = kwargs['theta_x']
-                        if kwargs.has_key('theta_y'):
+                        if 'theta_y' in kwargs:
                             theta_y = kwargs['theta_y']
                         else: mode = 'SA'
                     maxid = listPhi.index(max(listPhi))
                     minid = listPhi.index(min(listPhi))
-                    rango = range(len(phi))
+                    rango = list(range(len(phi)))
                #     rango = numpy.delete(rango,maxid)
                     heiRang1 = heiRang*math.cos(phi[maxid])
                 def getPhasePairs(self, channelPositions):
                     chanPos = numpy.array(channelPositions)
-                    listOper = list(itertools.combinations(range(5),2))
+                    listOper = list(itertools.combinations(list(range(5)),2))
                     distances = numpy.zeros(4)
                     axisX = []

schainpy/model/proc/jroproc_spectra.py +45 -44

             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
+            from schainpy.utils import log #yong
             class SpectraProc(ProcessingUnit):
                             (self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
+                                raise ValueError("Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
-                                    str(pair), str(self.dataOut.channelList))
+                                    str(pair), str(self.dataOut.channelList)))
                             if pair[1] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
+                                raise ValueError("Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
-                                    str(pair), str(self.dataOut.channelList))
+                                    str(pair), str(self.dataOut.channelList)))
                             cspc[pairIndex, :, :] = fft_volt[pair[0], :, :] * \
                                 numpy.conjugate(fft_volt[pair[1], :, :])
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
-                            raise ValueError, "This SpectraProc.run() need nFFTPoints input variable"
+                            raise ValueError("This SpectraProc.run() need nFFTPoints input variable")
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
-                                raise ValueError, "The type object %s has %d profiles, it should just has %d profiles" % (
+                                raise ValueError("The type object %s has %d profiles, it should just has %d profiles" % (
-                                    self.dataIn.type, self.dataIn.data.shape[1], nProfiles)
+                                    self.dataIn.type, self.dataIn.data.shape[1], nProfiles))
                                 self.dataOut.flagNoData = True
                                 return 0
                         else:
                         return True
-                    raise ValueError, "The type of input object '%s' is not valid" % (
+                    raise ValueError("The type of input object '%s' is not valid" % (
-                        self.dataIn.type)
+                        self.dataIn.type))
                 def __selectPairs(self, pairsList):
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" % (
+                            raise ValueError("Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" % (
-                                channel, str(self.dataOut.channelList))
+                                channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " % (
+                            raise ValueError("Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " % (
-                                channelIndex, self.dataOut.channelIndexList)
+                                channelIndex, self.dataOut.channelIndexList))
             #         nChannels = len(channelIndexList)
                     """
                     if (minHei > maxHei):
-                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (
+                        raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (
-                            minHei, maxHei)
+                            minHei, maxHei))
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (
+                        raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
-                            minIndex, maxIndex)
+                            minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     else:
                         jcspectraExist = False
-                    freq_dc = jspectra.shape[1] / 2
+                    freq_dc = int(jspectra.shape[1] / 2)
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
+                    ind_vel = ind_vel.astype(int)
                     if ind_vel[0] < 0:
-                        ind_vel[range(0, 1)] = ind_vel[range(0, 1)] + self.num_prof
+                        ind_vel[list(range(0, 1))] = ind_vel[list(range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
-                            xx[fil, :] = vel[fil]**numpy.asarray(range(4))
+                            xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                     # hei_interf
                     if hei_interf is None:
                         count_hei = num_hei / 2  # Como es entero no importa
-                        hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
+                        hei_interf = numpy.asmatrix(list(range(count_hei))) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     # nhei_interf
                     if (nhei_interf == None):
                     if (offhei_interf == None):
                         offhei_interf = 0
-                    ind_hei = range(num_hei)
+                    ind_hei = list(range(num_hei))
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
-                    mask_prof = numpy.asarray(range(num_prof))
+                    mask_prof = numpy.asarray(list(range(num_prof)))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof / 2]
                         psort = power.ravel().argsort()
                         # Se estima la interferencia promedio en los Espectros de Potencia empleando
-                        junkspc_interf = jspectra[ich, :, hei_interf[psort[range(
+                        junkspc_interf = jspectra[ich, :, hei_interf[psort[list(range(
-                            offhei_interf, nhei_interf + offhei_interf)]]]
+                            offhei_interf, nhei_interf + offhei_interf))]]]
                         if noise_exist:
                             #    tmp_noise = jnoise[ich] / num_prof
                             xx = numpy.zeros([4, 4])
                             for id1 in range(4):
-                                xx[:, id1] = ind[id1]**numpy.asarray(range(4))
+                                xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:, 0]
                         cspower = cspower.sum(axis=0)
                         cspsort = cspower.ravel().argsort()
-                        junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[range(
+                        junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[list(range(
-                            offhei_interf, nhei_interf + offhei_interf)]]]
+                            offhei_interf, nhei_interf + offhei_interf))]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
                         median_real = numpy.median(numpy.real(
-                            junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
+                            junkcspc_interf[mask_prof[ind[list(range(3 * num_prof / 4))]], :]))
                         median_imag = numpy.median(numpy.imag(
-                            junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
+                            junkcspc_interf[mask_prof[ind[list(range(3 * num_prof / 4))]], :]))
                         junkcspc_interf[comp_mask_prof, :] = numpy.complex(
                             median_real, median_imag)
                         xx = numpy.zeros([4, 4])
                         for id1 in range(4):
-                            xx[:, id1] = ind[id1]**numpy.asarray(range(4))
+                            xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:, 0]
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
-                        print 'minHei: %.2f is out of the heights range' % (minHei)
+                        print('minHei: %.2f is out of the heights range' % (minHei))
-                        print 'minHei is setting to %.2f' % (self.dataOut.heightList[0])
+                        print('minHei is setting to %.2f' % (self.dataOut.heightList[0]))
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
-                        print 'maxHei: %.2f is out of the heights range' % (maxHei)
+                        print('maxHei: %.2f is out of the heights range' % (maxHei))
-                        print 'maxHei is setting to %.2f' % (self.dataOut.heightList[-1])
+                        print('maxHei is setting to %.2f' % (self.dataOut.heightList[-1]))
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
-                        print 'minVel: %.2f is out of the velocity range' % (minVel)
+                        print('minVel: %.2f is out of the velocity range' % (minVel))
-                        print 'minVel is setting to %.2f' % (velrange[0])
+                        print('minVel is setting to %.2f' % (velrange[0]))
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
-                        print 'maxVel: %.2f is out of the velocity range' % (maxVel)
+                        print('maxVel: %.2f is out of the velocity range' % (maxVel))
-                        print 'maxVel is setting to %.2f' % (velrange[-1])
+                        print('maxVel is setting to %.2f' % (velrange[-1]))
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (
+                        raise ValueError("some value in (%d,%d) is not valid" % (
-                            minIndex, maxIndex)
+                            minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     self.__byTime = False
                     if n is None and timeInterval is None:
-                        raise ValueError, "n or timeInterval should be specified ..."
+                        raise ValueError("n or timeInterval should be specified ...")
                     if n is not None:
                         self.n = int(n)

schainpy/model/proc/jroproc_spectra_acf.py +30 -30

             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError("Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList)))
                             if pair[1] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError("Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList)))
                             chan_index0 = self.dataOut.channelList.index(pair[0])
                             chan_index1 = self.dataOut.channelList.index(pair[1])
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
-                            raise ValueError, "This SpectraProc.run() need nFFTPoints input variable"
+                            raise ValueError("This SpectraProc.run() need nFFTPoints input variable")
                         if nProfiles == None:
                             nProfiles = nFFTPoints
             #                 self.profIndex += 1
                         else:
-                            raise ValueError, ""
+                            raise ValueError("")
                         self.firstdatatime = self.dataIn.utctime
                         return True
-                    raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
+                    raise ValueError("The type of input object '%s' is not valid"%(self.dataIn.type))
                 def __selectPairs(self, pairsList):
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
+                            raise ValueError("Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
+                            raise ValueError("Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList))
             #         nChannels = len(channelIndexList)
                     """
                     if (minHei > maxHei):
-                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
+                        raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei))
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
-                        ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
+                        ind_vel[list(range(0,1))] = ind_vel[list(range(0,1))] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
-                            xx[fil,:] = vel[fil]**numpy.asarray(range(4))
+                            xx[fil,:] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                     #hei_interf
                     if hei_interf is None:
                         count_hei = num_hei/2   #Como es entero no importa
-                        hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
+                        hei_interf = numpy.asmatrix(list(range(count_hei))) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     #nhei_interf
                     if (nhei_interf == None):
                     if (offhei_interf == None):
                         offhei_interf = 0
-                    ind_hei = range(num_hei)
+                    ind_hei = list(range(num_hei))
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
-                    mask_prof = numpy.asarray(range(num_prof))
+                    mask_prof = numpy.asarray(list(range(num_prof)))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof/2]
                         psort = power.ravel().argsort()
                         #Se estima la interferencia promedio en los Espectros de Potencia empleando
-                        junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkspc_interf = jspectra[ich,:,hei_interf[psort[list(range(offhei_interf, nhei_interf + offhei_interf))]]]
                         if noise_exist:
                         #    tmp_noise = jnoise[ich] / num_prof
                             xx = numpy.zeros([4,4])
                             for id1 in range(4):
-                                xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                                xx[:,id1] = ind[id1]**numpy.asarray(list(range(4)))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:,0]
                         cspower = cspower.sum(axis = 0)
                         cspsort = cspower.ravel().argsort()
-                        junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[list(range(offhei_interf, nhei_interf + offhei_interf))]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis = 1)/nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
-                        median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                        median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[list(range(3*num_prof/4))]],:]))
-                        median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                        median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[list(range(3*num_prof/4))]],:]))
                         junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
                         for iprof in range(num_prof):
                         xx = numpy.zeros([4,4])
                         for id1 in range(4):
-                            xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                            xx[:,id1] = ind[id1]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:,0]
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
-                        print 'minHei: %.2f is out of the heights range'%(minHei)
+                        print('minHei: %.2f is out of the heights range'%(minHei))
-                        print 'minHei is setting to %.2f'%(self.dataOut.heightList[0])
+                        print('minHei is setting to %.2f'%(self.dataOut.heightList[0]))
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
-                        print 'maxHei: %.2f is out of the heights range'%(maxHei)
+                        print('maxHei: %.2f is out of the heights range'%(maxHei))
-                        print 'maxHei is setting to %.2f'%(self.dataOut.heightList[-1])
+                        print('maxHei is setting to %.2f'%(self.dataOut.heightList[-1]))
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
-                        print 'minVel: %.2f is out of the velocity range'%(minVel)
+                        print('minVel: %.2f is out of the velocity range'%(minVel))
-                        print 'minVel is setting to %.2f'%(velrange[0])
+                        print('minVel is setting to %.2f'%(velrange[0]))
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
-                        print 'maxVel: %.2f is out of the velocity range'%(maxVel)
+                        print('maxVel: %.2f is out of the velocity range'%(maxVel))
-                        print 'maxVel is setting to %.2f'%(velrange[-1])
+                        print('maxVel is setting to %.2f'%(velrange[-1]))
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError("some value in (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1

schainpy/model/proc/jroproc_spectra_lags.py +29 -29

             import numpy
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError("Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList)))
                             if pair[1] not in self.dataOut.channelList:
-                                raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                                raise ValueError("Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList)))
                             chan_index0 = self.dataOut.channelList.index(pair[0])
                             chan_index1 = self.dataOut.channelList.index(pair[1])
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
-                            raise ValueError, "This SpectraProc.run() need nFFTPoints input variable"
+                            raise ValueError("This SpectraProc.run() need nFFTPoints input variable")
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                         return True
-                    raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
+                    raise ValueError("The type of input object '%s' is not valid"%(self.dataIn.type))
                 def __selectPairs(self, pairsList):
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
+                            raise ValueError("Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
+                            raise ValueError("Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList))
             #         nChannels = len(channelIndexList)
                     """
                     if (minHei > maxHei):
-                        raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
+                        raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei))
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
-                        ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
+                        ind_vel[list(range(0,1))] = ind_vel[list(range(0,1))] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
-                            xx[fil,:] = vel[fil]**numpy.asarray(range(4))
+                            xx[fil,:] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                     #hei_interf
                     if hei_interf is None:
                         count_hei = num_hei/2   #Como es entero no importa
-                        hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
+                        hei_interf = numpy.asmatrix(list(range(count_hei))) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     #nhei_interf
                     if (nhei_interf == None):
                     if (offhei_interf == None):
                         offhei_interf = 0
-                    ind_hei = range(num_hei)
+                    ind_hei = list(range(num_hei))
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
-                    mask_prof = numpy.asarray(range(num_prof))
+                    mask_prof = numpy.asarray(list(range(num_prof)))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof/2]
                         psort = power.ravel().argsort()
                         #Se estima la interferencia promedio en los Espectros de Potencia empleando
-                        junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkspc_interf = jspectra[ich,:,hei_interf[psort[list(range(offhei_interf, nhei_interf + offhei_interf))]]]
                         if noise_exist:
                         #    tmp_noise = jnoise[ich] / num_prof
                             xx = numpy.zeros([4,4])
                             for id1 in range(4):
-                                xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                                xx[:,id1] = ind[id1]**numpy.asarray(list(range(4)))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:,0]
                         cspower = cspower.sum(axis = 0)
                         cspsort = cspower.ravel().argsort()
-                        junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+                        junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[list(range(offhei_interf, nhei_interf + offhei_interf))]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis = 1)/nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
-                        median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                        median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[list(range(3*num_prof/4))]],:]))
-                        median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
+                        median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[list(range(3*num_prof/4))]],:]))
                         junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
                         for iprof in range(num_prof):
                         xx = numpy.zeros([4,4])
                         for id1 in range(4):
-                            xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                            xx[:,id1] = ind[id1]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:,0]
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
-                        print 'minHei: %.2f is out of the heights range'%(minHei)
+                        print('minHei: %.2f is out of the heights range'%(minHei))
-                        print 'minHei is setting to %.2f'%(self.dataOut.heightList[0])
+                        print('minHei is setting to %.2f'%(self.dataOut.heightList[0]))
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
-                        print 'maxHei: %.2f is out of the heights range'%(maxHei)
+                        print('maxHei: %.2f is out of the heights range'%(maxHei))
-                        print 'maxHei is setting to %.2f'%(self.dataOut.heightList[-1])
+                        print('maxHei is setting to %.2f'%(self.dataOut.heightList[-1]))
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
-                        print 'minVel: %.2f is out of the velocity range'%(minVel)
+                        print('minVel: %.2f is out of the velocity range'%(minVel))
-                        print 'minVel is setting to %.2f'%(velrange[0])
+                        print('minVel is setting to %.2f'%(velrange[0]))
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
-                        print 'maxVel: %.2f is out of the velocity range'%(maxVel)
+                        print('maxVel: %.2f is out of the velocity range'%(maxVel))
-                        print 'maxVel is setting to %.2f'%(velrange[-1])
+                        print('maxVel is setting to %.2f'%(velrange[-1]))
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError("some value in (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1

schainpy/model/proc/jroproc_voltage.py +31 -30

             import sys
             import numpy
             from scipy import interpolate
-            from schainpy import cSchain
+            #TODO
-            from jroproc_base import ProcessingUnit, Operation
+            #from schainpy import cSchain
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Voltage
             from time import time
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
-                            raise ValueError, "Channel %d is not in %s" %(channel, str(self.dataOut.channelList))
+                            raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
-                            print channelIndexList
+                            print(channelIndexList)
-                            raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
+                            raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
                     if self.dataOut.flagDataAsBlock:
                         """
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
-                        raise ValueError, "Height index range (%d,%d) is not valid" % (minIndex, maxIndex)
+                        raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
                     if self.dataOut.nHeights <= 1:
-                        raise ValueError, "selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights)
+                        raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
                     return 1
                     newheights = (self.dataOut.nHeights-r)/window
                     if newheights <= 1:
-                        raise ValueError, "filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window)
+                        raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window))
                     if self.dataOut.flagDataAsBlock:
                         """
                     if self.dataOut.flagDataAsBlock:
                         flip = self.flip
-                        profileList = range(self.dataOut.nProfiles)
+                        profileList = list(range(self.dataOut.nProfiles))
                         if not channelList:
                             for thisProfile in profileList:
                     else:
                         nHeights = self.dataOut.data.shape[2]
                         x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
-                        y = self.dataOut.data[:,:,range(botLim)+range(topLim+1,nHeights)]
+                        y = self.dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
                         f = interpolate.interp1d(x, y, axis = 2)
                         xnew = numpy.arange(botLim,topLim+1)
                         ynew = f(xnew)
                     self.stride = stride
                     if n == None and timeInterval == None:
-                        raise ValueError, "n or timeInterval should be specified ..."
+                        raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n
                     self.__nHeis = dataOut.nHeights
                     if self.__nHeis < self.nBaud:
-                        raise ValueError, 'Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud)
+                        raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
                     #Frequency
                     __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
                     junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
                     junk = junk.flatten()
                     code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
-                    profilesList = xrange(self.__nProfiles)
+                    profilesList = range(self.__nProfiles)
                     for i in range(self.__nChannels):
                         for j in profilesList:
                 def __convolutionByBlockInFreq(self, data):
-                    raise NotImplementedError, "Decoder by frequency fro Blocks not implemented"
+                    raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
                     if dataOut.flagDecodeData:
-                        print "This data is already decoded, recoding again ..."
+                        print("This data is already decoded, recoding again ...")
                     if not self.isConfig:
                         if code is None:
                             if dataOut.code is None:
-                                raise ValueError, "Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type
+                                raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
                             code = dataOut.code
                         else:
                             sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
                     if self.code is None:
-                        print "Fail decoding: Code is not defined."
+                        print("Fail decoding: Code is not defined.")
                         return
                     self.__nProfiles = dataOut.nProfiles
                             datadec = self.__convolutionInFreqOpt(dataOut.data)
                     if datadec is None:
-                        raise ValueError, "Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode
+                        raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
                     dataOut.code = self.code
                     dataOut.nCode = self.nCode
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
-                        raise ValueError, "ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False"
+                        raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
                     else:
                         self.concat(dataOut.data)
                         if profileRangeList != None:
                             minIndex = profileRangeList[0]
                             maxIndex = profileRangeList[1]
-                            profileList = range(minIndex, maxIndex+1)
+                            profileList = list(range(minIndex, maxIndex+1))
                             dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
                                 minIndex = thisRange[0]
                                 maxIndex = thisRange[1]
-                                profileList.extend(range(minIndex, maxIndex+1))
+                                profileList.extend(list(range(minIndex, maxIndex+1)))
                             dataOut.data = dataOut.data[:,profileList,:]
                         return True
-                    raise ValueError, "ProfileSelector needs profileList, profileRangeList or rangeList parameter"
+                    raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
                     return False
                 def __checkInputs(self, dataOut, shape, nTxs):
                     if shape is None and nTxs is None:
-                        raise ValueError, "Reshaper: shape of factor should be defined"
+                        raise ValueError("Reshaper: shape of factor should be defined")
                     if nTxs:
                         if nTxs < 0:
-                            raise ValueError, "nTxs should be greater than 0"
+                            raise ValueError("nTxs should be greater than 0")
                         if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
-                            raise ValueError, "nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs))
+                            raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
                         shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
                         return shape, nTxs
                     if len(shape) != 2 and len(shape) !=  3:
-                        raise ValueError, "shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights)
+                        raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
                     if len(shape) == 2:
                         shape_tuple = [dataOut.nChannels]
                                 profileIndex = dataOut.profileIndex*nTxs
                         else:
-                            raise ValueError, "nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)"
+                            raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                         shape = dataOut.data.shape
                         if shape[2] % n != 0:
-                            raise ValueError, "Could not split the data, n=%d has to be multiple of %d" %(n, shape[2])
+                            raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
                         new_shape = shape[0], shape[1]*n, shape[2]/n
                     else:
-                        raise ValueError, "Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)"
+                        raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                         new_shape = shape[0], shape[1]/n, shape[2]*n
                         if shape[1] % n != 0:
-                            raise ValueError, "Could not split the data, n=%d has to be multiple of %d" %(n, shape[1])
+                            raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False

schainpy/model/proc/pxproc_parameters.py +1 -1

             from numpy import transpose
-            from jroproc_base import ProcessingUnit, Operation
+            from .jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Parameters

schainpy/model/serializer/data.py +6 -6

             @author: Miguel Urco
             '''
-            from serializer import DynamicSerializer
+            from .serializer import DynamicSerializer
             DEFAULT_SERIALIZER = None #'cPickle', 'msgpack', "yaml"
                 if type(thisValue) != type({}):
                     return False
-                if CLASSNAME_KEY not in thisValue.keys():
+                if CLASSNAME_KEY not in list(thisValue.keys()):
                     return False
                 return True
             def obj2Dict(myObj, keyList=[]):
                 if not keyList:
-                    keyList = myObj.__dict__.keys()
+                    keyList = list(myObj.__dict__.keys())
                 myDict = {}
                 myDict[CLASSNAME_KEY] = myObj.__class__.__name__
-                for thisKey, thisValue in myObj.__dict__.items():
+                for thisKey, thisValue in list(myObj.__dict__.items()):
                     if thisKey not in keyList:
                         continue
                 '''
                 '''
-                if CLASSNAME_KEY not in myDict.keys():
+                if CLASSNAME_KEY not in list(myDict.keys()):
                     return None
                 className = eval(myDict[CLASSNAME_KEY])
                 myObj = className()
-                for thisKey, thisValue in myDict.items():
+                for thisKey, thisValue in list(myDict.items()):
                     if thisKey == CLASSNAME_KEY:
                         continue

schainpy/model/serializer/serializer.py +2 -2

             DEFAULT_SERIALIZER = None
             try:
-                import cPickle
+                import pickle
                 DEFAULT_SERIALIZER = 'cPickle'
             except:
                 pass
                 def __init__(self, module = None):
                     if not DEFAULT_SERIALIZER:
-                        raise ImportError, "Install a python serializer like cPickle or msgpack"
+                        raise ImportError("Install a python serializer like cPickle or msgpack")
                     if not module:
                         module == DEFAULT_SERIALIZER

schainpy/model/serializer/test/DynamicObject.py +31 -32

             $Id$
             '''
-            import urllib
+            import urllib.request, urllib.parse, urllib.error
             import os
             import re
             import yaml # YAML Ain't Markup Language
                     elif isinstance(object_uri, str):
                         if object_uri.endswith('.yml'):
                             # URI is a web hyper-linked yaml file - read it.
-                            self.yaml = urllib.urlopen(object_uri).read()
+                            self.yaml = urllib.request.urlopen(object_uri).read()
                         else:
                             # URI is a (hyper-linked?) directory - try reading it.
                             #print "URI is a directory."
                             for fn in self.files:
                                 self.yaml.append(Object(fn))
                     else:
-                        print "Invalid URI supplied: %s"%(object_uri,)
+                        print("Invalid URI supplied: %s"%(object_uri,))
                 def __parseLink(self, object_uri, recursive):
                     """ Returns a listing of all YAML files located in the
                     hyper-link directory given by page. """
-                    page = urllib.urlopen(object_uri).read()
+                    page = urllib.request.urlopen(object_uri).read()
                     #print "URI is a URL directory: %s"%(object_uri,)
                     pattern = re.compile(r'<a href="[^"]*">')
                     if not isinstance(obj, Object): return False
-                    self_keys = self.__dict__.keys()
+                    self_keys = list(self.__dict__.keys())
-                    obj_keys = obj.__dict__.keys()
+                    obj_keys = list(obj.__dict__.keys())
                     if not self_keys == obj_keys:
                         return False
                     for key in self_keys:
                             if not self_value.equals(obj_value, compare_time_created):
                                 return False
                         elif isinstance(self_value, np.ndarray):
-                            m1 = map(repr,self_value.flat)
+                            m1 = list(map(repr,self_value.flat))
-                            m2 = map(repr,obj_value.flat)
+                            m2 = list(map(repr,obj_value.flat))
                             ret = m1 == m2
                             if not ret:
                                 return False
                 def sizeof(self):
                     """ Recursively computes the size in bytes of the given Dynamic Object """
                     sz = 0
-                    values = self.__dict__.values()
+                    values = list(self.__dict__.values())
                     for val in values:
                         if isinstance(val, Object): sz += val.sizeof()
                         elif isinstance(val, np.ndarray): sz += val.nbytes
                     return _Reference(loader.construct_mapping(node))
                 else:
                     return _Reference(loader.construct_scalar(node))
-            add_constructor(u'!ref', __ref_constructor)
+            add_constructor('!ref', __ref_constructor)
             # Method constructor using !method tag:
             def __method_constructor(loader, node):
                     return _Method(loader.construct_mapping(node))
                 else:
                     return _Method(loader.construct_scalar(node))
-            add_constructor(u'!method', __method_constructor)
+            add_constructor('!method', __method_constructor)
             # Generic constructor for any _BuiltinDtype
             def __dtype_constructor(loader, node):
                 return ret
             # Register YAML constructors for each builtin type:
-            for dtype in Lookup.numpy_dtypes.keys() + Lookup.builtin_objects.keys():
+            for dtype in list(Lookup.numpy_dtypes.keys()) + list(Lookup.builtin_objects.keys()):
-                add_constructor(u'!%s'%(dtype,), __dtype_constructor)
+                add_constructor('!%s'%(dtype,), __dtype_constructor)
             class FactoryLoader(OrderedYAML.Loader):
                 """ A YAML Loader specifically designed to load YAML object definitions
                 def construct_yaml_timestamp(self, node):
                     """ Make empty timestamps (None/null) acceptable, otherwise parse the timestamp """
-                    if node.value == u'':
+                    if node.value == '':
                         name = 'YAML_DEFN_LOADED_INCORRECTLY' # in case we forget to fix the name...
                         return _Parameter(name, hasDefault=False, classType=datetime.datetime)
                     else:
             # Override default timestamp constructor:
             FactoryLoader.add_constructor(
-                    u'tag:yaml.org,2002:timestamp',
+                    'tag:yaml.org,2002:timestamp',
                     FactoryLoader.construct_yaml_timestamp
             )
                         return _Parameter(sigName, True, default, length=None)
                     # Is the object an array with length and default value given?:
-                    if isinstance(sig.yamlString, dict) and "len" in sig.yamlString.keys():
+                    if isinstance(sig.yamlString, dict) and "len" in list(sig.yamlString.keys()):
                         length = sig.yamlString["len"]
                         # Shape is given as something like [[],[]], not [2,2] - convert
                     # List of names of classes we've created so far:
                     #print [x for x in objClasses]
-                    names = objClasses.keys()
+                    names = list(objClasses.keys())
                     if ref_object.yamlString in names:
                         defaultType = objClasses[ref_object.yamlString]
                             setattr(_self, classData[i].name, arg)
                         # Set named attributes (given by dictionary kwargs):
-                        for key,value in kwargs.items():
+                        for key,value in list(kwargs.items()):
                             try: keyIndex = [param.name for param in classData].index(key)
                             except ValueError:
                         # Object instantiation / creation time (if not already present):
-                        if not kwargs.has_key('__time_created'):
+                        if '__time_created' not in kwargs:
                             setattr(_self, "__time_created", np.float64(time.time()))
                     return init, attributes
                     a KeyError if the class cannot be found. """
                     # If class definition was in the YAML file, extend that one:
-                    if className in localClasses.keys():
+                    if className in list(localClasses.keys()):
                         return localClasses[className]
                     # Else try finding the class definition in our global scope:
                         # Each document can contain multiple objects - build each one.
                         # (NOTE: objects can cross reference each other in the same document
                         # need to resolve Reference objects as last step)
-                        for objClassName in document.keys():
+                        for objClassName in list(document.keys()):
                             # The dictionary containing method & data signatures:
                             objDict = document[objClassName]
                             classBases = [Object]
                             # List structured documents result in a list of dicts each with one key:
-                            if isinstance(objDict, list): keys = [param.keys()[0] for param in objDict]
+                            if isinstance(objDict, list): keys = [list(param.keys())[0] for param in objDict]
                             # Otherwise the parameter names are just the  keys of the dict
-                            else: keys = objDict.keys()   # if key not found, raises AttributeError
+                            else: keys = list(objDict.keys())   # if key not found, raises AttributeError
                             for sigName in keys:
                                 #print sigName
                                 else:
                                     msg = "Factory abstract base class doesn't " +\
                                     "support the following signature: %r \"%s\""%(sig.__class__,str(sig))
-                                    print sig.__class__
+                                    print(sig.__class__)
                                     raise SignatureException(msg)
                             # Built-in attribute for all Dynamic Objects:
                             def construct_dynamic_object(loader, node):
                                 kwargs = loader.construct_mapping(node)
                                 # Remove revision control from loaded objects (info is in the class object!)
-                                for arg in kwargs.keys():
+                                for arg in list(kwargs.keys()):
                                     if arg in getattr(Object, 'getters') and arg != '__time_created':
                                         del kwargs[arg]
                                 return cls(**kwargs)
                             revision = cls.meta_attributes["__revision_number"]
-                            DynamicYAML.Loader.add_constructor(u'!%s.%s'%(str(objClassName),revision), construct_dynamic_object)
+                            DynamicYAML.Loader.add_constructor('!%s.%s'%(str(objClassName),revision), construct_dynamic_object)
                             represent_dynamic_object = DynamicYAML.Dumper.represent_dynamic_object
                             DynamicYAML.Dumper.add_representer(cls, represent_dynamic_object)
                         except KeyError:
                             # Now look for reference to class object loaded from any YAML defn file, loading the
                             # most recent version / revision (number) of the definition
-                            for dynClass in Object.dynamicClasses.keys()[::-1]:
+                            for dynClass in list(Object.dynamicClasses.keys())[::-1]:
                                 if dynClass.startswith(className):
                                     return Object.dynamicClasses[dynClass]
                             # Still unresolved - raise exception:
-                            allDynamicClasses = repr(objClasses.keys() + Object.dynamicClasses.keys())
+                            allDynamicClasses = repr(list(objClasses.keys()) + list(Object.dynamicClasses.keys()))
                             raise UnresolvedTypeException("Cannot resolve type '%s': Name not found in %s"%(className,allDynamicClasses))
                     def resolve(param):
                         # Reference is just a string - that's the class name:
-                        if isinstance(param.classType.yamlObject, (str, unicode)):
+                        if isinstance(param.classType.yamlObject, str):
                             className = str(param.classType.yamlObject)
                             param.classType = findClass(className)
                             return
                             param.hasDefault = False # for good measure
                         # Is it an object array?:
-                        if "len" in refDict.keys():
+                        if "len" in list(refDict.keys()):
                             param.length = refDict["len"]
                     # Resolve any unresolved data-types:
             def load_defn(yaml):
                 """ Shortcut for producing a single DynamicObject class object from
                 the provided yaml definition in string format """
-                return Factory(yaml=yaml).classes.values()[0]
+                return list(Factory(yaml=yaml).classes.values())[0]

schainpy/model/serializer/test/DynamicSerializer.py +1 -1

             if __name__ == "__main__":
                 DynamicSerializer()
-                print "DynamicSerializer ran"
  No newline at end of file
+                print("DynamicSerializer ran")
  No newline at end of file

schainpy/model/serializer/test/DynamicYAML.py +29 -30

                         data = self.construct_mapping(self, node)
                         self.constructed_objects[node] = data
                         del self.recursive_objects[node]
-                        if data.has_key('__revision_source'):
+                        if '__revision_source' in data:
                             # TODO: Handle password authentication
                             client = pysvn.Client()
                             source = data['__revision_source']
                     """
                     state = {}
-                    state.update(obj.__dict__.items())
+                    state.update(list(obj.__dict__.items()))
-                    state.update(obj.__class__.meta_attributes.items())
+                    state.update(list(obj.__class__.meta_attributes.items()))
                     name = obj.getObjectName() # obj.__class__.__name__
                     revision = obj.getRevisionNumber()
-                    return self.represent_mapping(u'!%s.%s' % (name, revision), state)
+                    return self.represent_mapping('!%s.%s' % (name, revision), state)
             # Dtypes to be stored as hex in YAML streams / strings
             hex_dtypes = ['float', 'complex', 'half', 'single', 'double']
             dtypes = Lookup.numpy_dtypes
             # Inverse lookup for accessing tags given a class instance:
-            cls_dtypes = dict([(v,k) for (k,v) in dtypes.items()])
+            cls_dtypes = dict([(v,k) for (k,v) in list(dtypes.items())])
             # Representer for numpy arrays:
             def ndarray_representer(dumper, obj):
                 np_ary = obj
                 #hex_ary = np.empty(np_ary.shape, dtype=yaml.nodes.ScalarNode)
                 np_flat, hex_flat = np_ary.flat, [] #hex_ary.flat
-                hex_flat.append(dumper.represent_sequence(u'tag:yaml.org,2002:seq', list(np_ary.shape), flow_style=True))
+                hex_flat.append(dumper.represent_sequence('tag:yaml.org,2002:seq', list(np_ary.shape), flow_style=True))
                 if hexlify:
                     lst = []
                     for i in range(len(np_flat)):
-                        value = u'%s'%(np_flat[i],)
+                        value = '%s'%(np_flat[i],)
-                        node = dumper.represent_scalar(u'tag:yaml.org,2002:str', value, style='')
+                        node = dumper.represent_scalar('tag:yaml.org,2002:str', value, style='')
                         lst.append(node)
-                    hex_flat.append(yaml.nodes.SequenceNode(u'tag:yaml.org,2002:seq', lst, flow_style=True))
+                    hex_flat.append(yaml.nodes.SequenceNode('tag:yaml.org,2002:seq', lst, flow_style=True))
                     lst = []
                 for i in range(len(np_flat)):
-                    if hexlify: value = u'%s'%(binascii.hexlify(np_flat[i]),)
+                    if hexlify: value = '%s'%(binascii.hexlify(np_flat[i]),)
-                    else: value = u'%s'%(np_flat[i],)
+                    else: value = '%s'%(np_flat[i],)
-                    node = dumper.represent_scalar(u'tag:yaml.org,2002:str', value, style='')
+                    node = dumper.represent_scalar('tag:yaml.org,2002:str', value, style='')
                     if hexlify: lst.append(node)
                     else: hex_flat.append(node)
-                if hexlify: hex_flat.append(yaml.nodes.SequenceNode(u'tag:yaml.org,2002:seq', lst, flow_style=True))
+                if hexlify: hex_flat.append(yaml.nodes.SequenceNode('tag:yaml.org,2002:seq', lst, flow_style=True))
-                return yaml.nodes.SequenceNode(u'!%s'%(tag,), hex_flat, flow_style=True)
+                return yaml.nodes.SequenceNode('!%s'%(tag,), hex_flat, flow_style=True)
             Dumper.add_representer(np.ndarray, ndarray_representer)
             # Constructor for ndarrays with arbitrary (specified) dtype:
                     def dtype_representer(dumper, obj):
                         tag, hexlify, dtype = self.fncn_attributes
                         if isinstance(obj, float): obj = np.float64(obj)
-                        if hexlify: value = u'%s'%(binascii.hexlify(obj),)
+                        if hexlify: value = '%s'%(binascii.hexlify(obj),)
-                        else: value = u'%s'%(obj,)
+                        else: value = '%s'%(obj,)
-                        try: tag = u'!%s'%(cls_dtypes[obj.__class__]) # 'dtype.'+obj.__class__.__name__ # bullshit...
+                        try: tag = '!%s'%(cls_dtypes[obj.__class__]) # 'dtype.'+obj.__class__.__name__ # bullshit...
                         except KeyError: tag = ''
                         node = dumper.represent_scalar(tag, value, style='')
                         return node
                     self.dtype_constructor = dtype_constructor
                     self.dtype_representer = dtype_representer
-            keys = [x for x in dtypes.keys() if x != 'dtype.int' and x != 'dtype.bool']
+            keys = [x for x in list(dtypes.keys()) if x != 'dtype.int' and x != 'dtype.bool']
-            print keys
+            print(keys)
             n = len(keys)
-            print n
+            print(n)
             i=0
             for tag in keys:
                 dtype = __dtype_con(tag)
                 dtype_constructor = dtype.dtype_constructor
                 dtype_representer = dtype.dtype_representer
-                Loader.add_constructor(u'!%s'%(tag,), dtype_constructor)
+                Loader.add_constructor('!%s'%(tag,), dtype_constructor)
                 Dumper.add_representer(dtypes[tag], dtype_representer)
             # Precision time constructors & representers:
             def ns_rep(dumper, obj):
                 state = {'second': obj.__dict__['second'], 'nanosecond': obj.__dict__['nanosecond']}
-                return dumper.represent_mapping(u'!timestamp_ns', state)
+                return dumper.represent_mapping('!timestamp_ns', state)
             def ps_rep(dumper, obj):
                 state = {'second': obj.__dict__['second'], 'picosecond': obj.__dict__['picosecond']}
-                return dumper.represent_mapping(u'!timestamp_ps', state)
+                return dumper.represent_mapping('!timestamp_ps', state)
             def ns_con(loader, node): return PrecisionTime.nsTime(**loader.construct_mapping(node))
             def ps_con(loader, node): return PrecisionTime.psTime(**loader.construct_mapping(node))
             Dumper.add_representer(PrecisionTime.nsTime, ns_rep)
             Dumper.add_representer(PrecisionTime.psTime, ps_rep)
-            Loader.add_constructor(u'!timestamp_ns', ns_con)
+            Loader.add_constructor('!timestamp_ns', ns_con)
-            Loader.add_constructor(u'!timestamp_nanosecond', ns_con)
+            Loader.add_constructor('!timestamp_nanosecond', ns_con)
-            Loader.add_constructor(u'!timestamp_ps', ps_con)
+            Loader.add_constructor('!timestamp_ps', ps_con)
-            Loader.add_constructor(u'!timestamp_picosecond', ps_con)
+            Loader.add_constructor('!timestamp_picosecond', ps_con)
             # Binary object constructor & representer:
-            def bin_rep(dumper, obj): return dumper.represent_mapping(u'!binary', obj.__dict__)
+            def bin_rep(dumper, obj): return dumper.represent_mapping('!binary', obj.__dict__)
             def bin_con(loader, node): return DynamicObject.Binary(**loader.construct_mapping(node))
             Dumper.add_representer(DynamicObject.Binary, bin_rep)
-            Loader.add_constructor(u'!binary', bin_con)
+            Loader.add_constructor('!binary', bin_con)

schainpy/model/serializer/test/Lookup.py +4 -5

             import collections
             # Implicit Types:
-            python_dtypes = tuple([bool,int,long,float,str,datetime.datetime,list,
+            python_dtypes = tuple([bool,int,int,float,str,datetime.datetime,list,
-                             set,dict,tuple,unicode])
+                             set,dict,tuple,str])
             # Numpy Data-types:
             numpy_dtypes = {'dtype.bool': bool, 'dtype.int': np.int, 'dtype.int8': np.int8,
                                       'Binary': Binary}
             # Inverse lookup for accessing tags given a class instance:
-            cls_dtypes = dict([(v,k) for (k,v) in numpy_dtypes.items()])
+            cls_dtypes = dict([(v,k) for (k,v) in list(numpy_dtypes.items())])
-            obj_dtypes = dict([(v,k) for (k,v) in builtin_objects_simple.items()])
+            obj_dtypes = dict([(v,k) for (k,v) in list(builtin_objects_simple.items())])
             # Pointer to the list of all Object classes created, as located in the Object module / class:
             dynamicClasses = DynamicObject.Object.dynamicClasses

schainpy/model/serializer/test/PrecisionTime.py +16 -17

                 def __init__(self, second, nanosecond):
                     self.second = int(second)
                     if self.second < 0:
-                        raise ValueError, 'seconds must be greater than 0, not %i' % (self.second)
+                        raise ValueError('seconds must be greater than 0, not %i' % (self.second))
-                    nanosecond = long(nanosecond)
+                    nanosecond = int(nanosecond)
                     if nanosecond < 0:
-                        raise ValueError, 'nanoseconds must be greater 0, not %i' % (nanosecond)
+                        raise ValueError('nanoseconds must be greater 0, not %i' % (nanosecond))
                     addSec = nanosecond / 1000000000
                     if addSec > 0:
                         self.second += addSec
                     self.nanosecond = nanosecond % 1000000000
-                    self.totalNS = long(self.nanosecond) + long(self.second) * 1000000000
+                    self.totalNS = int(self.nanosecond) + int(self.second) * 1000000000
                 def __add__(self, other):
                     addSec = int(nsResult / 1000000000)
                     self.second = self.second + other.second + addSec
                     self.nanosecond = nsResult % 1000000000
-                    self.totalNS = long(self.nanosecond) + long(self.second) * 1000000000
+                    self.totalNS = int(self.nanosecond) + int(self.second) * 1000000000
                 def __sub__(self, other):
                 def multiply(self, factor):
                     """multiply this nsTime times an integer
                     """
-                    if type(factor) not in (types.IntType, types.LongType):
+                    if type(factor) not in (int, int):
-                        raise ValueError, 'Illegal type %s passed into nsTime.multiply' % (str(type(factor)))
+                        raise ValueError('Illegal type %s passed into nsTime.multiply' % (str(type(factor))))
                     newTotalNS = self.totalNS * factor
                     newSeconds = int(newTotalNS / 1000000000)
                     newNanoseconds = int(newTotalNS - (newSeconds * 1000000000))
                 def __mod__(self, other):
                     """__mod__ implements self % other.
                     """
-                    if type(other) in (types.IntType, types.LongType):
+                    if type(other) in (int, int):
                         return self.totalNS % other
                     else:
                         return self.totalNS % other.totalNS
                 def __init__(self, second, picosecond):
                     self.second = int(second)
                     if self.second < 0:
-                        raise ValueError, 'seconds must be greater than 0, not %i' % (self.second)
+                        raise ValueError('seconds must be greater than 0, not %i' % (self.second))
-                    picosecond = long(picosecond)
+                    picosecond = int(picosecond)
                     if picosecond < 0:
-                        raise ValueError, 'picoseconds must be greater 0, not %i' % (picosecond)
+                        raise ValueError('picoseconds must be greater 0, not %i' % (picosecond))
                     addSec = picosecond / 1000000000000
                     if addSec > 0:
                         self.second += addSec
                     self.picosecond = picosecond % 1000000000000
-                    self.totalPS = long(self.picosecond) + long(self.second) * 1000000000000
+                    self.totalPS = int(self.picosecond) + int(self.second) * 1000000000000
                 def __add__(self, other):
                     addSec = int(psResult / 1000000000000)
                     self.second = self.second + other.second + addSec
                     self.picosecond = psResult % 1000000000000
-                    self.totalPS = long(self.picosecond) + long(self.second) * 1000000000000
+                    self.totalPS = int(self.picosecond) + int(self.second) * 1000000000000
                 def __sub__(self, other):
                 def multiply(self, factor):
                     """multiply this psTime times an integer
                     """
-                    if type(factor) not in (types.IntType, types.LongType):
+                    if type(factor) not in (int, int):
-                        raise ValueError, 'Illegal type %s passed into psTime.multiply' % (str(type(factor)))
+                        raise ValueError('Illegal type %s passed into psTime.multiply' % (str(type(factor))))
                     newTotalPS = self.totalPS * factor
                     newSeconds = int(newTotalPS / 1000000000000)
                     newPicoseconds = int(newTotalPS - (newSeconds * 1000000000000))
                 def __mod__(self, other):
                     """__mod__ implements self % other.
                     """
-                    if type(other) in (types.IntType, types.LongType):
+                    if type(other) in (int, int):
                         return self.totalPS % other
                     else:
                         return self.totalPS % other.totalPS
                 def __str__(self):
                     return '%d.%12d' % (self.second, self.picosecond)

schainpy/model/serializer/test/Serializer.py +22 -23

             # Regular expression taken from yaml.constructor.py
             timestamp_regexp_str = str(\
-            	ur'^(?P<year>[0-9][0-9][0-9][0-9])'
+            	r'^(?P<year>[0-9][0-9][0-9][0-9])'
-            	ur'-(?P<month>[0-9][0-9]?)'
+            	r'-(?P<month>[0-9][0-9]?)'
-            	ur'-(?P<day>[0-9][0-9]?)'
+            	r'-(?P<day>[0-9][0-9]?)'
-            	ur'(?:(?:[Tt]|[ \t]+)'
+            	r'(?:(?:[Tt]|[ \t]+)'
-            	ur'(?P<hour>[0-9][0-9]?)'
+            	r'(?P<hour>[0-9][0-9]?)'
-            	ur':(?P<minute>[0-9][0-9])'
+            	r':(?P<minute>[0-9][0-9])'
-            	ur':(?P<second>[0-9][0-9])'
+            	r':(?P<second>[0-9][0-9])'
-            	ur'(?:\.(?P<fraction>[0-9]*))?'
+            	r'(?:\.(?P<fraction>[0-9]*))?'
-            	ur'(?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)'
+            	r'(?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)'
-            	ur'(?::(?P<tz_minute>[0-9][0-9]))?))?)?$')
+            	r'(?::(?P<tz_minute>[0-9][0-9]))?))?)?$')
             timestamp_regexp = re.compile(timestamp_regexp_str, re.X)
             def construct_timestamp(value):
                 def __fromSerial(self, msg_dict):
                     if not isinstance(msg_dict, (dict, list, tuple)):
                         return msg_dict # msg_dict is a value - return it
-                    if isinstance(msg_dict, dict) and msg_dict.has_key('__meta_attributes'):
+                    if isinstance(msg_dict, dict) and '__meta_attributes' in msg_dict:
                         meta_attr = msg_dict['__meta_attributes']
                         msg_dict.pop('__meta_attributes')
-                        if meta_attr.has_key('type'):
+                        if 'type' in meta_attr:
                             if meta_attr['type'] == 'datetime':
                                 return construct_timestamp(str(msg_dict['ts']))
                             elif meta_attr['type'] == 'nsTime':
                             except KeyError: dtype = Lookup.builtin_objects[meta_attr['type']]
                             return dtype(**msg_dict)
                         else:
-                            for key in msg_dict.keys():
+                            for key in list(msg_dict.keys()):
                                 msg_dict[key] = self.__fromSerial(msg_dict[key])
                             cls = Lookup.dynamicClasses['%s.%s'%(meta_attr['__object_name'],meta_attr['__revision_number'])]
                             return cls(**msg_dict)
                         return np.frombuffer(value, dtype=Lookup.numpy_dtypes[msg_dict[1]])[0]
                     tup = isinstance(msg_dict, tuple)
-                    if tup and len(msg_dict) > 1 and msg_dict[0] in Lookup.numpy_dtypes.keys():
+                    if tup and len(msg_dict) > 1 and msg_dict[0] in list(Lookup.numpy_dtypes.keys()):
                         msg_flat = list(msg_dict)
                         dtypeName = msg_flat.pop(0)
                         dtype = Lookup.numpy_dtypes[dtypeName]
                         return msg_dict
                     elif isinstance(obj, DynamicObject.Object):
                         msg_dict = {}
-                        for key, value in obj.__dict__.items():
+                        for key, value in list(obj.__dict__.items()):
                             msg_dict[key] = self.__toSerial(value)
                         msg_dict['__meta_attributes'] = obj.__class__.meta_attributes
                                 msg_flat.append(toSer)
                         return list(msg_flat)
-                    is_builtin = obj.__class__ in Lookup.numpy_dtypes.values()
+                    is_builtin = obj.__class__ in list(Lookup.numpy_dtypes.values())
                     #is_python = isinstance(obj, Lookup.python_dtypes)
                     if is_builtin: # and not is_python:
                         try:
                     if isinstance(grp, h5py.Dataset):
                         return grp.value
-                    elif isinstance(grp, h5py.Group) and '__type' in grp.keys():
+                    elif isinstance(grp, h5py.Group) and '__type' in list(grp.keys()):
                         typ = grp['__type'].value
                         if typ == 'datetime':
                             return construct_timestamp(str(grp['ts'].value))
                         try: cls = Lookup.builtin_objects_simple[typ]
                         except KeyError: cls = Lookup.dynamicClasses[typ]
                         args = []
-                        for key in grp.keys():
+                        for key in list(grp.keys()):
                             fromSer = self.__fromSerial(grp[key])
                             args.append((key, fromSer))
                         kwargs = dict(args)
                     elif isinstance(obj, tuple(Lookup.builtin_objects_simple.values())):
                         sub_grp = grp.create_group(name)
                         sub_grp['__type'] = Lookup.obj_dtypes[obj.__class__]
-                        for key, value in obj.__dict__.items():
+                        for key, value in list(obj.__dict__.items()):
                             if value != None and key not in ['totalNS', 'totalPS']:
                                 sub_grp[key] = value
                         tag = '%s.%s'%(obj.getObjectName(), obj.getRevisionNumber())
                         sub_grp['__type'] = tag
                         # Put all of the DynamicObject's attributes into the new h5py group
-                        for key, value in obj.__dict__.items():
+                        for key, value in list(obj.__dict__.items()):
                             self.__toSerial(value, sub_grp, key)
                     elif isinstance(obj, tuple):
                     #return json.dumps(string)
                     return jsonpickle.encode(string, max_depth=500)
-            # Dict mapping from serializer type to corresponding class object:
+            # Dict mapping from .serializer type to corresponding class object:
             serializers = {'yaml': YAMLSerializer,
                            'msgpack': MessagePackSerializer,
                            'hdf5': HDF5Serializer,
                          'hdf5': HDF5Serializer(),
                          'json': jsonSerializer()}
-            serial_types = dict([(v,u) for u,v in serializers.items()])
+            serial_types = dict([(v,u) for u,v in list(serializers.items())])
             compression_types = ['gzip', '']

schainpy/model/serializer/test/serialtest.py +5 -6

             dest_object = serializer.fromSerial(datastr)
-            print "dest_object=",dest_object
+            print("dest_object=",dest_object)
             myObject = StateListObject(hierarchical="yes",state=np.array([1,2,3.0]))
             try:
               r= redis.StrictRedis(host='localhost',port=6379,db=0)
             except Exception as eobj:
-              print "is the redis server running?",eobj
+              print("is the redis server running?",eobj)
             else:
               r.set('baz',packed)   # converts to string
             dest_object = serializer.fromSerial(unpacked)
-            print "val1=",dest_object.hierarchical
+            print("val1=",dest_object.hierarchical)
             val2 = dest_object.state
-            print "val2=",val2
+            print("val2=",val2)
             # can numpy array be used as array?
-            print val2.shape
+            print(val2.shape)

schainpy/model/utils/__init__.py +2 -2

             $Id: Processor.py 1 2012-11-12 18:56:07Z murco $
             '''
-            from jroutils_ftp import *
+            from .jroutils_ftp import *
-            from jroutils_publish import *
+            from .jroutils_publish import *

schainpy/model/utils/jroutils_ftp.py +72 -72

                 import paramiko
                 import scp
             except:
-                print "You should install paramiko and scp libraries \nif you want to use SSH protocol to upload files to the server"
+                print("You should install paramiko and scp libraries \nif you want to use SSH protocol to upload files to the server")
             import time
                     self.stopFlag = False
-                    print "[Remote Server] Opening server: %s" %self.__server
+                    print("[Remote Server] Opening server: %s" %self.__server)
                     if self.open(self.__server, self.__username, self.__password, self.__remotefolder):
-                        print "[Remote Server] %s server was opened successfully" %self.__server
+                        print("[Remote Server] %s server was opened successfully" %self.__server)
                     self.close()
                     """
                     Connect to server and create a connection class (FTP or SSH) to remote server.
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def close(self):
                     """
                     Close connection to server
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def mkdir(self, remotefolder):
                     """
                     Create a folder remotely
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def cd(self, remotefolder):
                     """
                     Change working directory in remote server
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def download(self, filename, localfolder=None):
                     """
                     Download a file from server to local host
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def sendFile(self, fullfilename):
                     """
                     Returns:
 in error case else 1
                     """
-                    raise NotImplementedError, "Implement this method in child class"
+                    raise NotImplementedError("Implement this method in child class")
                 def upload(self, fullfilename, remotefolder=None):
                     """
                     Returns:
 in error case else 1
                     """
-                    print "[Remote Server] Uploading %s to %s:%s" %(fullfilename, self.server, self.remotefolder)
+                    print("[Remote Server] Uploading %s to %s:%s" %(fullfilename, self.server, self.remotefolder))
                     if not self.status:
                         return 0
                         return 0
                     if not self.sendFile(fullfilename):
-                        print "[Remote Server] Error uploading file %s" %fullfilename
+                        print("[Remote Server] Error uploading file %s" %fullfilename)
                         return 0
-                    print "[Remote Server] upload finished successfully"
+                    print("[Remote Server] upload finished successfully")
                     return 1
                 def run(self):
                     if not self.status:
-                        print "Finishing FTP service"
+                        print("Finishing FTP service")
                         return
                     if not self.cd(self.remotefolder):
-                        raise ValueError, "Could not access to the new remote directory: %s" %self.remotefolder
+                        raise ValueError("Could not access to the new remote directory: %s" %self.remotefolder)
                     while True:
                         #   self.bussy = True
                         self.mutex.acquire()
-                        print "[Remote Server] Opening %s" %self.__server
+                        print("[Remote Server] Opening %s" %self.__server)
                         if not self.open(self.__server, self.__username, self.__password, self.__remotefolder):
                             self.mutex.release()
                             continue
                         for thisFile in self.fileList:
                             self.upload(thisFile, self.remotefolder)
-                        print "[Remote Server] Closing %s" %self.__server
+                        print("[Remote Server] Closing %s" %self.__server)
                         self.close()
                         self.mutex.release()
                         # self.bussy = False
-                    print "[Remote Server] Thread stopped successfully"
+                    print("[Remote Server] Thread stopped successfully")
             class FTPClient(Remote):
                     """
                     if server == None:
-                        raise ValueError, "FTP server should be defined"
+                        raise ValueError("FTP server should be defined")
                     if username == None:
-                        raise ValueError, "FTP username should be defined"
+                        raise ValueError("FTP username should be defined")
                     if password == None:
-                        raise ValueError, "FTP password should be defined"
+                        raise ValueError("FTP password should be defined")
                     if remotefolder == None:
-                        raise ValueError, "FTP remote folder should be defined"
+                        raise ValueError("FTP remote folder should be defined")
                     try:
                         ftpClientObj = ftplib.FTP(server)
-                    except ftplib.all_errors, e:
+                    except ftplib.all_errors as e:
-                        print "[FTP Server]: FTP server connection fail: %s" %server
+                        print("[FTP Server]: FTP server connection fail: %s" %server)
-                        print "[FTP Server]:", e
+                        print("[FTP Server]:", e)
                         self.status = 0
                         return 0
                     try:
                         ftpClientObj.login(username, password)
                     except ftplib.all_errors:
-                        print "[FTP Server]: FTP username or password are incorrect"
+                        print("[FTP Server]: FTP username or password are incorrect")
                         self.status = 0
                         return 0
                         try:
                             ftpClientObj.cwd(remotefolder)
                         except ftplib.all_errors:
-                            print "[FTP Server]: FTP remote folder is invalid: %s" %remotefolder
+                            print("[FTP Server]: FTP remote folder is invalid: %s" %remotefolder)
                             remotefolder = ftpClientObj.pwd()
                     self.server = server
                     try:
                         self.__ftpClientObj.mkd(dirname)
                     except ftplib.all_errors:
-                        print "[FTP Server]: Error creating remote folder: %s" %remotefolder
+                        print("[FTP Server]: Error creating remote folder: %s" %remotefolder)
                         return 0
                     return 1
                     try:
                         self.__ftpClientObj.cwd(remotefolder)
                     except ftplib.all_errors:
-                        print '[FTP Server]: Error changing to %s' %remotefolder
+                        print('[FTP Server]: Error changing to %s' %remotefolder)
-                        print '[FTP Server]: Trying to create remote folder'
+                        print('[FTP Server]: Trying to create remote folder')
                         if not self.mkdir(remotefolder):
-                            print '[FTP Server]: Remote folder could not be created'
+                            print('[FTP Server]: Remote folder could not be created')
                             return 0
                         try:
                     try:
                         self.__ftpClientObj.storbinary(command, fp)
-                    except ftplib.all_errors, e:
+                    except ftplib.all_errors as e:
-                        print "[FTP Server]:", e
+                        print("[FTP Server]:", e)
                         return 0
                     try:
                         self.__ftpClientObj.sendcmd('SITE CHMOD 755 ' + filename)
-                    except ftplib.all_errors, e:
+                    except ftplib.all_errors as e:
-                        print "[FTP Server]:", e
+                        print("[FTP Server]:", e)
                     fp.close()
                     import socket
                     if server == None:
-                        raise ValueError, "SSH server should be defined"
+                        raise ValueError("SSH server should be defined")
                     if username == None:
-                        raise ValueError, "SSH username should be defined"
+                        raise ValueError("SSH username should be defined")
                     if password == None:
-                        raise ValueError, "SSH password should be defined"
+                        raise ValueError("SSH password should be defined")
                     if remotefolder == None:
-                        raise ValueError, "SSH remote folder should be defined"
+                        raise ValueError("SSH remote folder should be defined")
                     sshClientObj = paramiko.SSHClient()
                     self.status = 0
                     try:
                         sshClientObj.connect(server, username=username, password=password, port=port)
-                    except paramiko.AuthenticationException, e:
+                    except paramiko.AuthenticationException as e:
                 #             print "SSH username or password are incorrect: %s"
-                        print "[SSH Server]:", e
+                        print("[SSH Server]:", e)
                         return 0
-                    except SSHException, e:
+                    except SSHException as e:
-                        print "[SSH Server]:", e
+                        print("[SSH Server]:", e)
                         return 0
                     except socket.error:
                         self.status = 0
-                        print "[SSH Server]:", e
+                        print("[SSH Server]:", e)
                         return 0
                     self.status = 1
                     self.status = 1
                     if not self.cd(remotefolder):
-                        raise ValueError, "[SSH Server]: Could not access to remote folder: %s" %remotefolder
+                        raise ValueError("[SSH Server]: Could not access to remote folder: %s" %remotefolder)
                         return 0
                     self.remotefolder = remotefolder
                     try:
                         self.__scpClientObj.put(fullfilename, remote_path=self.remotefolder)
-                    except scp.ScpError, e:
+                    except scp.ScpError as e:
-                        print "[SSH Server]", str(e)
+                        print("[SSH Server]", str(e))
                         return 0
                     remotefile = os.path.join(self.remotefolder, os.path.split(fullfilename)[-1])
                         self.clientObj = SSHClient(server, username, password, remotefolder, period)
                     if not self.clientObj:
-                        raise ValueError, "%s has been chosen as remote access protocol but it is not valid" %protocol
+                        raise ValueError("%s has been chosen as remote access protocol but it is not valid" %protocol)
                     self.clientObj.start()
                     for thisFolder in folderList:
-                        print "[Remote Server]: Searching files on %s" %thisFolder
+                        print("[Remote Server]: Searching files on %s" %thisFolder)
                         filenameList = glob.glob1(thisFolder, '*%s' %self.ext)
                         self.isConfig = True
                     if not self.clientObj.is_alive():
-                        print "[Remote Server]: Restarting connection "
+                        print("[Remote Server]: Restarting connection ")
                         self.setup(**kwargs)
                     if time.time() - self.init >= self.period:
                         fullfilenameList = self.findFiles()
                         if self.clientObj.updateFileList(fullfilenameList):
-                            print "[Remote Server]: Sending the next files ", str(fullfilenameList)
+                            print("[Remote Server]: Sending the next files ", str(fullfilenameList))
                         self.init = time.time()
                 def close(self):
-                    print "[Remote Server] Stopping thread"
+                    print("[Remote Server] Stopping thread")
                     self.clientObj.stop()
                         #   print 'Connect to FTP Server: Successfully'
                     except ftplib.all_errors:
-                        print 'Error FTP Service'
+                        print('Error FTP Service')
                         self.status = 1
                         return
                     try:
                         self.dirList = self.ftp.nlst()
-                    except ftplib.error_perm, resp:
+                    except ftplib.error_perm as resp:
                         if str(resp) == "550 No files found":
-                                print "no files in this directory"
+                                print("no files in this directory")
                                 self.status = 1
                                 return
                     except ftplib.all_errors:
-                        print 'Error Displaying Dir-Files'
+                        print('Error Displaying Dir-Files')
                         self.status = 1
                         return
                     try:
                         self.ftp.mkd(dirname)
                     except:
-                        print 'Error creating remote folder:%s'%dirname
+                        print('Error creating remote folder:%s'%dirname)
                         return 1
                     return 0
                     try:
                         self.ftp.delete(filename)
                     except:
-                        print 'Error deleting remote file:%s'%filename
+                        print('Error deleting remote file:%s'%filename)
                         return 1
                     return 0
                     if not(filename in self.fileList):
-                        print 'filename:%s not exists'%filename
+                        print('filename:%s not exists'%filename)
                         self.status = 1
                         return self.status
                     self.file = open(newfilename, 'wb')
                     try:
-                        print 'Download: ' + filename
+                        print('Download: ' + filename)
                         self.ftp.retrbinary('RETR ' + filename, self.__handleDownload)
-                        print 'Download Complete'
+                        print('Download Complete')
                     except ftplib.all_errors:
-                        print 'Error Downloading ' + filename
+                        print('Error Downloading ' + filename)
                         self.status = 1
                         return self.status
                         command = "STOR " + tail
-                        print 'Uploading: ' + tail
+                        print('Uploading: ' + tail)
                         self.ftp.storbinary(command, self.file)
-                        print 'Upload Completed'
+                        print('Upload Completed')
                     except ftplib.all_errors:
-                        print 'Error Uploading ' + tail
+                        print('Error Uploading ' + tail)
                         self.status = 1
                         return self.status
                     """
                     self.remotefolder = remotefolder
-                    print 'Change to ' + self.remotefolder
+                    print('Change to ' + self.remotefolder)
                     try:
                         self.ftp.cwd(remotefolder)
                     except ftplib.all_errors:
-                        print 'Error Change to ' + self.remotefolder
+                        print('Error Change to ' + self.remotefolder)
                         infoList = None
                         self.folderList = None
                         return infoList,self.folderList
                     try:
                         self.dirList = self.ftp.nlst()
-                    except ftplib.error_perm, resp:
+                    except ftplib.error_perm as resp:
                         if str(resp) == "550 No files found":
-                                print "no files in this directory"
+                                print("no files in this directory")
                                 infoList = None
                                 self.folderList = None
                                 return infoList,self.folderList
                     except ftplib.all_errors:
-                        print 'Error Displaying Dir-Files'
+                        print('Error Displaying Dir-Files')
                         infoList = None
                         self.folderList = None
                         return infoList,self.folderList
                 def error_print(self, ValueError):
-                    print ValueError, 'Error FTP'
+                    print(ValueError, 'Error FTP')
-                    print "don't worry the program is running..."
+                    print("don't worry the program is running...")
                 def worker_ftp(self, server, username, password, remotefolder, filenameList):
                     if p.is_alive():
                         p.terminate()
                         p.join()
-                        print 'killing ftp process...'
+                        print('killing ftp process...')
                         self.status = 0
                         return

schainpy/model/utils/jroutils_publish.py +6 -6

             def roundFloats(obj):
                 if isinstance(obj, list):
-                    return map(roundFloats, obj)
+                    return list(map(roundFloats, obj))
                 elif isinstance(obj, float):
                     return round(obj, 2)
                     H.sort()
                     for key in self.data:
                         shape = self.shape(key)[:-1] + H.shape
-                        for tm, obj in self.data[key].items():
+                        for tm, obj in list(self.data[key].items()):
                             h = self.__heights[self.__times.index(tm)]
                             if H.size == h.size:
                                 continue
                     else:
                         ret['pairs'] = []
-                    for key, value in self.meta.items():
+                    for key, value in list(self.meta.items()):
                         ret[key] = value
                     return json.dumps(ret)
                                 'yData': yData
                             }
                         else:
-                            print "Tipo de grafico invalido"
+                            print("Tipo de grafico invalido")
                             payload = {
                                 'data': 'None',
                                 'timestamp': 'None',
                     try:
                         self.ftp.storbinary(command, fp, blocksize=1024)
-                    except Exception, e:
+                    except Exception as e:
                         log.error('{}'.format(e), self.name)
                         if self.ftp is not None:
                             self.ftp.close()
                     try:
                         self.ftp.sendcmd('SITE CHMOD 755 {}'.format(dst))
-                    except Exception, e:
+                    except Exception as e:
                         log.error('{}'.format(e), self.name)
                         if self.ftp is not None:
                             self.ftp.close()

schainpy/utils/paramsFinder.py +3 -3

                 argsAsKey = ["\t'{}'".format(x) for x in args]
                 argsFormatted = ": 'string',\n".join(argsAsKey)
-                print op
+                print(op)
-                print "parameters = { \n" + argsFormatted + ": 'string',\n }"
+                print("parameters = { \n" + argsFormatted + ": 'string',\n }")
-                print '\n'
+                print('\n')
             if __name__ == "__main__":

schainpy/zerorpc/MyClient01.py +3 -3

                 size = len(mySerial)/1024.
                 vel = 1.0*size / deltaTime
-                print "Index [", replayerObj.getProfileIndex(), "]: ",
+                print("Index [", replayerObj.getProfileIndex(), "]: ", end=' ')
-                print "Total time %5.2f ms, Data size %5.2f KB, Speed %5.2f MB/s" %(deltaTime, size, vel)
+                print("Total time %5.2f ms, Data size %5.2f KB, Speed %5.2f MB/s" %(deltaTime, size, vel))
                 ####################
             if __name__ == '__main__':
                     deltaTime = (time.time() - ini)*1024
                     if not mySerialData:
-                        print "No more data"
+                        print("No more data")
                         break
             #         myDataDict = SERIALIZER.loads(mySerialData)

schainpy/zerorpc/MyClient02.py +1 -1

                 c = zerorpc.Client()
                 c.connect("tcp://127.0.0.1:4242")
                 c.load("file2") # AAAHH! The previously loaded model gets overwritten here!
-                print c.getModelName()
  No newline at end of file
+                print(c.getModelName())
  No newline at end of file

schainpy/zerorpc/MyServer.py +2 -2

                 replayerObj.start()
-                print "Initializing 'zerorpc' server"
+                print("Initializing 'zerorpc' server")
                 s = zerorpc.Server(replayerObj)
                 s.bind("tcp://0.0.0.0:4242")
                 s.run()
-                print "End"
  No newline at end of file
+                print("End")
  No newline at end of file

schainpy/zerorpc/test/testServer.py +12 -12

                 if type(thisValue) != type({}):
                     return False
-                if '__name__' not in thisValue.keys():
+                if '__name__' not in list(thisValue.keys()):
                     return False
                 return True
                 myDict['__name__'] = myObj.__class__.__name__
-                for thisKey, thisValue in myObj.__dict__.items():
+                for thisKey, thisValue in list(myObj.__dict__.items()):
                     if isNotClassVar(thisValue):
                         myDict[thisKey] = thisValue
                 '''
                 '''
-                if '__name__' not in myDict.keys():
+                if '__name__' not in list(myDict.keys()):
                     return None
                 className = eval(myDict['__name__'])
                 myObj = className()
-                for thisKey, thisValue in myDict.items():
+                for thisKey, thisValue in list(myDict.items()):
                     if thisKey == '__name__':
                         continue
                 x_enc = m.encode(x)
                 x_rec = m.decode(x_enc)
-                print x_rec
+                print(x_rec)
             #
             #     x_enc = msgpack.packb(x, default=m.encoder)
             #     x_rec = msgpack.unpackb(x_enc, object_hook=m.decoder)
             #     print myNewObj.__dict__
             #     sys.exit()
-                print myDict
+                print(myDict)
                 newSerial = serializerObj.encode(myDict)
             #     print newSerial
                 newDict = serializerObj.decode(newSerial)
-                print newDict
+                print(newDict)
                 myNewObj = dict2Obj(newDict)
-                print
+                print()
-                print
+                print()
-                print 50*'###'
+                print(50*'###')
-                print myTestObj.__dict__
+                print(myTestObj.__dict__)
-                print myNewObj.__dict__
+                print(myNewObj.__dict__)
   No newline at end of file

schainpy/zerorpc/test/testServer_Voltage.py +6 -6

             '''
             import sys
-            import cPickle
+            import pickle
             from schainpy.model.data.jrodata import Voltage
             # from schainpy.model.io.jrodataIO import USRPReaderMP
             #     print newValue
-                print '###########CPICKLE##################'
+                print('###########CPICKLE##################')
-                print myDict
+                print(myDict)
-                newSerialized = cPickle.dumps(myDict, 2)
+                newSerialized = pickle.dumps(myDict, 2)
             #     print newValue
-                newDict = cPickle.loads(newSerialized)
+                newDict = pickle.loads(newSerialized)
-                print newDict
  No newline at end of file
+                print(newDict)
  No newline at end of file

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