Changeset 14011


Ignore:
Timestamp:
Nov 11, 2019 9:41:38 PM (4 weeks ago)
Author:
Christian Andersson
Message:

Merged latest changes to release branch. Related to ticket:5873

Location:
PyFMI/branches/PyFMI-2.5.x
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • PyFMI/branches/PyFMI-2.5.x

  • PyFMI/branches/PyFMI-2.5.x/CHANGELOG

    r13729 r14011  
    11--- CHANGELOG ---
     2
     3--- PyFMI-2.5.6 ---
     4    * Fixed such that instance attributes 'name' and 'raw_name' in class ResultDymolaBinary
     5      are now attributes that consists of strings instead of bytes in Python 3.
     6    * Fixed issue with set_string when input was a list of strings in Python 3.
     7    * Methods _get_types_platform and get_version now returns data of type string
     8      instead of bytes with Python 3.
     9    * Fixed other bytes/string incompabilities that caused exceptions with
     10      Python 3.
    211
    312--- PyFMI-2.5.5 ---
  • PyFMI/branches/PyFMI-2.5.x/src/common

  • PyFMI/branches/PyFMI-2.5.x/src/common/core.py

    r13031 r14011  
    106106            (FMU)Model.set(['damper.d','gear.a'], [1.1, 10])
    107107        """
    108         if isinstance(variable_name, basestring):
     108        if isinstance(variable_name, str):
    109109            self._set(variable_name, value) #Scalar case
    110110        else:
    111             for i in xrange(len(variable_name)): #A list of variables
     111            for i in range(len(variable_name)): #A list of variables
    112112                self._set(variable_name[i], value[i])
    113113   
     
    133133            (FMU)Model.get(['damper.d','gear.a'])
    134134        """
    135         if isinstance(variable_name, basestring):
     135        if isinstance(variable_name, str):
    136136            return self._get(variable_name) #Scalar case
    137137        else:
    138138            ret = []
    139             for i in xrange(len(variable_name)): #A list of variables
     139            for i in range(len(variable_name)): #A list of variables
    140140                ret += [self._get(variable_name[i])]
    141141            return ret
     
    155155        AlgorithmBase = getattr(algdrive, 'AlgorithmBase')
    156156       
    157         if isinstance(algorithm, basestring):
     157        if isinstance(algorithm, str):
    158158            module = __import__(module, globals(), locals(), [algorithm], -1)
    159159            algorithm = getattr(module, algorithm)
     
    190190        AlgorithmBase = getattr(algdrive, 'AlgorithmBase')
    191191       
    192         if isinstance(algorithm, basestring):
     192        if isinstance(algorithm, str):
    193193            module = __import__(module, globals(), locals(), [algorithm], -1)
    194194            algorithm = getattr(module, algorithm)
  • PyFMI/branches/PyFMI-2.5.x/src/common/io.py

    r13581 r14011  
    116116    Base class for representation of a result file.
    117117    """
     118    def _get_name(self):
     119        return [decode(n) for n in self._name]
     120   
     121    name = property(fget = _get_name)
     122   
    118123    def get_variable_index(self,name):
    119124        """
     
    180185        for ind in alias_index:
    181186            #Get the trial name
    182             trial_name = self.name[ind]
     187            trial_name = self._name[ind]
    183188           
    184189            #Create the derivative name
     
    266271        else:
    267272            raise JIOError('Unsupported separator.')
    268         self.name = name
     273        self._name = name
    269274       
    270275        self.data_matrix = {}
     
    724729        self.model = model
    725730        self.vars = vars
    726         self.name = [var.name for var in vars.values()]
     731        self._name = [var.name for var in vars.values()]
    727732        self.data = {}
    728733        self.data_matrix = data
     
    853858        fid = codecs.open(fname,'r','utf-8')
    854859       
    855         result  = [];
     860        result  = []
    856861     
    857862        # Read Aclass section
     
    873878        #for i in range(0,nLines):
    874879        #    name.append(fid.readline().strip().replace(" ",""))
    875         self.name = name
    876         self.name_lookup = {key:ind for ind,key in enumerate(self.name)}
     880        self._name = name
     881        self.name_lookup = {key:ind for ind,key in enumerate(self._name)}
    877882     
    878883        # Read description section 
     
    11191124        self.raw_name = name
    11201125
    1121         self.name = fmi_util.convert_array_names_list_names_int(name.view(np.int32))
     1126        self._name = fmi_util.convert_array_names_list_names_int(name.view(np.int32))
    11221127        self.dataInfo = self.raw['dataInfo'].transpose()
    1123         self.name_lookup = {key:ind for ind,key in enumerate(self.name)}
    1124        
    1125         self._description = None
    1126        
     1128        self.name_lookup = {key:ind for ind,key in enumerate(self._name)}
     1129       
     1130        self._description = None 
     1131   
    11271132    def _get_description(self):
    11281133        if not self._description:
  • PyFMI/branches/PyFMI-2.5.x/src/common/xmlparser.py

    r9999 r14011  
    950950            for sv in scalarvariables:
    951951                names.append(sv.get_name())
    952             return zip(tuple(self._vrefs),tuple(names))
     952            return list(zip(tuple(self._vrefs),tuple(names)))
    953953
    954954        for sv in scalarvariables:
    955955            if sv.get_alias() == NO_ALIAS:
    956956                names.append(sv.get_name())
    957         return zip(tuple(self._vrefs_noAlias),tuple(names))
     957        return list(zip(tuple(self._vrefs_noAlias),tuple(names)))
    958958       
    959959    def get_variable_aliases(self, ignore_cache=False):
     
    980980        for sv in scalarvariables:
    981981            alias_data.append(sv.get_alias())
    982         return zip(tuple(self._vrefs),tuple(alias_data))
     982        return list(zip(tuple(self._vrefs),tuple(alias_data)))
    983983
    984984    def get_variable_descriptions(self, include_alias=True, ignore_cache=False):
     
    10141014            for sv in scalarvariables:
    10151015                descriptions.append(sv.get_description())
    1016             return zip(tuple(self._vrefs),tuple(descriptions))
     1016            return list(zip(tuple(self._vrefs),tuple(descriptions)))
    10171017           
    10181018        for sv in scalarvariables:
    10191019            if sv.get_alias() == NO_ALIAS:
    10201020                descriptions.append(sv.get_description())
    1021         return zip(tuple(self._vrefs_noAlias),tuple(descriptions))
     1021        return list(zip(tuple(self._vrefs_noAlias),tuple(descriptions)))
    10221022       
    10231023    def get_variable_variabilities(self, include_alias=True,
     
    10541054            for sv in scalarvariables:
    10551055                variabilities.append(sv.get_variability())
    1056             return zip(tuple(self._vrefs),tuple(variabilities))
     1056            return list(zip(tuple(self._vrefs),tuple(variabilities)))
    10571057       
    10581058        for sv in scalarvariables:
    10591059            if sv.get_alias() == NO_ALIAS:
    10601060                variabilities.append(sv.get_variability())
    1061         return zip(tuple(self._vrefs_noAlias),tuple(variabilities))
     1061        return list(zip(tuple(self._vrefs_noAlias),tuple(variabilities)))
    10621062
    10631063    def get_variable_nominal_attributes(self, include_alias=True,
     
    10981098                else:
    10991099                    nominals.append(None)
    1100             return zip(tuple(self._vrefs),tuple(nominals))
     1100            return list(zip(tuple(self._vrefs),tuple(nominals)))
    11011101       
    11021102        for sv in scalarvariables:
     
    11071107                else:
    11081108                    nominals.append(None)
    1109         return zip(tuple(self._vrefs_noAlias),tuple(nominals))
     1109        return list(zip(tuple(self._vrefs_noAlias),tuple(nominals)))
    11101110
    11111111    def get_variable_fixed_attributes(self, include_alias=True,
     
    11461146                else:
    11471147                    fixeds.append(None)
    1148             return zip(tuple(self._vrefs),tuple(fixeds))
     1148            return list(zip(tuple(self._vrefs),tuple(fixeds)))
    11491149       
    11501150        for sv in scalarvariables:
     
    11551155                else:
    11561156                    fixeds.append(None)
    1157         return zip(tuple(self._vrefs_noAlias),tuple(fixeds))
     1157        return list(zip(tuple(self._vrefs_noAlias),tuple(fixeds)))
    11581158
    11591159
     
    11921192            for sv in scalarvariables:
    11931193                start_attributes.append(sv.get_fundamental_type().get_start())
    1194             return zip(tuple(self._vrefs), tuple(start_attributes))
     1194            return list(zip(tuple(self._vrefs), tuple(start_attributes)))
    11951195       
    11961196        for sv in scalarvariables:
    11971197            if sv.get_alias() == NO_ALIAS:
    11981198                start_attributes.append(sv.get_fundamental_type().get_start())
    1199         return zip(tuple(self._vrefs_noAlias), tuple(start_attributes))
     1199        return list(zip(tuple(self._vrefs_noAlias), tuple(start_attributes)))
    12001200       
    12011201    def get_all_real_variables(self, include_alias=True, ignore_cache=False):
     
    13611361                        vrefs.append(sv.get_value_reference())
    13621362                        names.append(sv.get_name())
    1363             return zip(tuple(vrefs), tuple(names))
     1363            return list(zip(tuple(vrefs), tuple(names)))
    13641364           
    13651365        for sv in scalarvariables:
     
    13691369                        vrefs.append(sv.get_value_reference())
    13701370                        names.append(sv.get_name())
    1371         return zip(tuple(vrefs), tuple(names))
     1371        return list(zip(tuple(vrefs), tuple(names)))
    13721372               
    13731373    def get_dx_variable_names(self, include_alias=True, ignore_cache=False):
     
    14051405                    vrefs.append(sv.get_value_reference())
    14061406                    names.append(sv.get_name())
    1407             return zip(tuple(vrefs), tuple(names))
     1407            return list(zip(tuple(vrefs), tuple(names)))
    14081408           
    14091409        for sv in scalarvariables:
     
    14121412                    vrefs.append(sv.get_value_reference())
    14131413                    names.append(sv.get_name())
    1414         return zip(tuple(vrefs), tuple(names))
     1414        return list(zip(tuple(vrefs), tuple(names)))
    14151415                   
    14161416    def get_x_variable_names(self, include_alias=True, ignore_cache=False):
     
    14491449                    vrefs.append(sv.get_value_reference())
    14501450                    names.append(sv.get_name())
    1451             return zip(tuple(vrefs), tuple(names))
     1451            return list(zip(tuple(vrefs), tuple(names)))
    14521452           
    14531453        for sv in scalarvariables:
     
    14561456                    vrefs.append(sv.get_value_reference())
    14571457                    names.append(sv.get_name())
    1458         return zip(tuple(vrefs), tuple(names))
     1458        return list(zip(tuple(vrefs), tuple(names)))
    14591459                   
    14601460    def get_u_variable_names(self, include_alias=True, ignore_cache=False):
     
    14921492                    vrefs.append(sv.get_value_reference())
    14931493                    names.append(sv.get_name())
    1494             return zip(tuple(vrefs), tuple(names))
     1494            return list(zip(tuple(vrefs), tuple(names)))
    14951495           
    14961496        for sv in scalarvariables:
     
    15001500                    vrefs.append(sv.get_value_reference())
    15011501                    names.append(sv.get_name())
    1502         return zip(tuple(vrefs), tuple(names))
     1502        return list(zip(tuple(vrefs), tuple(names)))
    15031503
    15041504    def get_w_variable_names(self, include_alias=True, ignore_cache=False):
     
    15361536                    vrefs.append(sv.get_value_reference())
    15371537                    names.append(sv.get_name())
    1538             return zip(tuple(vrefs), tuple(names))
     1538            return list(zip(tuple(vrefs), tuple(names)))
    15391539           
    15401540        for sv in scalarvariables:
     
    15441544                    vrefs.append(sv.get_value_reference())
    15451545                    names.append(sv.get_name())
    1546         return zip(tuple(vrefs), tuple(names))
     1546        return list(zip(tuple(vrefs), tuple(names)))
    15471547
    15481548    def get_p_opt_start(self, include_alias=True, ignore_cache=False):
     
    15821582                    vrefs.append(sv.get_value_reference())
    15831583                    start_attributes.append(sv.get_fundamental_type().get_start())
    1584             return zip(tuple(vrefs), tuple(start_attributes))
     1584            return list(zip(tuple(vrefs), tuple(start_attributes)))
    15851585           
    15861586        for sv in scalarvariables:
     
    15901590                    vrefs.append(sv.get_value_reference())
    15911591                    start_attributes.append(sv.get_fundamental_type().get_start())
    1592         return zip(tuple(vrefs), tuple(start_attributes))
     1592        return list(zip(tuple(vrefs), tuple(start_attributes)))
    15931593               
    15941594    def get_dx_start(self, include_alias=True, ignore_cache=False):
     
    16261626                    vrefs.append(sv.get_value_reference())
    16271627                    start_attributes.append(sv.get_fundamental_type().get_start())
    1628             return zip(tuple(vrefs), tuple(start_attributes))
     1628            return list(zip(tuple(vrefs), tuple(start_attributes)))
    16291629           
    16301630        for sv in scalarvariables:
     
    16331633                    vrefs.append(sv.get_value_reference())
    16341634                    start_attributes.append(sv.get_fundamental_type().get_start())
    1635         return zip(tuple(vrefs), tuple(start_attributes))
     1635        return list(zip(tuple(vrefs), tuple(start_attributes)))
    16361636                   
    16371637    def get_x_start(self, include_alias=True, ignore_cache=False):
     
    16691669                    vrefs.append(sv.get_value_reference())
    16701670                    start_attributes.append(sv.get_fundamental_type().get_start())
    1671             return zip(tuple(vrefs), tuple(start_attributes))
     1671            return list(zip(tuple(vrefs), tuple(start_attributes)))
    16721672           
    16731673        for sv in scalarvariables:
     
    16761676                    vrefs.append(sv.get_value_reference())
    16771677                    start_attributes.append(sv.get_fundamental_type().get_start())
    1678         return zip(tuple(vrefs), tuple(start_attributes))
     1678        return list(zip(tuple(vrefs), tuple(start_attributes)))
    16791679                   
    16801680    def get_u_start(self, include_alias=True, ignore_cache=False):
     
    17131713                    vrefs.append(sv.get_value_reference())
    17141714                    start_attributes.append(sv.get_fundamental_type().get_start())
    1715             return zip(tuple(vrefs), tuple(start_attributes))
     1715            return list(zip(tuple(vrefs), tuple(start_attributes)))
    17161716           
    17171717        for sv in scalarvariables:
     
    17211721                    vrefs.append(sv.get_value_reference())
    17221722                    start_attributes.append(sv.get_fundamental_type().get_start())
    1723         return zip(tuple(vrefs), tuple(start_attributes))
     1723        return list(zip(tuple(vrefs), tuple(start_attributes)))
    17241724
    17251725    def get_w_start(self, include_alias=True, ignore_cache=False):
     
    17581758                    vrefs.append(sv.get_value_reference())
    17591759                    start_attributes.append(sv.get_fundamental_type().get_start())
    1760             return zip(tuple(vrefs), tuple(start_attributes))
     1760            return list(zip(tuple(vrefs), tuple(start_attributes)))
    17611761           
    17621762        for sv in scalarvariables:
     
    17661766                    vrefs.append(sv.get_value_reference())
    17671767                    start_attributes.append(sv.get_fundamental_type().get_start())
    1768         return zip(tuple(vrefs), tuple(start_attributes))
     1768        return list(zip(tuple(vrefs), tuple(start_attributes)))
    17691769
    17701770############################
     
    18031803                    vrefs.append(sv.get_value_reference())
    18041804                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1805             return zip(tuple(vrefs), tuple(fixed_attributes))
     1805            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18061806           
    18071807        for sv in scalarvariables:
     
    18101810                    vrefs.append(sv.get_value_reference())
    18111811                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1812         return zip(tuple(vrefs), tuple(fixed_attributes))
     1812        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18131813                   
    18141814    def get_x_fixed(self, include_alias=True, ignore_cache=False):
     
    18461846                    vrefs.append(sv.get_value_reference())
    18471847                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1848             return zip(tuple(vrefs), tuple(fixed_attributes))
     1848            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18491849           
    18501850        for sv in scalarvariables:
     
    18531853                    vrefs.append(sv.get_value_reference())
    18541854                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1855         return zip(tuple(vrefs), tuple(fixed_attributes))
     1855        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18561856                   
    18571857    def get_u_fixed(self, include_alias=True, ignore_cache=False):
     
    18901890                    vrefs.append(sv.get_value_reference())
    18911891                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1892             return zip(tuple(vrefs), tuple(fixed_attributes))
     1892            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    18931893           
    18941894        for sv in scalarvariables:
     
    18981898                    vrefs.append(sv.get_value_reference())
    18991899                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1900         return zip(tuple(vrefs), tuple(fixed_attributes))
     1900        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19011901
    19021902    def get_w_fixed(self, include_alias=True, ignore_cache=False):
     
    19351935                    vrefs.append(sv.get_value_reference())
    19361936                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1937             return zip(tuple(vrefs), tuple(fixed_attributes))
     1937            return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19381938           
    19391939        for sv in scalarvariables:
     
    19431943                    vrefs.append(sv.get_value_reference())
    19441944                    fixed_attributes.append(sv.get_fundamental_type().get_fixed())
    1945         return zip(tuple(vrefs), tuple(fixed_attributes))
     1945        return list(zip(tuple(vrefs), tuple(fixed_attributes)))
    19461946
    19471947    def get_x_nominal(self, include_alias=True, ignore_cache=False):
     
    19791979                    vrefs.append(sv.get_value_reference())
    19801980                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    1981             return zip(tuple(vrefs), tuple(nominal_attributes))
     1981            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    19821982           
    19831983        for sv in scalarvariables:
     
    19861986                    vrefs.append(sv.get_value_reference())
    19871987                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    1988         return zip(tuple(vrefs), tuple(nominal_attributes))
     1988        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    19891989                   
    19901990    def get_u_nominal(self, include_alias=True, ignore_cache=False):
     
    20232023                    vrefs.append(sv.get_value_reference())
    20242024                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2025             return zip(tuple(vrefs), tuple(nominal_attributes))
     2025            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20262026           
    20272027        for sv in scalarvariables:
     
    20312031                    vrefs.append(sv.get_value_reference())
    20322032                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2033         return zip(tuple(vrefs), tuple(nominal_attributes))
     2033        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20342034
    20352035    def get_w_nominal(self, include_alias=True, ignore_cache=False):
     
    20682068                    vrefs.append(sv.get_value_reference())
    20692069                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2070             return zip(tuple(vrefs), tuple(nominal_attributes))
     2070            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20712071           
    20722072        for sv in scalarvariables:
     
    20762076                    vrefs.append(sv.get_value_reference())
    20772077                    nominal_attributes.append(sv.get_fundamental_type().get_nominal())
    2078         return zip(tuple(vrefs), tuple(nominal_attributes))
     2078        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    20792079
    20802080    def get_p_opt_nominal(self, include_alias=True, ignore_cache=False):
     
    21152115                    vrefs.append(sv.get_value_reference())
    21162116                    nominal_attributes.append(ftype.get_nominal())
    2117             return zip(tuple(vrefs), tuple(nominal_attributes))
     2117            return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    21182118           
    21192119        for sv in scalarvariables:
     
    21242124                vrefs.append(sv.get_value_reference())
    21252125                nominal_attributes.append(ftype.get_nominal())
    2126         return zip(tuple(vrefs), tuple(nominal_attributes))
     2126        return list(zip(tuple(vrefs), tuple(nominal_attributes)))
    21272127
    21282128#############################
     
    21662166                    vrefs.append(sv.get_value_reference())
    21672167                    initial_values.append(ftype.get_initial_guess())
    2168             return zip(tuple(vrefs), tuple(initial_values))
     2168            return list(zip(tuple(vrefs), tuple(initial_values)))
    21692169           
    21702170        for sv in scalarvariables:
     
    21782178                    vrefs.append(sv.get_value_reference())
    21792179                    initial_values.append(ftype.get_initial_guess())
    2180         return zip(tuple(vrefs), tuple(initial_values))
     2180        return list(zip(tuple(vrefs), tuple(initial_values)))
    21812181
    21822182    def get_dx_initial_guess(self, include_alias=True, ignore_cache=False):
     
    22192219                    vrefs.append(sv.get_value_reference())
    22202220                    initial_values.append(ftype.get_initial_guess())
    2221             return zip(tuple(vrefs), tuple(initial_values))
     2221            return list(zip(tuple(vrefs), tuple(initial_values)))
    22222222           
    22232223        for sv in scalarvariables:
     
    22302230                    vrefs.append(sv.get_value_reference())
    22312231                    initial_values.append(ftype.get_initial_guess())
    2232         return zip(tuple(vrefs), tuple(initial_values))
     2232        return list(zip(tuple(vrefs), tuple(initial_values)))
    22332233
    22342234    def get_x_initial_guess(self, include_alias=True, ignore_cache=False):
     
    22712271                        vrefs.append(sv.get_value_reference())
    22722272                        initial_values.append(ftype.get_initial_guess())
    2273             return zip(tuple(vrefs), tuple(initial_values))
     2273            return list(zip(tuple(vrefs), tuple(initial_values)))
    22742274           
    22752275        for sv in scalarvariables:
     
    22822282                    vrefs.append(sv.get_value_reference())
    22832283                    initial_values.append(ftype.get_initial_guess())
    2284         return zip(tuple(vrefs), tuple(initial_values))
     2284        return list(zip(tuple(vrefs), tuple(initial_values)))
    22852285
    22862286    def get_u_initial_guess(self, include_alias=True, ignore_cache=False):
     
    23242324                        vrefs.append(sv.get_value_reference())
    23252325                        initial_values.append(ftype.get_initial_guess())
    2326             return zip(tuple(vrefs), tuple(initial_values))
     2326            return list(zip(tuple(vrefs), tuple(initial_values)))
    23272327           
    23282328        for sv in scalarvariables:
     
    23362336                    vrefs.append(sv.get_value_reference())
    23372337                    initial_values.append(ftype.get_initial_guess())
    2338         return zip(tuple(vrefs), tuple(initial_values))
     2338        return list(zip(tuple(vrefs), tuple(initial_values)))
    23392339
    23402340    def get_w_initial_guess(self, include_alias=True, ignore_cache=False):
     
    23782378                        vrefs.append(sv.get_value_reference())
    23792379                        initial_values.append(ftype.get_initial_guess())
    2380             return zip(tuple(vrefs), tuple(initial_values))
     2380            return list(zip(tuple(vrefs), tuple(initial_values)))
    23812381           
    23822382        for sv in scalarvariables:
     
    23902390                    vrefs.append(sv.get_value_reference())
    23912391                    initial_values.append(ftype.get_initial_guess())
    2392         return zip(tuple(vrefs), tuple(initial_values))
     2392        return list(zip(tuple(vrefs), tuple(initial_values)))
    23932393
    23942394    def get_p_opt_min(self, include_alias=True, ignore_cache=False):
     
    24302430                    vrefs.append(sv.get_value_reference())
    24312431                    min_values.append(ftype.get_min())
    2432             return zip(tuple(vrefs), tuple(min_values))
     2432            return list(zip(tuple(vrefs), tuple(min_values)))
    24332433           
    24342434        for sv in scalarvariables:
     
    24422442                    vrefs.append(sv.get_value_reference())
    24432443                    min_values.append(ftype.get_min())
    2444         return zip(tuple(vrefs), tuple(min_values))
     2444        return list(zip(tuple(vrefs), tuple(min_values)))
    24452445
    24462446    def get_dx_min(self, include_alias=True, ignore_cache=False):
     
    24822482                    vrefs.append(sv.get_value_reference())
    24832483                    min_values.append(ftype.get_min())
    2484             return zip(tuple(vrefs), tuple(min_values))
     2484            return list(zip(tuple(vrefs), tuple(min_values)))
    24852485           
    24862486        for sv in scalarvariables:
     
    24932493                    vrefs.append(sv.get_value_reference())
    24942494                    min_values.append(ftype.get_min())
    2495         return zip(tuple(vrefs), tuple(min_values))
     2495        return list(zip(tuple(vrefs), tuple(min_values)))
    24962496
    24972497    def get_x_min(self, include_alias=True, ignore_cache=False):
     
    25332533                    vrefs.append(sv.get_value_reference())
    25342534                    min_values.append(ftype.get_min())
    2535             return zip(tuple(vrefs), tuple(min_values))
     2535            return list(zip(tuple(vrefs), tuple(min_values)))
    25362536           
    25372537        for sv in scalarvariables:
     
    25442544                    vrefs.append(sv.get_value_reference())
    25452545                    min_values.append(ftype.get_min())
    2546         return zip(tuple(vrefs), tuple(min_values))
     2546        return list(zip(tuple(vrefs), tuple(min_values)))
    25472547
    25482548    def get_u_min(self, include_alias=True, ignore_cache=False):
     
    25852585                    vrefs.append(sv.get_value_reference())
    25862586                    min_values.append(ftype.get_min())
    2587             return zip(tuple(vrefs), tuple(min_values))
     2587            return list(zip(tuple(vrefs), tuple(min_values)))
    25882588           
    25892589        for sv in scalarvariables:
     
    25972597                    vrefs.append(sv.get_value_reference())
    25982598                    min_values.append(ftype.get_min())
    2599         return zip(tuple(vrefs), tuple(min_values))
     2599        return list(zip(tuple(vrefs), tuple(min_values)))
    26002600
    26012601    def get_w_min(self, include_alias=True, ignore_cache=False):
     
    26382638                    vrefs.append(sv.get_value_reference())
    26392639                    min_values.append(ftype.get_min())
    2640             return zip(tuple(vrefs), tuple(min_values))
     2640            return list(zip(tuple(vrefs), tuple(min_values)))
    26412641           
    26422642        for sv in scalarvariables:
     
    26502650                    vrefs.append(sv.get_value_reference())
    26512651                    min_values.append(ftype.get_min())
    2652         return zip(tuple(vrefs), tuple(min_values))
     2652        return list(zip(tuple(vrefs), tuple(min_values)))
    26532653
    26542654    def get_p_opt_max(self, include_alias=True, ignore_cache=False):
     
    26902690                    vrefs.append(sv.get_value_reference())
    26912691                    max_values.append(ftype.get_max())
    2692             return zip(tuple(vrefs), tuple(max_values))
     2692            return list(zip(tuple(vrefs), tuple(max_values)))
    26932693           
    26942694        for sv in scalarvariables:
     
    27022702                    vrefs.append(sv.get_value_reference())
    27032703                    max_values.append(ftype.get_max())
    2704         return zip(tuple(vrefs), tuple(max_values))
     2704        return list(zip(tuple(vrefs), tuple(max_values)))
    27052705
    27062706    def get_dx_max(self, include_alias=True, ignore_cache=False):
     
    27422742                    vrefs.append(sv.get_value_reference())
    27432743                    max_values.append(ftype.get_max())
    2744             return zip(tuple(vrefs), tuple(max_values))
     2744            return list(zip(tuple(vrefs), tuple(max_values)))
    27452745           
    27462746        for sv in scalarvariables:
     
    27532753                    vrefs.append(sv.get_value_reference())
    27542754                    max_values.append(ftype.get_max())
    2755         return zip(tuple(vrefs), tuple(max_values))
     2755        return list(zip(tuple(vrefs), tuple(max_values)))
    27562756
    27572757    def get_x_max(self, include_alias=True, ignore_cache=False):
     
    27932793                    vrefs.append(sv.get_value_reference())
    27942794                    max_values.append(ftype.get_max())
    2795             return zip(tuple(vrefs), tuple(max_values))
     2795            return list(zip(tuple(vrefs), tuple(max_values)))
    27962796           
    27972797        for sv in scalarvariables:
     
    28042804                    vrefs.append(sv.get_value_reference())
    28052805                    max_values.append(ftype.get_max())
    2806         return zip(tuple(vrefs), tuple(max_values))
     2806        return list(zip(tuple(vrefs), tuple(max_values)))
    28072807
    28082808    def get_u_max(self, include_alias=True, ignore_cache=False):
     
    28452845                    vrefs.append(sv.get_value_reference())
    28462846                    max_values.append(ftype.get_max())
    2847             return zip(tuple(vrefs), tuple(max_values))
     2847            return list(zip(tuple(vrefs), tuple(max_values)))
    28482848           
    28492849        for sv in scalarvariables:
     
    28572857                    vrefs.append(sv.get_value_reference())
    28582858                    max_values.append(ftype.get_max())
    2859         return zip(tuple(vrefs), tuple(max_values))
     2859        return list(zip(tuple(vrefs), tuple(max_values)))
    28602860
    28612861    def get_w_max(self, include_alias=True, ignore_cache=False):
     
    28982898                    vrefs.append(sv.get_value_reference())
    28992899                    max_values.append(ftype.get_max())
    2900             return zip(tuple(vrefs), tuple(max_values))
     2900            return list(zip(tuple(vrefs), tuple(max_values)))
    29012901           
    29022902        for sv in scalarvariables:
     
    29102910                    vrefs.append(sv.get_value_reference())
    29112911                    max_values.append(ftype.get_max())
    2912         return zip(tuple(vrefs), tuple(max_values))
     2912        return list(zip(tuple(vrefs), tuple(max_values)))
    29132913
    29142914    def get_p_opt_islinear(self, include_alias=True, ignore_cache=False):
     
    29492949                    vrefs.append(sv.get_value_reference())
    29502950                    is_linear.append(sv.get_is_linear())
    2951             return zip(tuple(vrefs), tuple(is_linear))
     2951            return list(zip(tuple(vrefs), tuple(is_linear)))
    29522952           
    29532953        for sv in scalarvariables:
     
    29562956                    vrefs.append(sv.get_value_reference())
    29572957                    is_linear.append(sv.get_is_linear())
    2958         return zip(tuple(vrefs), tuple(is_linear))
     2958        return list(zip(tuple(vrefs), tuple(is_linear)))
    29592959
    29602960    def get_dx_islinear(self, include_alias=True, ignore_cache=False):
     
    29942994                    vrefs.append(sv.get_value_reference())
    29952995                    is_linear.append(sv.get_is_linear())
    2996             return zip(tuple(vrefs), tuple(is_linear))
     2996            return list(zip(tuple(vrefs), tuple(is_linear)))
    29972997           
    29982998        for sv in scalarvariables:
     
    30013001                    vrefs.append(sv.get_value_reference())
    30023002                    is_linear.append(sv.get_is_linear())
    3003         return zip(tuple(vrefs), tuple(is_linear))
     3003        return list(zip(tuple(vrefs), tuple(is_linear)))
    30043004
    30053005    def get_x_islinear(self, include_alias=True, ignore_cache=False):
     
    30393039                    vrefs.append(sv.get_value_reference())
    30403040                    is_linear.append(sv.get_is_linear())
    3041             return zip(tuple(vrefs), tuple(is_linear))
     3041            return list(zip(tuple(vrefs), tuple(is_linear)))
    30423042           
    30433043        for sv in scalarvariables:
     
    30463046                    vrefs.append(sv.get_value_reference())
    30473047                    is_linear.append(sv.get_is_linear())
    3048         return zip(tuple(vrefs), tuple(is_linear))
     3048        return list(zip(tuple(vrefs), tuple(is_linear)))
    30493049
    30503050    def get_u_islinear(self, include_alias=True, ignore_cache=False):
     
    30853085                    vrefs.append(sv.get_value_reference())
    30863086                    is_linear.append(sv.get_is_linear())
    3087             return zip(tuple(vrefs), tuple(is_linear))
     3087            return list(zip(tuple(vrefs), tuple(is_linear)))
    30883088           
    30893089        for sv in scalarvariables:
     
    30933093                    vrefs.append(sv.get_value_reference())
    30943094                    is_linear.append(sv.get_is_linear())
    3095         return zip(tuple(vrefs), tuple(is_linear))
     3095        return list(zip(tuple(vrefs), tuple(is_linear)))
    30963096
    30973097    def get_w_islinear(self, include_alias=True, ignore_cache=False):
     
    31323132                    vrefs.append(sv.get_value_reference())
    31333133                    is_linear.append(sv.get_is_linear())
    3134             return zip(tuple(vrefs), tuple(is_linear))
     3134            return list(zip(tuple(vrefs), tuple(is_linear)))
    31353135           
    31363136        for sv in scalarvariables:
     
    31403140                    vrefs.append(sv.get_value_reference())
    31413141                    is_linear.append(sv.get_is_linear())
    3142         return zip(tuple(vrefs), tuple(is_linear))
     3142        return list(zip(tuple(vrefs), tuple(is_linear)))
    31433143       
    31443144    def get_dx_linear_timed_variables(self, include_alias=True,
     
    51135113            values.append(ip.get_value())
    51145114           
    5115         return dict(zip(names, values))
     5115        return dict(list(zip(names, values)))
    51165116       
    51175117    def get_all_parameters(self):
     
    56575657            result = f(ignore_cache=True)
    56585658        # check if function is already in cache
    5659         if not self.cache.has_key(function):
     5659        if function not in self.cache:
    56605660            # function is not in cache so add both function
    56615661            # and return result which is either a dict or
  • PyFMI/branches/PyFMI-2.5.x/src/pyfmi

  • PyFMI/branches/PyFMI-2.5.x/src/pyfmi/fmi.pyx

    r13581 r14011  
    12851285        """
    12861286        version = FMIL.fmi1_import_get_version(self._fmu)
    1287         return version
     1287        return decode(version)
    12881288
    12891289    def _get_version(self):
     
    16201620                'The length of valueref and values are inconsistent.')
    16211621       
     1622        values = [encode(item) for item in values]
    16221623        for i in range(val_ref.size):
    1623             val[i] = values[i]     
     1624            val[i] = values[i]
    16241625       
    16251626        status = FMIL.fmi1_import_set_string(self._fmu, <FMIL.fmi1_value_reference_t*>val_ref.data, val_ref.size, val)
     
    27212722            model.types_platform
    27222723        """
    2723         return FMIL.fmi1_import_get_types_platform(self._fmu)
     2724        types_platform = FMIL.fmi1_import_get_types_platform(self._fmu)
     2725        return decode(types_platform)
    27242726
    27252727    types_platform = property(fget=_get_types_platform)
     
    30833085            model.model_types_platform
    30843086        """
    3085         return FMIL.fmi1_import_get_model_types_platform(self._fmu)
     3087        model_types_platform = FMIL.fmi1_import_get_model_types_platform(self._fmu)
     3088        return decode(model_types_platform)
    30863089
    30873090    model_types_platform = property(fget=_get_model_types_platform)
     
    30893092    def reset(self):
    30903093        """
    3091         This metod resets the FMU by first calling fmiTerminate and
     3094        This method resets the FMU by first calling fmiTerminate and
    30923095        fmiFreeModelInstance and then reloads the DLL and finally
    30933096        re-instantiates using fmiInstantiateModel.
     
    41694172            raise FMUException(
    41704173                'The length of valueref and values are inconsistent.')
    4171        
     4174
     4175        values = [encode(item) for item in values]
    41724176        for i in range(val_ref.size):
    4173             val[i] = values[i]     
     4177            val[i] = values[i]
    41744178       
    41754179        status = FMIL.fmi2_import_set_string(self._fmu, <FMIL.fmi2_value_reference_t*>val_ref.data, val_ref.size, val)
     
    41954199            self.set_integer([ref], [value])
    41964200        elif type == FMIL.fmi2_base_type_enum:
    4197             if isinstance(value, str):
     4201            if isinstance(value, str) or isinstance(value, bytes):
    41984202                enum_type = self.get_variable_declared_type(variable_name)
    4199                 enum_values = {v[0]: k for k, v in enum_type.items.items()}
     4203                enum_values = {encode(v[0]): k for k, v in enum_type.items.items()}
    42004204                try:
    4201                     self.set_integer([ref], [enum_values[value]])
     4205                    self.set_integer([ref], [enum_values[encode(value)]])
    42024206                except KeyError:
    4203                     raise FMUException("The value '%s' is not in the list of allowed enumeration items for variable '%s'. Allowed values: %s'"%(value, variable_name, ", ".join(enum_values.keys())))
     4207                    str_keys = [decode(k) for k in enum_values.keys()]
     4208                    msg = "The value '{}' is not in the list of allowed enumeration items for variable '{}'. Allowed values: {}'.".format(decode(value), decode(variable_name), ", ".join(str_keys))
     4209                    raise FMUException(msg)
    42044210            else:
    42054211                self.set_integer([ref], [value])
     
    80448050            FMIL.fmi_import_rmdir(&callbacks,fmu_temp_dir)
    80458051            _handle_load_fmu_exception(fmu, log_data)
    8046             raise FMUException('FMU is a ' + FMIL.fmi1_fmu_kind_to_string(fmu_1_kind) + ' and not a ' + kind.upper())
     8052            raise FMUException("FMU is a {} and not a {}".format(FMIL.fmi1_fmu_kind_to_string(fmu_1_kind), kind.upper()))
    80478053
    80488054    elif version == FMIL.fmi_version_2_0_enu:
     
    80968102            FMIL.fmi_import_rmdir(&callbacks, fmu_temp_dir)
    80978103            _handle_load_fmu_exception(fmu, log_data)
    8098             raise FMUException('FMU is a ' + FMIL.fmi2_fmu_kind_to_string(fmu_2_kind) + ' and not a ' + kind.upper())
     8104            raise FMUException("FMU is a {} and not a {}".format(decode(FMIL.fmi2_fmu_kind_to_string(fmu_2_kind)),  decode(kind.upper())))
    80998105
    81008106    else:
  • PyFMI/branches/PyFMI-2.5.x/src/pyfmi/fmi_util.pyx

    r13362 r14011  
    3838cpdef decode(x):
    3939    if python3_flag:
    40         return x.decode()
     40        if isinstance(x, bytes):
     41            return x.decode()
     42        else:
     43            return x
    4144    else:
    4245        return x
  • PyFMI/branches/PyFMI-2.5.x/src/pyfmi/simulation/assimulo_interface.py

    r13690 r14011  
    996996            names = ""
    997997            for i in range(self._f_nbr):
    998                 names += self._model.get_states_list().keys()[i] + ", "
     998                names += list(self._model.get_states_list().keys())[i] + ", "
    999999           
    10001000            f.write("Solver: %s \n"%solver.__class__.__name__)
Note: See TracChangeset for help on using the changeset viewer.