Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use skip_function method in Test_junkie

Best Python code snippet using test_junkie

code_object.py

Source:code_object.py

1# -*- coding: utf-8 -*-2###############################################################################3# This file is part of metalibm (https://github.com/kalray/metalibm)4###############################################################################5# MIT License6#7# Copyright (c) 2018 Kalray8#9# Permission is hereby granted, free of charge, to any person obtaining a copy10# of this software and associated documentation files (the "Software"), to deal11# in the Software without restriction, including without limitation the rights12# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell13# copies of the Software, and to permit persons to whom the Software is14# furnished to do so, subject to the following conditions:15#16# The above copyright notice and this permission notice shall be included in all17# copies or substantial portions of the Software.18#19# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR20# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,21# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE22# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER23# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,24# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE25# SOFTWARE.26###############################################################################27# created:          Dec 24th, 201328# last-modified:    Mar  7th, 201829#30# author(s): Nicolas Brunie (nicolas.brunie@kalray.eu)31###############################################################################32import re33import subprocess34import sys35import pdb36import sollya37from ..core.ml_operations import Variable38from ..core.ml_hdl_operations import Signal39from .code_constant import (40    C_Code, Gappa_Code, LLVM_IR_Code41)42from ..core.ml_formats import ML_GlobalRoundMode, ML_Fixed_Format, ML_FP_Format, FunctionFormat43from .code_configuration import CodeConfiguration44class DataLayout(object):45    def __init__(self):46        pass47from collections import OrderedDict48class SymbolTable(object):49    def __init__(self, uniquifier=""):50        # using an ordered ditcionnary to ensure processing order51        # during code generation52        self.table = OrderedDict()53        self.reverse_map = {}54        self.prefix_index = {}55        self.uniquifier = uniquifier56    def is_free_name(self, name):57        return not name in self.table58    def uniquify(self, name):59        return self.uniquifier + name60    def is_empty(self):61        return len(self.table) == 062    def get_free_name(self, var_type, prefix = "sttmp", update_index = True):63        _prefix = self.uniquify(prefix)64        if self.is_free_name(_prefix):65            self.prefix_index[_prefix] = 066            return _prefix67        else:68            new_index = 069            if _prefix in self.prefix_index:70                new_index = self.prefix_index[_prefix] + 171            while not self.is_free_name("%s%d" % (_prefix, new_index)):72                new_index += 173            if update_index:74              self.prefix_index[_prefix] = new_index75            return "%s%d" % (_prefix, new_index)76    def get_values(self):77        return self.table.values()78    def has_definition(self, symbol_object):79        if symbol_object in self.reverse_map:80          return self.reverse_map[symbol_object]81        else:82          return None83        #for key in self.table:84        #    if symbol_object is self.table[key]: return key85        #return None86    def declare_symbol(self, name, symbol_object):87        self.table[name] = symbol_object88        self.reverse_map[symbol_object] = name89    def generate_declaration(self, code_generator):90        code_object = ""91        for symbol in self.table:92            symbol_object = self.table[symbol]93            code_object += code_generator.generate_declaration(symbol, symbol_object)94        return code_object95    def generate_initialization(self, code_generator):96        """ generate symbol initialization, only necessary97            if symbols require a specific initialization procedure98            after declaration (e.g. mpfr_t variable) """99        code_object = ""100        for symbol in self.table:101            symbol_object = self.table[symbol]102            code_object += code_generator.generate_initialization(symbol, symbol_object)103        return code_object104class MultiSymbolTable(object):105    """ symbol table object """106    class ConstantSymbol: pass107    class FunctionSymbol: pass108    class ComponentSymbol: pass109    class EntitySymbol: pass110    class VariableSymbol: pass111    class SignalSymbol:  pass112    class ProtectedSymbol: pass113    class TableSymbol: pass114    class LabelSymbol: pass115    def get_shared_table(self, symbol_tag, shared_tables):116        if symbol_tag in shared_tables: return shared_tables[symbol_tag]117        else: return SymbolTable(uniquifier = self.uniquifier)118    def __init__(self, shared_tables = None, parent_tables = None, uniquifier = ""):119        """ symbol table initialization120            shared_tables is a map of pre-defined tables shared with other parent block121            (and not created within this block)122            parent_tables is a list of pre-existing tables, which are used when123            checking whether a name is free or not124        """125        self.uniquifier = uniquifier126        self.default_exclusion_list = [MultiSymbolTable.ProtectedSymbol]127        shared_tables = shared_tables if shared_tables else {}128        parent_tables = parent_tables if parent_tables else []129        self.constant_table = self.get_shared_table(MultiSymbolTable.ConstantSymbol, shared_tables)130        self.function_table = self.get_shared_table(MultiSymbolTable.FunctionSymbol, shared_tables)131        self.variable_table = self.get_shared_table(MultiSymbolTable.VariableSymbol, shared_tables)132        self.signal_table   = self.get_shared_table(MultiSymbolTable.SignalSymbol, shared_tables)133        self.protected_table = self.get_shared_table(MultiSymbolTable.ProtectedSymbol, shared_tables)134        self.table_table = self.get_shared_table(MultiSymbolTable.TableSymbol, shared_tables)135        self.component_table = self.get_shared_table(MultiSymbolTable.ComponentSymbol, shared_tables)136        self.entity_table    = self.get_shared_table(MultiSymbolTable.EntitySymbol, shared_tables)137        self.label_table = self.get_shared_table(MultiSymbolTable.LabelSymbol, shared_tables)138        self.parent_tables = parent_tables139        # initializing through a list of paire (key, value) to ensure140        # known ordering141        self.table_list = OrderedDict([142            (MultiSymbolTable.ConstantSymbol, self.constant_table),143            (MultiSymbolTable.FunctionSymbol, self.function_table),144            (MultiSymbolTable.VariableSymbol, self.variable_table),145            (MultiSymbolTable.SignalSymbol,   self.signal_table),146            (MultiSymbolTable.ProtectedSymbol, self.protected_table),147            (MultiSymbolTable.TableSymbol, self.table_table),148            (MultiSymbolTable.ComponentSymbol, self.component_table),149            (MultiSymbolTable.EntitySymbol, self.entity_table),150            (MultiSymbolTable.LabelSymbol, self.label_table),151        ])152        self.prefix_index = {}153    def is_empty(self):154      for table_tag in self.table_list:155        if not self.table_list[table_tag].is_empty(): return False156      return True157    def table_has_definition(self, table_object):158        """ search for a previous definition of ML_Table <table_object>159            returns the table index if found, else None """160        table_key = self.table_table.has_definition(table_object)161        if table_key != None:162            return table_key163        for table in self.parent_tables:164            table_name = table.table_has_definition(table_object)165            if table_name != None: return table_name166        return None167    def get_table(self, symbol):168        return self.table_list[symbol]169    def get_parent_tables(self):170        return self.parent_tables171    def get_extended_dependency_table(self):172        return self.parent_tables + [self]173    def is_free_name(self, name):174        for table_tag in self.table_list:175            if not self.table_list[table_tag].is_free_name(name): return False176        for table in self.parent_tables:177            if not table.is_free_name(name): return False178        return True179    def get_free_name(self, var_type, prefix = "mstmp"):180        if self.is_free_name(prefix):181            self.prefix_index[prefix] = 0182            return prefix183        else:184            new_index = 0185            if prefix in self.prefix_index:186                new_index = self.prefix_index[prefix] + 1187            while not self.is_free_name("%s%d" % (prefix, new_index)):188                new_index += 1189            self.prefix_index[prefix] = new_index190            return "%s%d" % (prefix, new_index)191    ## return a free name for a constant192    def get_free_cst_name(self, var_type, prefix = "cst"):193        cst_free_name = self.constant_table.get_free_name(var_type, prefix, update_index = True)194        while not self.is_free_name(cst_free_name):195          cst_free_name = self.constant_table.get_free_name(var_type, prefix, update_index = True)196        return cst_free_name197    def declare_symbol_name(self, symbol_name, symbol_object, symbol_type):198        """ Generic function to declare a symbol of a specified type """199        self.table_list[symbol_type].declare_symbol(symbol_name, symbol_object)200    def declare_function_name(self, function_name, function_object):201        self.function_table.declare_symbol(function_name, function_object)202    def declare_component_name(self, component_name, component_object):203        self.component_table.declare_symbol(component_name, component_object)204        self.entity_table.declare_symbol(component_name, component_object)205    def get_entity_list(self):206        """ return a list of components registered in this table """207        return self.entity_table.get_values()208    def declare_protected_symbol(self, name, node):209        self.protected_table.declare_symbol(name, node)210    def declare_var_name(self, var_name, var_object):211        self.variable_table.declare_symbol(var_name, var_object)212    def declare_signal_name(self, signal_name, signal_object):213        self.signal_table.declare_symbol(signal_name, signal_object)214    def has_signal_definition(self, signal_object):215        return self.signal_table.has_definition(signal_object)216    def declare_cst_name(self, cst_name, cst_object):217        self.constant_table.declare_symbol(cst_name, cst_object)218    def declare_table_name(self, table_name, table_object):219        self.table_table.declare_symbol(table_name, table_object)220    def generate_declarations(self, code_generator, exclusion_list = []):221        code_object = ""222        for table_tag in self.table_list:223            if table_tag in exclusion_list + self.default_exclusion_list:224                continue225            code_object += self.table_list[table_tag].generate_declaration(code_generator)226        return code_object227    def generate_initializations(self, code_generator, init_required_list = []):228        code_object = ""229        for table_tag in init_required_list:230            code_object += self.table_list[table_tag].generate_initialization(code_generator)231        return code_object232def get_git_tag():233    """ extract git commit tag """234    git_tag = subprocess.call("git log -n 1")235    return git_tag236class CodeObject(CodeConfiguration):237    level_header = "{\n"238    level_footer = "}"239    # Prefix added to every free variable name240    GENERAL_PREFIX = ""241    def __init__(self, language, shared_tables = None, parent_tables = None, rounding_mode = ML_GlobalRoundMode, uniquifier = "", main_code_level = None, var_ctor = None):242        """ code object initialization """243        self.expanded_code = ""244        self.uniquifier = uniquifier245        self.tablevel = 0246        self.header_list = []247        self.library_list = []248        self.symbol_table = MultiSymbolTable(shared_tables if shared_tables else {}, parent_tables = (parent_tables if parent_tables else []), uniquifier = self.uniquifier)249        self.language = language250        self.header_comment = []251        self.default_var_ctor = var_ctor252    def add_header_comment(self, comment):253        self.header_comment.append(comment)254    def is_empty(self):255        return len(self.header_list) == 0 and len(self.library_list) == 0 and self.symbol_table.is_empty() and len(self.header_comment) == 0 and len(self.expanded_code) == 0256    def get_symbol_table(self):257        return self.symbol_table258    def reindent(self, line):259        """ re indent code line <line> with proper current indentation level """260        # inserting proper indentation level261        codeline = re.sub("\n", lambda _: ("\n" + self.tablevel * CodeObject.tab), line)262        # removing trailing whitespaces263        codeline = re.sub(" +\n", "\n", codeline)264        return codeline265    def append_code(self, code):266        self.expanded_code += code267        return self268    def __lshift__(self, added_code):269        """ implicit code insertion through << operator """270        indented_code = self.reindent(added_code)271        return self.append_code(indented_code)272    def inc_level(self):273        """ increase indentation level """274        self.tablevel += 1275        self.expanded_code += CodeObject.tab276    def dec_level(self):277        """ decrease indentation level """278        self.tablevel -= 1279        # deleting last inserted tab280        if self.expanded_code[-len(CodeObject.tab):] == CodeObject.tab:281            self.expanded_code = self.expanded_code[:-len(CodeObject.tab)]282    def open_level(self, inc=True, header=None):283        """ open nested block """284        header = self.level_header if header is None else header285        self << header # "{\n"286        if inc: self.inc_level()287    def close_level(self, cr="\n", inc=True, footer=None):288        """ close nested block """289        footer = self.level_footer if footer is None else footer290        if inc: self.dec_level()291        self << "%s%s" % (footer, cr)292    def link_level(self, transition = ""):293        """ close nested block """294        self.dec_level()295        self << "} %s {" % transition296        self.inc_level()297    def add_header(self, header_file):298        """ add a new header file """299        if not header_file in self.header_list:300            self.header_list.append(header_file)301    def get_multiline_comment(self, comment_list):302        result = "/**\n"303        for comment in comment_list:304            result += " * " + comment.replace("\n", "\n *") + "\n"305        result += "**/\n"306        return result307    def add_library(self, library_file):308        """ add a new library file """309        if not library_file in self.library_list:310            self.library_list.append(library_file)311    def generate_header_code(self, git_tag = True):312        """ generate code for header file inclusion """313        result = ""314        # generating git comment315        if git_tag:316            git_comment = CodeConfiguration.get_git_comment()317            self.header_comment.insert(0, git_comment)318        # generating header comments319        result += self.get_multiline_comment(self.header_comment)320        for header_file in self.header_list:321            result += """#include <%s>\n""" % (header_file)322        return result323    def get_free_symbol_name(self, symbol_type, symbol_format, prefix="cotmp", declare=True, symbol_ctor=Variable):324        free_symbol_name = self.symbol_table.get_free_name(symbol_format, prefix)325        if declare:326            self.symbol_table.declare_symbol_name(free_symbol_name, symbol_ctor(free_symbol_name), symbol_type=symbol_type)327        return free_symbol_name328    def get_free_var_name(self, var_type, prefix = "cotmp", declare = True, var_ctor = Variable):329        assert not var_type is None330        free_var_name = self.symbol_table.get_free_name(var_type, self.GENERAL_PREFIX + prefix)331        # declare free var if required332        if declare:333            self.symbol_table.declare_var_name(free_var_name, var_ctor(free_var_name, precision = var_type))334        return free_var_name335    def declare_var_name(self, var_name, var_object):336        self.symbol_table.declare_var_name(var_name, var_object)337        return var_name338    def declare_protected_symbol(self, name, node):339        self.symbol_table.declare_protected_symbol(name, node)340        return node341    def get_free_name(self, var_type, prefix = "cotmp"):342        assert not var_type is None343        return self.symbol_table.get_free_name(var_type, prefix)344    def table_has_definition(self, table_object):345        return self.symbol_table.table_has_definition(table_object)346    ## Declare a new constant object whose name is build347    #  from @p prefix348    #  @param cst_objet Constant constant object to be declared349    #  @para, prefix str constant name prefix350    def declare_cst(self, cst_object, prefix = "cst"):351        """ declare a new constant object and return the registered name """352        free_var_name = self.symbol_table.get_free_cst_name(cst_object.get_precision(), prefix)353        self.symbol_table.declare_cst_name(free_var_name, cst_object)354        return free_var_name355    def declare_table(self, table_object, prefix):356        table_name = self.table_has_definition(table_object)357        if table_name != None:358            return table_name359        else:360            free_var_name = self.symbol_table.get_free_name(table_object.get_storage_precision(), prefix)361            self.symbol_table.declare_table_name(free_var_name, table_object)362            return free_var_name363    def declare_function(self, function_name, function_object):364        self.symbol_table.declare_function_name(function_name, function_object)365        return function_name366    def declare_component(self, component_name, component_object):367        self.symbol_table.declare_component_name(component_name, component_object)368        return component_name369    def get(self, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):370        """ generate unrolled code content """371        result = ""372        if headers:373            result += self.generate_header_code()374            result += "\n\n"375        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []376        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []377        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []378        result += self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)379        result += self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])380        result += "\n" if result != "" else ""381        result += self.expanded_code382        return result383    def push_into_parent_code(self, parent_code, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):384        if headers:385            parent_code << self.generate_header_code()386            parent_code << "\n\n"387        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []388        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []389        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []390        parent_code << self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)391        parent_code << self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])392        parent_code << "\n"393        parent_code << self.expanded_code394    def add_comment(self, comment):395        """ add a full line comment """396        self << ("/* %s */\n" % comment)397    def add_multiline_comment(self, comment):398        self.add_comment(comment)399class Gappa_Unknown(object):400    def __str__(self):401        return "?"402class GappaCodeObject(CodeObject):403    def __init__(self):404        CodeObject.__init__(self, Gappa_Code)405        self.hint_table = []406        self.hypothesis_table = []407        self.goal_table = []408    def add_hint(self, hypoth_code, goal_code, annotation_code, isApprox = False):409        self.hint_table.append((hypoth_code, goal_code, annotation_code, isApprox))410    def add_hypothesis(self, hypoth_code, hypoth_value):411        self.hypothesis_table.append((hypoth_code, hypoth_value))412    def add_goal(self, goal_code, goal_value = Gappa_Unknown):413        self.goal_table.append((goal_code, goal_value))414    def gen_hint(self):415        result = "#hints\n"416        for hypoth_code, goal_code, annotation_code, isApprox in self.hint_table:417            annotation_code = "{%s}" % annotation_code.get() if annotation_code is not None else ""418            symbol = "~" if isApprox else "->"419            result += "%s %s %s %s;\n\n" % (hypoth_code.get(), symbol, goal_code.get(), annotation_code)420        return result421    def gen_complete_goal(self):422        result = "# goalee\n"423        hypothesis = []424        for hc, hv in self.hypothesis_table:425          hypothesis.append("%s in %s" % (hc.get(), self.get_value_str(hv)))426          if isinstance(hc.precision, ML_Fixed_Format):427            hypothesis.append("@FIX(%s,%s)" % (hc.get(), str(- hc.precision.get_frac_size())))428          if isinstance(hc.precision, ML_FP_Format):429            hypothesis.append("@FLT(%s,%s)" % (hc.get(), str(hc.precision.get_field_size()+1)))430        goal = ["%s in %s" % (hc.get(), self.get_value_str(hv)) for hc, hv in self.goal_table]431        result += "{ %s -> %s }\n\n" % (" /\ ".join(hypothesis), " /\ ".join(goal))432        return result433    def get_value_str(self, value):434        if value is Gappa_Unknown:435            return "?"436        elif isinstance(value, sollya.SollyaObject) and value.is_range():437            return "[%s, %s]" % (sollya.inf(value), sollya.sup(value))438        else:439            return str(value)440    def get(self, code_generator, static_cst = False, static_table = False, headers = False, skip_function = True):441        result = ""442        # symbol exclusion list443        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []444        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []445        declaration_exclusion_list += [MultiSymbolTable.VariableSymbol]446        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []447        # declaration generation448        result += self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)449        result += self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])450        result += "\n" if result != "" else ""451        result += self.expanded_code452        result += "\n\n"453        result += self.gen_complete_goal()454        result += self.gen_hint()455        return result456    def push_into_parent_code(self, parent_code, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):457        # symbol exclusion list458        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []459        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []460        declaration_exclusion_list += [MultiSymbolTable.VariableSymbol]461        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []462        # declaration generation463        parent_code << self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)464        parent_code << self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])465        parent_code << "\n"466        parent_code << self.expanded_code467        parent_code << "\n\n"468        parent_code << self.gen_complete_goal()469        parent_code << self.gen_hint()470class LLVMCodeObject(CodeObject):471    GENERAL_PREFIX = "%"472    def __init__(self, language, shared_tables=None, parent_tables=None,473                 rounding_mode=ML_GlobalRoundMode, uniquifier="",474                 main_code_level=None, var_ctor=None):475        CodeObject.__init__(476            self, LLVM_IR_Code, shared_tables, parent_tables, rounding_mode,477            uniquifier, main_code_level, var_ctor478        )479    def get_multiline_comment(self, comment_list):480        result = ""481        for comment in comment_list:482            result += "; " + comment.replace("\n", "\n;") + "\n"483        return result484    def get(self, code_generator, static_cst=False, static_table=False, headers=False, skip_function = True):485        result = ""486        if headers:487            result += self.generate_header_code()488            result += "\n\n"489        # symbol exclusion list490        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []491        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []492        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []493        # always exclude the following from llvm-ir code generation494        declaration_exclusion_list += [495            MultiSymbolTable.VariableSymbol,496            MultiSymbolTable.LabelSymbol497        ]498        # declaration generation499        result += self.symbol_table.generate_declarations(code_generator, exclusion_list=declaration_exclusion_list)500        result += self.symbol_table.generate_initializations(501            code_generator,502            init_required_list=[503                MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol504            ]505        )506        result += "\n" if result != "" else ""507        result += self.expanded_code508        result += "\n"509        return result510    def push_into_parent_code(self, parent_code, code_generator, static_cst = False, static_table = False, headers = False, skip_function=True):511        # symbol exclusion list512        declaration_exclusion_list = [MultiSymbolTable.ConstantSymbol] if static_cst else []513        declaration_exclusion_list += [MultiSymbolTable.TableSymbol] if static_table else []514        declaration_exclusion_list += [MultiSymbolTable.VariableSymbol]515        declaration_exclusion_list += [MultiSymbolTable.LabelSymbol]516        declaration_exclusion_list += [MultiSymbolTable.FunctionSymbol] if skip_function else []517        # declaration generation518        parent_code << self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)519        parent_code << self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])520        parent_code << "\n"521        parent_code << self.expanded_code522        parent_code << "\n"523class VHDLCodeObject(CodeConfiguration):524    def __init__(self, language, shared_tables = None, parent_tables = None, rounding_mode = ML_GlobalRoundMode, uniquifier = "", main_code_level = False, var_ctor = None):525        """ code object initialization """526        self.expanded_code = ""527        self.uniquifier = uniquifier528        self.tablevel = 0529        self.header_list = []530        self.library_list = []531        self.symbol_table = MultiSymbolTable(shared_tables if shared_tables else {}, parent_tables = (parent_tables if parent_tables else []), uniquifier = self.uniquifier)532        self.language = language533        self.header_comment = []534        self.shared_symbol_table_f = MultiSymbolTable.SignalSymbol in shared_tables535        self.main_code_level = main_code_level536        self.default_var_ctor = var_ctor537    def add_header_comment(self, comment):538        self.header_comment.append(comment)539    def is_empty(self):540        return len(self.header_list) == 0 and len(self.library_list) == 0 and self.symbol_table.is_empty() and len(self.header_comment) == 0 and len(self.expanded_code) == 0541    def get_symbol_table(self):542        return self.symbol_table543    def __lshift__(self, added_code):544        """ implicit code insertion through << operator """545        self.expanded_code += re.sub("\n", lambda _: ("\n" + self.tablevel * CodeObject.tab), added_code)546    def inc_level(self):547        """ increase indentation level """548        self.tablevel += 1549        self.expanded_code += CodeObject.tab550    def dec_level(self):551        """ decrease indentation level """552        self.tablevel -= 1553        # deleting last inserted tab554        if self.expanded_code[-len(CodeObject.tab):] == CodeObject.tab:555            self.expanded_code = self.expanded_code[:-len(CodeObject.tab)]556    def open_level(self, inc = True, header=None):557        """ open nested block """558        if inc: self.inc_level()559    def close_level(self, cr = "\n", inc = True, footer=None):560        """ close nested block """561        if inc: self.dec_level()562    def link_level(self, transition = ""):563        """ close nested block """564        raise NotImplementedError565    def add_header(self, header_file):566        """ add a new header file """567        if not header_file in self.header_list:568            self.header_list.append(header_file)569    def add_library(self, library_file):570        """ add a new library file """571        if not library_file in self.library_list:572            self.library_list.append(library_file)573    def generate_header_code(self, git_tag = True):574        """ generate code for header file inclusion """575        result = ""576        # generating git comment577        if git_tag:578            git_comment = CodeConfiguration.get_git_comment()579            self.header_comment.insert(0, git_comment)580        # generating header comments581        result += "--\n"582        for comment in self.header_comment:583            result += "-- " + comment.replace("\n", "\n--") + "\n"584        # TODO/FIXME: erase trailing white spaces properly585        result.replace("--\n", "--\n")586        result += "--\n"587        for library_file in self.library_list:588            result += "library {lib};\n".format(lib = library_file)589        for header_file in self.header_list:590            result += """use %s;\n""" % (header_file)591        return result592    def get_free_var_name(self, var_type, prefix = "tmps", declare = True, var_ctor = None):593        assert not var_type is None594        var_ctor = var_ctor or self.default_var_ctor or Signal595        free_var_name = self.symbol_table.get_free_name(var_type, prefix)596        # declare free var if required597        if declare:598            if var_ctor is Variable:599                self.symbol_table.declare_var_name(free_var_name, var_ctor(free_var_name, precision = var_type))600            elif var_ctor is Signal:601                self.symbol_table.declare_signal_name(free_var_name, var_ctor(free_var_name, precision = var_type))602            else:603                Log.report(Log.Error, "unsupported var constructor in get_free_var_name")604        return free_var_name605    def get_free_signal_name(self, signal_type, prefix = "stmp", declare = True):606        assert not signal_type is None607        free_signal_name = self.symbol_table.get_free_name(signal_type, prefix)608        # declare free var if required609        if declare:610            self.symbol_table.declare_signal_name(free_signal_name, Signal(free_signal_name, precision = signal_type))611        return free_signal_name612    def declare_var_name(self, var_name, var_object):613        self.symbol_table.declare_var_name(var_name, var_object)614        return var_name615    def declare_protected_symbol(self, name, node):616        self.symbol_table.declare_protected_symbol(name, node)617        return node618    def declare_signal(self, signal_object, signal_type, prefix = "stmp"):619        signal_key = self.symbol_table.has_signal_definition(signal_object)620        if not signal_key is None:621          return signal_key622        else:623          free_signal_name = self.symbol_table.get_free_name(signal_type, prefix)624          self.symbol_table.declare_signal_name(free_signal_name, signal_object)625        return free_signal_name626    def get_free_name(self, var_type, prefix = "svtmp"):627        return self.symbol_table.get_free_name(var_type, prefix)628    def table_has_definition(self, table_object):629        return self.symbol_table.table_has_definition(table_object)630    ## Declare a new constant object whose name is build631    #  from @p prefix632    #  @param cst_objet Constant constant object to be declared633    #  @para, prefix str constant name prefix634    def declare_cst(self, cst_object, prefix = "cst"):635        """ declare a new constant object and return the registered name """636        free_var_name = self.symbol_table.get_free_cst_name(cst_object.get_precision(), prefix)637        self.symbol_table.declare_cst_name(free_var_name, cst_object)638        return free_var_name639    def declare_table(self, table_object, prefix):640        table_name = self.table_has_definition(table_object)641        if table_name != None:642            return table_name643        else:644            free_var_name = self.symbol_table.get_free_name(table_object.get_storage_precision(), prefix)645            self.symbol_table.declare_table_name(free_var_name, table_object)646            return free_var_name647    def declare_function(self, function_name, function_object):648        self.symbol_table.declare_function_name(function_name, function_object)649        return function_name650    def declare_component(self, component_name, component_object):651        self.symbol_table.declare_component_name(component_name, component_object)652        return component_name653    def get_entity_list(self):654        """ Return the list of component instanciated in this code object """655        return self.symbol_table.get_entity_list()656    def get(self, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):657        """ generate unrolled code content """658        result = ""659        if headers:660            result += self.generate_header_code()661            result += "\n\n"662        # Entities are always excluded from generation663        # They will be processed in a separate manner (see ML_EntityBasis)664        declaration_exclusion_list = [MultiSymbolTable.EntitySymbol]665        if static_cst:666            declaration_exclusion_list.append(MultiSymbolTable.ConstantSymbol)667        if static_table:668            declaration_exclusion_list.append(MultiSymbolTable.TableSymbol)669        if skip_function:670            declaration_exclusion_list.append(MultiSymbolTable.FunctionSymbol)671        if self.shared_symbol_table_f:672            declaration_exclusion_list.append(MultiSymbolTable.SignalSymbol)673        result += self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)674        result += self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])675        result += "begin\n" if not self.main_code_level else ""676        result += "\n" if result != "" else ""677        result += self.expanded_code678        return result679    def push_into_parent_code(self, parent_code, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):680        """ generate unrolled code content """681        if headers:682            parent_code << self.generate_header_code()683            parent_code << "\n\n"684        declaration_exclusion_list = [MultiSymbolTable.EntitySymbol]685        if static_cst:686            declaration_exclusion_list.append(MultiSymbolTable.ConstantSymbol)687        if static_table:688            declaration_exclusion_list.append(MultiSymbolTable.TableSymbol)689        if skip_function:690            declaration_exclusion_list.append(MultiSymbolTable.FunctionSymbol)691        if self.shared_symbol_table_f:692            declaration_exclusion_list.append(MultiSymbolTable.SignalSymbol)693        parent_code << self.symbol_table.generate_declarations(code_generator, exclusion_list = declaration_exclusion_list)694        parent_code << self.symbol_table.generate_initializations(code_generator, init_required_list = [MultiSymbolTable.ConstantSymbol, MultiSymbolTable.VariableSymbol])695        parent_code.dec_level()696        parent_code << "\n"697        parent_code << ("begin\n" if not self.main_code_level else "")698        parent_code.inc_level()699        parent_code << self.expanded_code700    def add_comment(self, comment):701        """ add a full line comment """702        self << ("-- %s\n" % comment)703    def add_multiline_comment(self, comment):704        for line in comment.split("\n"):705            if line != "": self.add_comment(line) 706## Nested code object707#  language is derived from code_generator's language708class NestedCode(object):709    """ object to support multiple levels of nested code with local and710        global variable management """711    ##712    #  @param uniquifier <str> unifiquation prefix for name generation713    def __init__(self, code_generator,714            static_cst=False,715            static_table=True,716            uniquifier="",717            code_ctor=CodeObject,718            main_code_level=None,719            shared_symbol_list=None,720            static_var=False):721        self.language = code_generator.language722        self.code_generator = code_generator723        # name uniquifier724        self.uniquifier = uniquifier725        # constructor function for code levels726        self.code_ctor = code_ctor727        # top-level global tables728        self.global_tables = {}729        # defaulting list of shared symbol table to build730        # if none is defined731        self.global_symbol_list = [732            MultiSymbolTable.ConstantSymbol,733            MultiSymbolTable.TableSymbol,734            MultiSymbolTable.FunctionSymbol,735            MultiSymbolTable.EntitySymbol,736            MultiSymbolTable.ProtectedSymbol,737        ] if shared_symbol_list is None else shared_symbol_list738        for symbol in self.global_symbol_list:739            self.global_tables[symbol] = SymbolTable(uniquifier=uniquifier)740        shared_tables = self.global_tables741        self.main_code = self.code_ctor(self.language, shared_tables, uniquifier=self.uniquifier, main_code_level=True)742        self.code_list = [self.main_code]743    @property744    def default_var_ctor(self):745        return self.code_list[0].default_var_ctor746    def add_header_comment(self, comment):747        self.main_code.add_header_comment(comment)748    def add_header(self, header_file):749        self.main_code.add_header(header_file)750    def add_library(self, library_file):751        self.main_code.add_library(library_file)752    def add_local_header(self, header_file):753        self.code_list[0].add_header(header_file)754    def append_code(self, code):755        self.code_list[0].append_code(code)756        return self757    def __lshift__(self, added_code):758        self.code_list[0] << added_code759        return self760    def add_comment(self, comment):761        self.code_list[0].add_comment(comment)762    def add_multiline_comment(self, comment):763        self.code_list[0].add_multiline_comment(comment)764    def open_level(self, extra_shared_tables=None, inc=True, var_ctor=None, header=None):765        """ Open a new level of code """766        self.code_list[0].open_level(inc=inc, header=header)767        parent_tables = self.code_list[0].get_symbol_table().get_extended_dependency_table()768        shared_tables = {}769        # preparing sub-global shared tables770        for global_symbol in self.global_tables:771            shared_tables[global_symbol] = self.global_tables[global_symbol]772        if extra_shared_tables:773          for table_key in extra_shared_tables:774            shared_tables[table_key] = self.code_list[0].get_symbol_table().get_table(table_key)775        # building a new code object for the sub-level776        sublevel_code = self.code_ctor(777            self.language, shared_tables,778            parent_tables=parent_tables, var_ctor=var_ctor)779        self.code_list.insert(0, sublevel_code)780    @property781    def static_cst(self):782        return MultiSymbolTable.ConstantSymbol in self.global_tables783    @property784    def static_table(self):785        return MultiSymbolTable.TableSymbol in self.global_tables786    def close_level(self, cr = "\n", inc = True, footer=None):787        level_code = self.code_list.pop(0)788        level_code.push_into_parent_code(self, self.code_generator, static_cst = self.static_cst, static_table = self.static_table, skip_function = True)789        self.code_list[0].close_level(cr=cr, inc=inc, footer=footer)790    def inc_level(self):791        """ increase indentation level """792        self.code_list[0].inc_level()793    def dec_level(self):794        """ decrease indentation level """795        self.code_list[0].dec_level()796    # @param function_object possible dummy FunctionObject associated with new function_name797    def declare_free_function_name(self, prefix = "foo", function_object = None):798        function_name = self.code_list[0].get_free_name(FunctionFormat(), prefix = prefix)799        self.code_list[0].declare_function(function_name, function_object)800        return function_name801    def get_free_symbol_name(self, symbol_type, symbol_format, symbol_ctor, prefix="tmp", declare=True):802        return self.code_list[0].get_free_symbol_name(symbol_type, symbol_format, prefix, declare, symbol_ctor=symbol_ctor)803    def get_free_var_name(self, var_type, prefix = "tmpv", declare = True, var_ctor = None):804        # trying not to override code_list[0] default var_ctor805        if var_ctor is None:806          return self.code_list[0].get_free_var_name(var_type, prefix, declare)807        else:808          return self.code_list[0].get_free_var_name(var_type, prefix, declare, var_ctor)809    def get_free_name(self, var_type, prefix="tmps"):810        return self.code_list[0].get_free_name(var_type, prefix)811    def get_free_signal_name(self, signal_type, prefix = "stmp", declare = True):812        return self.code_list[0].get_free_signal_name(signal_type, prefix, declare)813    def declare_signal(self, signal_object, signal_type, prefix = "stmp"):814        return self.code_list[0].declare_signal(signal_object, signal_type, prefix)815    def declare_var_name(self, var_name, var_object):816        return self.code_list[0].declare_var_name(var_name, var_object)817    def declare_protected_symbol(self, name, node):818        return self.code_list[0].declare_protected_symbol(name, node)819    def declare_cst(self, cst_object, prefix = "cst"):820        return self.code_list[0].declare_cst(cst_object, prefix)821    def declare_table(self, table_object, prefix = "table"):822        return self.code_list[0].declare_table(table_object, prefix)823    def declare_function(self, function_name, function_object):824        return self.code_list[0].declare_function(function_name, function_object)825    def declare_component(self, component_name, component_object):826        component_name = self.code_list[0].declare_component(component_name, component_object)827        return component_name828    def get_entity_list(self):829        """ Return the component list """830        return self.code_list[0].get_entity_list()831    def get(self, code_generator, static_cst = False, static_table = False, headers = True, skip_function = False):832        return self.code_list[0].get(code_generator, static_cst = static_cst, static_table = static_table, headers = headers, skip_function = skip_function)833    def push_into_parent_code(self, parent_code, code_generator, static_cst = False, static_table = False, headers = False, skip_function = False):...

mailboximap.py

Source:mailboximap.py

...153                    data = self.M.fetch(num, '(BODY[HEADER])')[1]154                    emailBody = data[0][1]155                    mail = email.message_from_bytes(156                        emailBody, _class=EmailMessage)157                    if skip_function(mail):158                        continue159                if body:160                    data = self.M.fetch(num, '(RFC822)')[1]161                    emailBody = data[0][1]162                    mail = email.message_from_bytes(163                        emailBody, _class=EmailMessage)164                elif skip_function is None:165                    data = self.M.fetch(num, '(BODY[HEADER])')[1]166                    emailBody = data[0][1]167                    mail = email.message_from_bytes(168                        emailBody, _class=EmailMessage)169                yield mail170            self.M.close()171    def enumerate_search_person(self, person, folder, skip_function=None,...

model_selection.py

Source:model_selection.py

1###############################################################################2#                                                                             #3# Copyright (C) 2003-2013 Edward d'Auvergne                                   #4#                                                                             #5# This file is part of the program relax (http://www.nmr-relax.com).          #6#                                                                             #7# This program is free software: you can redistribute it and/or modify        #8# it under the terms of the GNU General Public License as published by        #9# the Free Software Foundation, either version 3 of the License, or           #10# (at your option) any later version.                                         #11#                                                                             #12# This program is distributed in the hope that it will be useful,             #13# but WITHOUT ANY WARRANTY; without even the implied warranty of              #14# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #15# GNU General Public License for more details.                                #16#                                                                             #17# You should have received a copy of the GNU General Public License           #18# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #19#                                                                             #20###############################################################################21# Module docstring.22"""Module for selecting the best model."""23# Python module imports.24import sys25# relax module imports.26from lib.errors import RelaxError, RelaxPipeError27from lib.io import write_data28from lib.model_selection import aic, aicc, bic29import pipe_control.pipes30from pipe_control.pipes import get_type, has_pipe, pipe_names, switch31from specific_analyses.setup import get_specific_fn32def select(method=None, modsel_pipe=None, bundle=None, pipes=None):33    """Model selection function.34    @keyword method:        The model selection method.  This can currently be one of:35                                - 'AIC', Akaike's Information Criteria.36                                - 'AICc', Small sample size corrected AIC.37                                - 'BIC', Bayesian or Schwarz Information Criteria.38                                - 'CV', Single-item-out cross-validation.39                            None of the other model selection techniques are currently supported.40    @type method:           str41    @keyword modsel_pipe:   The name of the new data pipe to be created by copying of the selected data pipe.42    @type modsel_pipe:      str43    @keyword bundle:        The optional data pipe bundle to associate the newly created pipe with.44    @type bundle:           str or None45    @keyword pipes:         A list of the data pipes to use in the model selection.46    @type pipes:            list of str47    """48    # Test if the pipe already exists.49    if has_pipe(modsel_pipe):50        raise RelaxPipeError(modsel_pipe)51    # Use all pipes.52    if pipes == None:53        # Get all data pipe names from the relax data store.54        pipes = pipe_names()55    # Select the model selection technique.56    if method == 'AIC':57        print("AIC model selection.")58        formula = aic59    elif method == 'AICc':60        print("AICc model selection.")61        formula = aicc62    elif method == 'BIC':63        print("BIC model selection.")64        formula = bic65    elif method == 'CV':66        print("CV model selection.")67        raise RelaxError("The model selection technique " + repr(method) + " is not currently supported.")68    else:69        raise RelaxError("The model selection technique " + repr(method) + " is not currently supported.")70    # No pipes.71    if len(pipes) == 0:72        raise RelaxError("No data pipes are available for use in model selection.")73    # Initialise.74    function_type = {}75    model_loop = {}76    model_type = {}77    duplicate_data = {}78    model_statistics = {}79    skip_function = {}80    modsel_pipe_exists = False81    # Cross validation setup.82    if isinstance(pipes[0], list):83        # No pipes.84        if len(pipes[0]) == 0:85            raise RelaxError("No pipes are available for use in model selection in the array " + repr(pipes[0]) + ".")86        # Loop over the data pipes.87        for i in range(len(pipes)):88            for j in range(len(pipes[i])):89                # Specific functions.90                model_loop[pipes[i][j]] = get_specific_fn('model_loop', get_type(pipes[i][j]))91                model_type[pipes[i][j]] = get_specific_fn('model_type', get_type(pipes[i][j]))92                duplicate_data[pipes[i][j]] = get_specific_fn('duplicate_data', get_type(pipes[i][j]))93                model_statistics[pipes[i][j]] = get_specific_fn('model_stats', get_type(pipes[i][j]))94                skip_function[pipes[i][j]] = get_specific_fn('skip_function', get_type(pipes[i][j]))95        # The model loop should be the same for all data pipes!96        for i in range(len(pipes)):97            for j in range(len(pipes[i])):98                if model_loop[pipes[0][j]] != model_loop[pipes[i][j]]:99                    raise RelaxError("The models for each data pipes should be the same.")100        model_loop = model_loop[pipes[0][0]]101        # The model description.102        model_desc = get_specific_fn('model_desc', get_type(pipes[0]))103        # Global vs. local models.104        global_flag = False105        for i in range(len(pipes)):106            for j in range(len(pipes[i])):107                if model_type[pipes[i][j]]() == 'global':108                    global_flag = True109    # All other model selection setup.110    else:111        # Loop over the data pipes.112        for i in range(len(pipes)):113            # Specific functions.114            model_loop[pipes[i]] = get_specific_fn('model_loop', get_type(pipes[i]))115            model_type[pipes[i]] = get_specific_fn('model_type', get_type(pipes[i]))116            duplicate_data[pipes[i]] = get_specific_fn('duplicate_data', get_type(pipes[i]))117            model_statistics[pipes[i]] = get_specific_fn('model_stats', get_type(pipes[i]))118            skip_function[pipes[i]] = get_specific_fn('skip_function', get_type(pipes[i]))119        model_loop = model_loop[pipes[0]]120        # The model description.121        model_desc = get_specific_fn('model_desc', get_type(pipes[0]))122        # Global vs. local models.123        global_flag = False124        for j in range(len(pipes)):125            if model_type[pipes[j]]() == 'global':126                global_flag = True127    # Loop over the base models.128    for model_info in model_loop():129        # Print out.130        print("\n")131        desc = model_desc(model_info)132        if desc:133            print(desc)134        # Initial model.135        best_model = None136        best_crit = 1e300137        data = []138        # Loop over the pipes.139        for j in range(len(pipes)):140            # Single-item-out cross validation.141            if method == 'CV':142                # Sum of chi-squared values.143                sum_crit = 0.0144                # Loop over the validation samples and sum the chi-squared values.145                for k in range(len(pipes[j])):146                    # Alias the data pipe name.147                    pipe = pipes[j][k]148                    # Switch to this pipe.149                    switch(pipe)150                    # Skip function.151                    if skip_function[pipe](model_info):152                        continue153                    # Get the model statistics.154                    k, n, chi2 = model_statistics[pipe](model_info)155                    # Missing data sets.156                    if k == None or n == None or chi2 == None:157                        continue158                    # Chi2 sum.159                    sum_crit = sum_crit + chi2160                # Cross-validation criterion (average chi-squared value).161                crit = sum_crit / float(len(pipes[j]))162            # Other model selection methods.163            else:164                # Reassign the pipe.165                pipe = pipes[j]166                # Switch to this pipe.167                switch(pipe)168                # Skip function.169                if skip_function[pipe](model_info):170                    continue171                # Get the model statistics.172                k, n, chi2 = model_statistics[pipe](model_info, global_stats=global_flag)173                # Missing data sets.174                if k == None or n == None or chi2 == None:175                    continue176                # Calculate the criterion value.177                crit = formula(chi2, float(k), float(n))178                # Store the values for a later printout.179                data.append([pipe, repr(k), repr(n), "%.5f" % chi2, "%.5f" % crit])180            # Select model.181            if crit < best_crit:182                best_model = pipe183                best_crit = crit184        # Write out the table.185        write_data(out=sys.stdout, headings=["Data pipe", "Num_params_(k)", "Num_data_sets_(n)", "Chi2", "Criterion"], data=data)186        # Duplicate the data from the 'best_model' to the model selection data pipe.187        if best_model != None:188            # Print out of selected model.189            print("The model from the data pipe " + repr(best_model) + " has been selected.")190            # Switch to the selected data pipe.191            switch(best_model)192            # Duplicate.193            duplicate_data[best_model](best_model, modsel_pipe, model_info, global_stats=global_flag, verbose=False)194            # Model selection pipe now exists.195            modsel_pipe_exists = True196        # No model selected.197        else:198            # Print out of selected model.199            print("No model has been selected.")200    # Switch to the model selection pipe.201    if modsel_pipe_exists:202        switch(modsel_pipe)203    # Bundle the data pipe.204    if bundle:...

utils.py

Source:utils.py

...42        throw_away_prob = data_cuts['throw_away_prob']43        throw_away = np.random.choice([False, True], p=[1 - throw_away_prob, throw_away_prob])44        if throw_away: continue_bool = True45    if data_cuts['custom_skip_function'] is not None:46        continue_bool = use_custom_skip_function(data_cuts['custom_skip_function'], event_track)47    return continue_bool48def use_custom_skip_function(skip_function, event_track):49    """50    User defined, custom skip functions.51    Parameters52    ----------53    skip_function : str54        String that specifies, which custom skip function should be used.55    event_track : ndarray(ndim=1)56        Structured numpy array containing the McTracks info of this event.57    Returns58    -------59    continue_bool : bool60        Bool which specifies, if this event should be skipped or not.61    """62    if skip_function == 'ts_e_flat':...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.