Changeset aaa801e in sasview for src/sas/sascalc/dataloader


Ignore:
Timestamp:
Sep 23, 2017 4:33:43 PM (7 years ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
b796c72
Parents:
1cdbcd8 (diff), d3b0c77 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ticket-853-fit-gui-to-calc' into py3

Location:
src/sas/sascalc/dataloader
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/dataloader/readers/__init__.py

    r574adc7 raaa801e  
    11# Method to associate extensions to default readers 
    22from .associations import read_associations 
    3  
    4  
    5 # Method to return the location of the XML settings file 
    6 def get_data_path(): 
    7     """ 
    8         Return the location of the settings file for the data readers. 
    9     """ 
    10     import os 
    11     return os.path.dirname(__file__) 

  • src/sas/sascalc/dataloader/__init__.py

    rb699768 r574adc7  
    1 from data_info import * 
    2 from manipulations import * 
    3 from readers import * 
     1from .data_info import * 
     2from .manipulations import * 
     3from .readers import * 

  • src/sas/sascalc/dataloader/data_info.py

    r17e257b5 r574adc7  
    716716                self.y_unit = '1/cm' 
    717717        except: # the data is not recognized/supported, and the user is notified 
    718             raise(TypeError, 'data not recognized, check documentation for supported 1D data formats') 
     718            raise TypeError('data not recognized, check documentation for supported 1D data formats') 
    719719 
    720720    def __str__(self): 
    … …  
    796796                len(self.y) != len(other.y): 
    797797                msg = "Unable to perform operation: data length are not equal" 
    798                 raise ValueError, msg 
     798                raise ValueError(msg) 
    799799            # Here we could also extrapolate between data points 
    800800            TOLERANCE = 0.01 
    … …  
    802802                if math.fabs((self.x[i] - other.x[i])/self.x[i]) > TOLERANCE: 
    803803                    msg = "Incompatible data sets: x-values do not match" 
    804                     raise ValueError, msg 
     804                    raise ValueError(msg) 
    805805 
    806806            # Check that the other data set has errors, otherwise 
    … …  
    876876        if not isinstance(other, Data1D): 
    877877            msg = "Unable to perform operation: different types of data set" 
    878             raise ValueError, msg 
     878            raise ValueError(msg) 
    879879        return True 
    880880 
    … …  
    948948 
    949949        if len(self.detector) > 0: 
    950             raise RuntimeError, "Data2D: Detector bank already filled at init" 
     950            raise RuntimeError("Data2D: Detector bank already filled at init") 
    951951 
    952952    def __str__(self): 
    … …  
    10201020                len(self.qy_data) != len(other.qy_data): 
    10211021                msg = "Unable to perform operation: data length are not equal" 
    1022                 raise ValueError, msg 
     1022                raise ValueError(msg) 
    10231023            for ind in range(len(self.data)): 
    10241024                if math.fabs((self.qx_data[ind] - other.qx_data[ind])/self.qx_data[ind]) > TOLERANCE: 
    10251025                    msg = "Incompatible data sets: qx-values do not match: %s %s" % (self.qx_data[ind], other.qx_data[ind]) 
    1026                     raise ValueError, msg 
     1026                    raise ValueError(msg) 
    10271027                if math.fabs((self.qy_data[ind] - other.qy_data[ind])/self.qy_data[ind]) > TOLERANCE: 
    10281028                    msg = "Incompatible data sets: qy-values do not match: %s %s" % (self.qy_data[ind], other.qy_data[ind]) 
    1029                     raise ValueError, msg 
     1029                    raise ValueError(msg) 
    10301030 
    10311031            # Check that the scales match 
    … …  
    11081108        if not isinstance(other, Data2D): 
    11091109            msg = "Unable to perform operation: different types of data set" 
    1110             raise ValueError, msg 
     1110            raise ValueError(msg) 
    11111111        return True 
    11121112 

  • src/sas/sascalc/dataloader/file_reader_base_class.py

    rae69c690 r7b50f14  
    66 
    77import os 
     8import sys 
    89import re 
    910import logging 
     11from abc import abstractmethod 
     12 
    1013import numpy as np 
    11 from abc import abstractmethod 
    12 from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     14from .loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
    1315    DataReaderException, DefaultReaderException 
    14 from data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
     16from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
    1517    combine_data_info_with_plottable 
    1618 
    1719logger = logging.getLogger(__name__) 
    1820 
     21if sys.version_info[0] < 3: 
     22    def decode(s): 
     23        return s 
     24else: 
     25    def decode(s): 
     26        return s.decode() if isinstance(s, bytes) else s 
    1927 
    2028class FileReader(object): 
    … …  
    7886        # Return a list of parsed entries that data_loader can manage 
    7987        return self.output 
     88 
     89    def nextline(self): 
     90        """ 
     91        Returns the next line in the file as a string. 
     92        """ 
     93        #return self.f_open.readline() 
     94        return decode(self.f_open.readline()) 
     95 
     96    def nextlines(self): 
     97        """ 
     98        Returns the next line in the file as a string. 
     99        """ 
     100        for line in self.f_open: 
     101            #yield line 
     102            yield decode(line) 
     103 
     104    def readall(self): 
     105        """ 
     106        Returns the entire file as a string. 
     107        """ 
     108        #return self.f_open.read() 
     109        return decode(self.f_open.read()) 
    80110 
    81111    def handle_error_message(self, msg): 

  • src/sas/sascalc/dataloader/loader.py

    rdcb91cf rdc8d1c2  
    2626import time 
    2727from zipfile import ZipFile 
     28 
    2829from sas.sascalc.data_util.registry import ExtensionRegistry 
     30 
    2931# Default readers are defined in the readers sub-module 
    30 import readers 
    31 from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     32from . import readers 
     33from .loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
    3234    DefaultReaderException 
    33 from readers import ascii_reader 
    34 from readers import cansas_reader 
    35 from readers import cansas_reader_HDF5 
     35from .readers import ascii_reader 
     36from .readers import cansas_reader 
     37from .readers import cansas_reader_HDF5 
    3638 
    3739logger = logging.getLogger(__name__) 
    … …  
    7375        try: 
    7476            return super(Registry, self).load(path, format=format) 
     77        #except Exception: raise  # for debugging, don't use fallback loader 
    7578        except NoKnownLoaderException as nkl_e: 
    7679            pass  # Try the ASCII reader 
    … …  
    327330        extlist = [ext for ext in self.extensions() if path.endswith(ext)] 
    328331        # Sort matching extensions by decreasing order of length 
    329         extlist.sort(lambda a, b: len(a) < len(b)) 
     332        extlist.sort(key=len) 
    330333        # Combine loaders for matching extensions into one big list 
    331334        writers = [] 
    … …  
    341344        # Raise an error if there are no matching extensions 
    342345        if len(writers) == 0: 
    343             raise ValueError, "Unknown file type for " + path 
     346            raise ValueError("Unknown file type for " + path) 
    344347        # All done 
    345348        return writers 
    … …  
    360363            try: 
    361364                return fn(path, data) 
    362             except: 
     365            except Exception: 
    363366                pass  # give other loaders a chance to succeed 
    364367        # If we get here it is because all loaders failed 

  • src/sas/sascalc/dataloader/manipulations.py

    r324e0bf r574adc7  
    2626 
    2727#from data_info import plottable_2D 
    28 from data_info import Data1D 
     28from .data_info import Data1D 
    2929 
    3030 

  • src/sas/sascalc/dataloader/readers/abs_reader.py

    rad92c5a r46cf4c9  
    1111 
    1212import logging 
     13 
    1314import numpy as np 
    14 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    15 from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D,\ 
    16     Detector 
    17 from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
    18     DefaultReaderException 
     15 
     16from sas.sascalc.data_util.nxsunit import Converter 
     17from ..file_reader_base_class import FileReader 
     18from ..data_info import DataInfo, plottable_1D, Data1D, Detector 
     19from ..loader_exceptions import FileContentsException, DefaultReaderException 
    1920 
    2021logger = logging.getLogger(__name__) 
    … …  
    3132    # List of allowed extensions 
    3233    ext = ['.abs'] 
    33      
     34 
    3435    def get_file_contents(self): 
    35         """  
     36        """ 
    3637        Get the contents of the file 
    37          
     38 
    3839        :raise RuntimeError: when the file can't be opened 
    3940        :raise ValueError: when the length of the data vectors are inconsistent 
    4041        """ 
    41         buff = self.f_open.read() 
     42        buff = self.readall() 
    4243        filepath = self.f_open.name 
    4344        lines = buff.splitlines() 
    44         self.has_converter = True 
    45         try: 
    46             from sas.sascalc.data_util.nxsunit import Converter 
    47         except: 
    48             self.has_converter = False 
    4945        self.output = [] 
    5046        self.current_datainfo = DataInfo() 
    … …  
    7571                try: 
    7672                    value = float(line_toks[1]) 
    77                     if self.has_converter and \ 
    78                             self.current_datainfo.source.wavelength_unit != 'A': 
     73                    if self.current_datainfo.source.wavelength_unit != 'A': 
    7974                        conv = Converter('A') 
    8075                        self.current_datainfo.source.wavelength = conv(value, 
    … …  
    8984                try: 
    9085                    value = float(line_toks[3]) 
    91                     if self.has_converter and detector.distance_unit != 'm': 
     86                    if detector.distance_unit != 'm': 
    9287                        conv = Converter('m') 
    9388                        detector.distance = conv(value, 
    … …  
    9590                    else: 
    9691                        detector.distance = value 
    97                 except: 
     92                except Exception: 
    9893                    msg = "ABSReader cannot read SDD from %s" % filepath 
    9994                    self.current_datainfo.errors.append(msg) 
    … …  
    110105                try: 
    111106                    value = float(line_toks[5]) 
    112                     if self.has_converter and \ 
    113                             self.current_datainfo.sample.thickness_unit != 'cm': 
     107                    if self.current_datainfo.sample.thickness_unit != 'cm': 
    114108                        conv = Converter('cm') 
    115109                        self.current_datainfo.sample.thickness = conv(value, 
    … …  
    134128 
    135129                # Bin size 
    136                 if self.has_converter and detector.pixel_size_unit != 'mm': 
     130                if detector.pixel_size_unit != 'mm': 
    137131                    conv = Converter('mm') 
    138132                    detector.pixel_size.x = conv(5.08, 
    … …  
    146140                # Store beam center in distance units 
    147141                # Det 640 x 640 mm 
    148                 if self.has_converter and detector.beam_center_unit != 'mm': 
     142                if detector.beam_center_unit != 'mm': 
    149143                    conv = Converter('mm') 
    150144                    detector.beam_center.x = conv(center_x * 5.08, 
    151145                                     units=detector.beam_center_unit) 
    152146                    detector.beam_center.y = conv(center_y * 5.08, 
    153                                     units=detector.beam_center_unit) 
     147                                     units=detector.beam_center_unit) 
    154148                else: 
    155149                    detector.beam_center.x = center_x * 5.08 

  • src/sas/sascalc/dataloader/readers/anton_paar_saxs_reader.py

    rfafe52a ra5bd87a  
    6363        ## Reinitialize the class when loading a new data file to reset all class variables 
    6464        self.reset_state() 
    65         buff = self.f_open.read() 
     65        buff = self.readall() 
    6666        self.raw_data = buff.splitlines() 
    6767        self.read_data() 

  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    rf994e8b1 rf7d720f  
    4545        """ 
    4646 
    47         buff = self.f_open.read() 
     47        buff = self.readall() 
    4848        filepath = self.f_open.name 
    4949        lines = buff.splitlines() 
    … …  
    130130                # Reset # of lines of data candidates 
    131131                candidate_lines = 0 
    132          
     132 
    133133        if not is_data: 
    134134            self.set_all_to_none() 

  • src/sas/sascalc/dataloader/readers/associations.py

    rce8c7bd r574adc7  
    4040    """ 
    4141    # For each FileType entry, get the associated reader and extension 
    42     for ext, reader in settings.iteritems(): 
     42    for ext, reader in settings.items(): 
    4343        if reader is not None and ext is not None: 
    4444            # Associate the extension with a particular reader 
    … …  
    4747            # and remove the extra line below. 
    4848            try: 
    49                 exec "import %s" % reader 
    50                 exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
    51                                                                 reader) 
    52                 exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
    53                                                                 reader) 
     49                exec("from . import %s" % reader) 
     50                exec("loader.associate_file_type('%s', %s)" 
     51                     % (ext.lower(), reader)) 
     52                exec("loader.associate_file_type('%s', %s)" 
     53                     % (ext.upper(), reader)) 
    5454            except: 
    5555                msg = "read_associations: skipping association" 

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    rae69c690 re6e89c4  
    11import logging 
    2 import numpy as np 
    32import os 
    43import sys 
    54import datetime 
    65import inspect 
    7 # For saving individual sections of data 
    8 from sas.sascalc.dataloader.data_info import Data1D, Data2D, DataInfo, \ 
    9     plottable_1D, plottable_2D 
    10 from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, \ 
    11     Detector, Process, Aperture 
    12 from sas.sascalc.dataloader.data_info import \ 
    13     combine_data_info_with_plottable as combine_data 
    14 import sas.sascalc.dataloader.readers.xml_reader as xml_reader 
    15 from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    16 from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants, CurrentLevel 
    17 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, \ 
    18     DefaultReaderException, DataReaderException 
     6 
     7import numpy as np 
    198 
    209# The following 2 imports *ARE* used. Do not remove either. 
    … …  
    2312 
    2413from lxml import etree 
     14 
     15from sas.sascalc.data_util.nxsunit import Converter 
     16 
     17# For saving individual sections of data 
     18from ..data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D, \ 
     19    Collimation, TransmissionSpectrum, Detector, Process, Aperture, \ 
     20    combine_data_info_with_plottable as combine_data 
     21from ..loader_exceptions import FileContentsException, DefaultReaderException, \ 
     22    DataReaderException 
     23from . import xml_reader 
     24from .xml_reader import XMLreader 
     25from .cansas_constants import CansasConstants, CurrentLevel 
    2526 
    2627logger = logging.getLogger(__name__) 
    … …  
    3435              "as much of the data as possible.\n\n" 
    3536HAS_CONVERTER = True 
    36 try: 
    37     from sas.sascalc.data_util.nxsunit import Converter 
    38 except ImportError: 
    39     HAS_CONVERTER = False 
    4037 
    4138CONSTANTS = CansasConstants() 
    … …  
    163160                raise fc_exc 
    164161        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
    165             raise FileContentsException(e.message) 
     162            raise 
     163            raise FileContentsException(str(e)) 
    166164 
    167165 
    … …  
    632630                else: 
    633631                    save_in = "current_datainfo" 
    634                 exec "default_unit = self.{0}.{1}".format(save_in, unitname) 
    635                 if local_unit and default_unit and local_unit.lower() != default_unit.lower() \ 
    636                         and local_unit.lower() != "none": 
    637                     if HAS_CONVERTER == True: 
     632                default_unit = getattrchain(self, '.'.join((save_in, unitname))) 
     633                if (local_unit and default_unit 
     634                        and local_unit.lower() != default_unit.lower() 
     635                        and local_unit.lower() != "none"): 
     636                    if HAS_CONVERTER: 
    638637                        # Check local units - bad units raise KeyError 
     638                        #print("loading", tagname, node_value, local_unit, default_unit) 
    639639                        data_conv_q = Converter(local_unit) 
    640640                        value_unit = default_unit 
    … …  
    654654                    err_msg += "expecting [{0}]".format(default_unit) 
    655655                value_unit = local_unit 
    656             except: 
     656            except Exception: 
    657657                err_msg = "CanSAS reader: unknown error converting " 
    658658                err_msg += "\"{0}\" unit [{1}]" 
    … …  
    717717        doc, _ = self._to_xml_doc(datainfo) 
    718718        # Write the file 
    719         file_ref = open(filename, 'w') 
     719        file_ref = open(filename, 'wb') 
    720720        if self.encoding is None: 
    721721            self.encoding = "UTF-8" 
    … …  
    908908        point = self.create_element("Idata") 
    909909        node.append(point) 
    910         qx = ','.join([str(datainfo.qx_data[i]) for i in xrange(len(datainfo.qx_data))]) 
    911         qy = ','.join([str(datainfo.qy_data[i]) for i in xrange(len(datainfo.qy_data))]) 
    912         intensity = ','.join([str(datainfo.data[i]) for i in xrange(len(datainfo.data))]) 
     910        qx = ','.join(str(v) for v in datainfo.qx_data) 
     911        qy = ','.join(str(v) for v in datainfo.qy_data) 
     912        intensity = ','.join(str(v) for v in datainfo.data) 
    913913 
    914914        self.write_node(point, "Qx", qx, 
    … …  
    919919                        {'unit': datainfo._zunit}) 
    920920        if datainfo.err_data is not None: 
    921             err = ','.join([str(datainfo.err_data[i]) for i in 
    922                             xrange(len(datainfo.err_data))]) 
     921            err = ','.join(str(v) for v in datainfo.err_data) 
    923922            self.write_node(point, "Idev", err, 
    924923                            {'unit': datainfo._zunit}) 
    925924        if datainfo.dqy_data is not None: 
    926             dqy = ','.join([str(datainfo.dqy_data[i]) for i in 
    927                             xrange(len(datainfo.dqy_data))]) 
     925            dqy = ','.join(str(v) for v in datainfo.dqy_data) 
    928926            self.write_node(point, "Qydev", dqy, 
    929927                            {'unit': datainfo._yunit}) 
    930928        if datainfo.dqx_data is not None: 
    931             dqx = ','.join([str(datainfo.dqx_data[i]) for i in 
    932                             xrange(len(datainfo.dqx_data))]) 
     929            dqx = ','.join(str(v) for v in datainfo.dqx_data) 
    933930            self.write_node(point, "Qxdev", dqx, 
    934931                            {'unit': datainfo._xunit}) 
    935932        if datainfo.mask is not None: 
    936             mask = ','.join( 
    937                 ["1" if datainfo.mask[i] else "0" 
    938                  for i in xrange(len(datainfo.mask))]) 
     933            mask = ','.join("1" if v else "0" for v in datainfo.mask) 
    939934            self.write_node(point, "Mask", mask) 
    940935 
    … …  
    12801275        try: 
    12811276            value = float(entry.text) 
    1282         except: 
     1277        except ValueError: 
    12831278            value = None 
    12841279 
    … …  
    12891284            if units is not None: 
    12901285                toks = variable.split('.') 
    1291                 local_unit = None 
    1292                 exec "local_unit = storage.%s_unit" % toks[0] 
     1286                # TODO: why split() when accessing unit, but not when setting value? 
     1287                local_unit = getattr(storage, toks[0]+"_unit") 
    12931288                if local_unit is not None and units.lower() != local_unit.lower(): 
    12941289                    if HAS_CONVERTER == True: 
    12951290                        try: 
    12961291                            conv = Converter(units) 
    1297                             exec "storage.%s = %g" % \ 
    1298                                 (variable, conv(value, units=local_unit)) 
    1299                         except: 
     1292                            setattrchain(storage, variable, conv(value, units=local_unit)) 
     1293                        except Exception: 
    13001294                            _, exc_value, _ = sys.exc_info() 
    13011295                            err_mess = "CanSAS reader: could not convert" 
    … …  
    13061300                                logger.info(err_mess) 
    13071301                            else: 
    1308                                 raise ValueError, err_mess 
     1302                                raise ValueError(err_mess) 
    13091303                    else: 
    13101304                        err_mess = "CanSAS reader: unrecognized %s unit [%s];"\ 
    … …  
    13151309                            logger.info(err_mess) 
    13161310                        else: 
    1317                             raise ValueError, err_mess 
     1311                            raise ValueError(err_mess) 
    13181312                else: 
    1319                     exec "storage.%s = value" % variable 
     1313                    setattrchain(storage, variable, value) 
    13201314            else: 
    1321                 exec "storage.%s = value" % variable 
     1315                setattrchain(storage, variable, value) 
    13221316 
    13231317    # DO NOT REMOVE - used in saving and loading panel states. 
    … …  
    13391333        entry = get_content(location, node) 
    13401334        if entry is not None and entry.text is not None: 
    1341             exec "storage.%s = entry.text.strip()" % variable 
     1335            exec("storage.%s = entry.text.strip()" % variable) 
    13421336 
    13431337# DO NOT REMOVE Called by outside packages: 
    … …  
    13821376        return True 
    13831377    return False 
     1378 
     1379def getattrchain(obj, chain, default=None): 
     1380    """Like getattr, but the attr may contain multiple parts separated by '.'""" 
     1381    for part in chain.split('.'): 
     1382        if hasattr(obj, part): 
     1383            obj = getattr(obj, part, None) 
     1384        else: 
     1385            return default 
     1386    return obj 
     1387 
     1388def setattrchain(obj, chain, value): 
     1389    """Like setattr, but the attr may contain multiple parts separated by '.'""" 
     1390    parts = list(chain.split('.')) 
     1391    for part in parts[-1]: 
     1392        obj = getattr(obj, part, None) 
     1393        if obj is None: 
     1394            raise ValueError("missing parent object "+part) 
     1395    setattr(obj, value) 

  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rcd57c7d4 r7b50f14  
    99import sys 
    1010 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\ 
     11from ..data_info import plottable_1D, plottable_2D,\ 
    1212    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
    1313    TransmissionSpectrum, Detector 
    14 from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
    15 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DefaultReaderException 
    16 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    17  
     14from ..data_info import combine_data_info_with_plottable 
     15from ..loader_exceptions import FileContentsException, DefaultReaderException 
     16from ..file_reader_base_class import FileReader, decode 
     17 
     18def h5attr(node, key, default=None): 
     19    return decode(node.attrs.get(key, default)) 
    1820 
    1921class Reader(FileReader): 
    … …  
    130132            # Get all information for the current key 
    131133            value = data.get(key) 
    132             if value.attrs.get(u'canSAS_class') is not None: 
    133                 class_name = value.attrs.get(u'canSAS_class') 
    134             else: 
    135                 class_name = value.attrs.get(u'NX_class') 
     134            class_name = h5attr(value, u'canSAS_class') 
     135            if class_name is None: 
     136                class_name = h5attr(value, u'NX_class') 
    136137            if class_name is not None: 
    137138                class_prog = re.compile(class_name) 
    … …  
    225226 
    226227                for data_point in data_set: 
     228                    if data_point.dtype.char == 'S': 
     229                        data_point = decode(bytes(data_point)) 
    227230                    # Top Level Meta Data 
    228231                    if key == u'definition': 
    … …  
    231234                        self.current_datainfo.run.append(data_point) 
    232235                        try: 
    233                             run_name = value.attrs['name'] 
     236                            run_name = h5attr(value, 'name') 
    234237                            run_dict = {data_point: run_name} 
    235238                            self.current_datainfo.run_name = run_dict 
    236                         except: 
     239                        except Exception: 
    237240                            pass 
    238241                    elif key == u'title': 
    … …  
    576579        :return: unit for the value passed to the method 
    577580        """ 
    578         unit = value.attrs.get(u'units') 
     581        unit = h5attr(value, u'units') 
    579582        if unit is None: 
    580             unit = value.attrs.get(u'unit') 
     583            unit = h5attr(value, u'unit') 
    581584        # Convert the unit formats 
    582585        if unit == "1/A": 

  • src/sas/sascalc/dataloader/readers/danse_reader.py

    ra78a02f raf3e9f5  
    1414import math 
    1515import os 
     16import logging 
     17 
    1618import numpy as np 
    17 import logging 
    18 from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    19 from sas.sascalc.dataloader.manipulations import reader2D_converter 
    20 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    21 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
     19 
     20from ..data_info import plottable_2D, DataInfo, Detector 
     21from ..manipulations import reader2D_converter 
     22from ..file_reader_base_class import FileReader 
     23from ..loader_exceptions import FileContentsException, DataReaderException 
    2224 
    2325logger = logging.getLogger(__name__) 
    … …  
    7880        data_start_line = 1 
    7981        while read_on: 
    80             line = self.f_open.readline() 
     82            line = self.nextline() 
    8183            data_start_line += 1 
    8284            if line.find("DATA:") >= 0: 
    … …  
    112114            raise FileContentsException(msg) 
    113115 
    114         for line_num, data_str in enumerate(self.f_open.readlines()): 
     116        for line_num, data_str in enumerate(self.nextlines()): 
    115117            toks = data_str.split() 
    116118            try: 

  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    r2f85af7 rc8321cfc  
    1010###################################################################### 
    1111import os 
     12import math 
     13import time 
     14 
    1215import numpy as np 
    13 import math 
    14 from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    15 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    16 from sas.sascalc.dataloader.loader_exceptions import FileContentsException 
    17  
    18 # Look for unit converter 
    19 has_converter = True 
    20 try: 
    21     from sas.sascalc.data_util.nxsunit import Converter 
    22 except: 
    23     has_converter = False 
     16 
     17from sas.sascalc.data_util.nxsunit import Converter 
     18 
     19from ..data_info import plottable_2D, DataInfo, Detector 
     20from ..file_reader_base_class import FileReader 
     21from ..loader_exceptions import FileContentsException 
    2422 
    2523 
    … …  
    3129    try: 
    3230        return float(x_point) 
    33     except: 
     31    except Exception: 
    3432        return 0 
    3533 
    … …  
    5149        :param data: data2D 
    5250        """ 
    53         import time 
    5451        # Write the file 
    5552        try: 
    … …  
    7269    def get_file_contents(self): 
    7370        # Read file 
    74         buf = self.f_open.read() 
     71        buf = self.readall() 
    7572        self.f_open.close() 
    7673        # Instantiate data object 
    … …  
    119116                try: 
    120117                    wavelength = float(line_toks[1]) 
    121                     # Units 
    122                     if has_converter == True and \ 
    123                     self.current_datainfo.source.wavelength_unit != 'A': 
     118                    # Wavelength is stored in angstroms; convert if necessary 
     119                    if self.current_datainfo.source.wavelength_unit != 'A': 
    124120                        conv = Converter('A') 
    125121                        wavelength = conv(wavelength, 
    126122                                          units=self.current_datainfo.source.wavelength_unit) 
    127                 except: 
    128                     #Not required 
    129                     pass 
    130                 # Distance in mm 
     123                except Exception: 
     124                    pass  # Not required 
    131125                try: 
    132126                    distance = float(line_toks[3]) 
    133                     # Units 
    134                     if has_converter == True and self.current_datainfo.detector[0].distance_unit != 'm': 
     127                    # Distance is stored in meters; convert if necessary 
     128                    if self.current_datainfo.detector[0].distance_unit != 'm': 
    135129                        conv = Converter('m') 
    136130                        distance = conv(distance, 
    137131                            units=self.current_datainfo.detector[0].distance_unit) 
    138                 except: 
    139                     #Not required 
    140                     pass 
    141  
    142                 # Distance in meters 
     132                except Exception: 
     133                    pass  # Not required 
     134 
    143135                try: 
    144136                    transmission = float(line_toks[4]) 
    145                 except: 
    146                     #Not required 
    147                     pass 
     137                except Exception: 
     138                    pass  # Not required 
    148139 
    149140            if line.count("LAMBDA") > 0: 
    … …  
    170161 
    171162            ## Read and get data. 
    172             if data_started == True: 
     163            if data_started: 
    173164                line_toks = line.split() 
    174165                if len(line_toks) == 0: 
    … …  
    178169                col_num = len(line_toks) 
    179170                break 
     171 
    180172        # Make numpy array to remove header lines using index 
    181173        lines_array = np.array(lines) 
    … …  
    203195        # Change it(string) into float 
    204196        #data_list = map(float,data_list) 
    205         data_list1 = map(check_point, data_list) 
     197        data_list1 = list(map(check_point, data_list)) 
    206198 
    207199        # numpy array form 
    … …  
    211203        try: 
    212204            data_point = data_array.reshape(row_num, col_num).transpose() 
    213         except: 
     205        except Exception: 
    214206            msg = "red2d_reader can't read this file: Incorrect number of data points provided." 
    215207            raise FileContentsException(msg) 
    … …  
    325317 
    326318        # Units of axes 
    327         self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    328         self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    329         self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     319        self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}') 
     320        self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}') 
     321        self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}") 
    330322 
    331323        # Store loading process information 

  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    rbe43448 r849094a  
    66    Jurrian Bakker 
    77""" 
     8import os 
     9 
    810import numpy as np 
    9 import os 
    10 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, DataInfo 
    12 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
     11 
     12from ..file_reader_base_class import FileReader 
     13from ..data_info import plottable_1D, DataInfo 
     14from ..loader_exceptions import FileContentsException, DataReaderException 
    1315 
    1416# Check whether we have a converter available 
    … …  
    4244        self.output = [] 
    4345 
    44         line = self.f_open.readline() 
     46        line = self.nextline() 
    4547        params = {} 
    4648        while not line.startswith("BEGIN_DATA"): 
    … …  
    4850            if len(terms) >= 2: 
    4951                params[terms[0]] = " ".join(terms[1:]) 
    50             line = self.f_open.readline() 
     52            line = self.nextline() 
    5153        self.params = params 
    5254 
    … …  
    6870                               "handled by other software.") 
    6971 
    70         headers = self.f_open.readline().split() 
     72        headers = self.nextline().split() 
    7173 
    7274        self._insist_header(headers, "SpinEchoLength") 

  • src/sas/sascalc/dataloader/readers/tiff_reader.py

    r959eb01 r574adc7  
    22#This software was developed by the University of Tennessee as part of the 
    33#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    4 #project funded by the US National Science Foundation.  
     4#project funded by the US National Science Foundation. 
    55#See the license text in license.txt 
    66#copyright 2008, University of Tennessee 
    … …  
    3131    ## Extension 
    3232    ext = ['.tif', '.tiff'] 
    33          
     33 
    3434    def read(self, filename=None): 
    3535        """ 
    3636        Open and read the data in a file 
    37          
     37 
    3838        :param file: path of the file 
    3939        """ 
    … …  
    4444        except: 
    4545            msg = "tiff_reader: could not load file. Missing Image module." 
    46             raise RuntimeError, msg 
    47          
     46            raise RuntimeError(msg) 
     47 
    4848        # Instantiate data object 
    4949        output = Data2D() 
    5050        output.filename = os.path.basename(filename) 
    51              
     51 
    5252        # Read in the image 
    5353        try: 
    5454            im = Image.open(filename) 
    5555        except: 
    56             raise  RuntimeError, "cannot open %s"%(filename) 
     56            raise  RuntimeError("cannot open %s"%(filename)) 
    5757        data = im.getdata() 
    5858 
    … …  
    6161        output.err_data = np.zeros([im.size[0], im.size[1]]) 
    6262        output.mask = np.ones([im.size[0], im.size[1]], dtype=bool) 
    63          
     63 
    6464        # Initialize 
    6565        x_vals = [] 
    … …  
    6969        for i_x in range(im.size[0]): 
    7070            x_vals.append(i_x) 
    71              
     71 
    7272        itot = 0 
    7373        for i_y in range(im.size[1]): 
    … …  
    8080                logger.error("tiff_reader: had to skip a non-float point") 
    8181                continue 
    82              
     82 
    8383            # Get bin number 
    8484            if math.fmod(itot, im.size[0]) == 0: 
    … …  
    8787            else: 
    8888                i_x += 1 
    89                  
     89 
    9090            output.data[im.size[1] - 1 - i_y][i_x] = value 
    91              
     91 
    9292            itot += 1 
    93                  
     93 
    9494        output.xbins = im.size[0] 
    9595        output.ybins = im.size[1] 
    … …  
    102102        output.ymin = 0 
    103103        output.ymax = im.size[0] - 1 
    104          
     104 
    105105        # Store loading process information 
    106106        output.meta_data['loader'] = self.type_name 

  • src/sas/sascalc/dataloader/readers/xml_reader.py

    rcd57c7d4 r7b50f14  
    1616 
    1717import logging 
     18 
    1819from lxml import etree 
    1920from lxml.builder import E 
    20 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     21 
     22from ..file_reader_base_class import FileReader, decode 
    2123 
    2224logger = logging.getLogger(__name__) 
    … …  
    151153        Converts an etree element into a string 
    152154        """ 
    153         return etree.tostring(elem, pretty_print=pretty_print, \ 
    154                               encoding=encoding) 
     155        return decode(etree.tostring(elem, pretty_print=pretty_print, 
     156                                     encoding=encoding)) 
    155157 
    156158    def break_processing_instructions(self, string, dic): 
Note: See TracChangeset for help on using the changeset viewer.