def create_exists_clone(string): """Create a clone of the table statement which has the exists check """ parser = get_definition_start() + restOfLine.setResultsName('definition') result = to_dict(parser.parseString(string)) template = 'CREATE {temp} TABLE IF NOT EXISTS {table_name} {definition}' return template.format(temp='TEMP' if result['temporary'] else '', table_name=result['full_name'], definition=result['definition'])
def add_sections_info(self, sections_info_dump): first_line = sections_info_dump.readline() archive_path = (Literal('In archive').suppress() + White().suppress() + # trim the colon and line ending characters from archive_path restOfLine.setResultsName('archive_path').setParseAction(lambda s, loc, toks: s.rstrip(':\n\r '))) parser = archive_path results = None try: results = parser.parseString(first_line, parseAll=True) except ParseException as p: raise ParseException('Parsing sections info for library ' + sections_info_dump.name + ' failed. ' + p.msg) archive = os.path.basename(results.archive_path) self.sections[archive] = SectionsInfo.__info(sections_info_dump.name, sections_info_dump.read())
def add_sections_info(self, sections_info_file): first_line = sections_info_file.readline() archive_path = ( Literal("In archive").suppress() + White().suppress() + # trim the colon and line ending characters from archive_path restOfLine.setResultsName("archive_path").setParseAction( lambda s, loc, toks: s.rstrip(":\n\r "))) parser = archive_path results = None try: results = parser.parseString(first_line) except ParseException as p: raise ParseException("File " + sections_info_file.name + " is not a valid sections info file. " + p.message) archive = os.path.basename(results.archive_path) self.sections[archive] = SectionsInfo.__info(sections_info_file.name, sections_info_file.read())
DATA_PATH = 'data' def get_files(dirpath): return os.listdir(dirpath) #PATTERN_F_BORN = re.compile(u'^Родилась\sв\s(?P<year>[0-9]{4,4})\s(г|году)(\.\s|\s|\.|)$') #PATTERN_F_BORN = re.compile(r'^Родилась\s+в\s+(?P<year>[0-9]{4,4}).*$') PATTERN_F_BORN = lineStart + Suppress(u'Родилась') + Suppress(u'в') + Word( nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года' ]).suppress() + lineEnd PATTERN_M_BORN = lineStart + Suppress(u'Родился') + Suppress(u'в') + Word( nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года' ]).suppress() + lineEnd PATTERN_PRIG = lineStart + Suppress(u'Приговор:') + restOfLine.setResultsName( 'prigovor') + lineEnd def parse_all(): for p in range(1, 39, 1): thep = MIRROR_PATH + 'd' + str(p) + '\\' for fname in get_files(thep): frecords = [] resname = 'data/d' + str(p) + '_' + fname.split('.')[0] + '.json' if os.path.exists(resname): continue f = open(os.path.join(thep, fname), 'r') lo = parse(f) objs = lo.xpath("//ul[@class='list-right']/li") for o in objs: record = {} names = o.xpath("p[@class='name']")
def generate_spreadsheet(correction_folder): now = time.strftime("%Y-%m-%d %H_%M_%S", time.localtime()) files = sorted(f for f in os.listdir(correction_folder) if re.match("^question\d{3}\.txt$",f)) rmat = collections.defaultdict(dict) grade =(Literal("question..........:").suppress() + Word(nums+"."+",").setResultsName("Q#") + Literal("points............:").suppress() + Word(nums+"."+",").setResultsName("points") + Literal("name..............:").suppress() + restOfLine.setResultsName("name") + Literal("mec...............:").suppress() + Word(alphanums).setResultsName("mec") + Literal("automatic grade(%):").suppress() + Word(nums+"."+",").setResultsName("autgrade") + Literal("manual grade(%)...:").suppress() + Optional(Word(nums+"."+",")).setResultsName("mangrade")) question_number_list = [] name_list = [] points = [] names=[] for file_ in files: weight=[] print("processing: ", file_) content = open(os.path.join(correction_folder, file_),"r").read() for data, dataStart, dataEnd in grade.scanString(content): name = str(data["name"].strip()) try: mec = int(data["mec"]) except ValueError: mec = str(data["mec"]) if not rmat[mec]: rmat[mec] = [name, mec] names.append((name, mec)) question_number_list.append(data["Q#"]) weight.append(data["points"]) if "mangrade" in data: rmat[mec].append(float( data["mangrade"])) else: rmat[mec].append(float( data["autgrade"])) points.extend(list(set(weight))) doc = newdoc(doctype='ods', filename='grades_bioinformatics_{}.ods'.format(now)) doc.sheets.append(Sheet(name="grades", size=(1, 20))) sheet = doc.sheets['grades'] def write_row(sheet, row): for i,v in enumerate(row): sheet[(sheet.nrows()-1, i)].set_value(v) sheet.append_rows() headers = (['name','mec']+ ["Q{}".format(no) for no in sorted(set(question_number_list))]+ ['grade(0-20)']) write_row(sheet, headers) write_row(sheet, ["",""] + points) from string import ascii_uppercase as letters formula="=20*(" #print(points) for c in range(len(points)): formula += "${letter}$2*{letter}3+".format(letter = letters[c+2]) formula = formula.rstrip("+") formula +=")/{} \n".format(sum([100*int(x) for x in points])) write_row(sheet, ["Max Maximus", 99999] + [100]*len(points) + [formula]+['=IF({}3<9.5,"R","")'.format(letters[c+3])]) for mec in [m for n, m in sorted(names)]: write_row(sheet, rmat[mec]) doc.save() input("press return")
#define USERNAME = "******" #define PASSWORD = "******" a = MAX_LOCS; CORBA::initORB("xyzzy", USERNAME, PASSWORD ); """ ################# print("Example of an extractor") print("----------------------") # simple grammar to match #define's ident = Word(alphas, alphanums + "_") macroDef = Literal("#define") + ident.setResultsName( "name") + "=" + restOfLine.setResultsName("value") for t, s, e in macroDef.scanString(testData): print(t.name, ":", t.value) # or a quick way to make a dictionary of the names and values # (return only key and value tokens, and construct dict from key-value pairs) # - empty ahead of restOfLine advances past leading whitespace, does implicit lstrip during parsing macroDef = Suppress("#define") + ident + Suppress("=") + empty + restOfLine macros = dict(list(macroDef.searchString(testData))) print("macros =", macros) print() ################# print("Examples of a transformer") print("----------------------")
def __init__(self, query): self._methods = { 'and': self.evaluate_and, 'or': self.evaluate_or, 'not': self.evaluate_not, 'parenthesis': self.evaluate_parenthesis, 'quotes': self.evaluate_quotes, 'word': self.evaluate_word, } self.line = '' self.query = query.lower() if query else '' if self.query: # TODO: Cleanup operator_or = Forward() operator_word = Group(Word(alphanums)).setResultsName('word') operator_quotes_content = Forward() operator_quotes_content << ( (operator_word + operator_quotes_content) | operator_word ) operator_quotes = Group( Suppress('"') + operator_quotes_content + Suppress('"') ).setResultsName('quotes') | operator_word operator_parenthesis = Group( (Suppress('(') + operator_or + Suppress(")")) ).setResultsName('parenthesis') | operator_quotes operator_not = Forward() operator_not << (Group( Suppress(Keyword('no', caseless=True)) + operator_not ).setResultsName('not') | operator_parenthesis) operator_and = Forward() operator_and << (Group( operator_not + Suppress(Keyword('and', caseless=True)) + operator_and ).setResultsName('and') | Group( operator_not + OneOrMore(~oneOf('and or') + operator_and) ).setResultsName('and') | operator_not) operator_or << (Group( operator_and + Suppress(Keyword('or', caseless=True)) + operator_or ).setResultsName('or') | operator_and) self._query_parser = operator_or.parseString(self.query)[0] else: self._query_parser = False time_cmpnt = Word(nums).setParseAction(lambda t: t[0].zfill(2)) date = Combine((time_cmpnt + '-' + time_cmpnt + '-' + time_cmpnt) + ' ' + time_cmpnt + ':' + time_cmpnt) word = Word(printables) self._log_parser = ( date.setResultsName('timestamp') + word.setResultsName('log_level') + word.setResultsName('plugin') + ( White(min=16).setParseAction(lambda s, l, t: [t[0].strip()]).setResultsName('task') | (White(min=1).suppress() & word.setResultsName('task')) ) + restOfLine.setResultsName('message') )
'REG_LINK', 'REG_MULTI_SZ', 'REG_RESOURCE_LIST', 'REG_FULL_RESOURCE_DESCRIPTOR', 'REG_RESOURCE_REQUIREMENTS_LIST', 'REG_QWORD']).setResultsName('regType') # Transforms the ~ or = into True or False. equals = oneOf(['~', '=']).setParseAction(lambda orig, match, tokens: tokens[0] == '~') # Example: # Value=Foobar # REG_SZ~Foobaz#2300 valueLine = Group(Literal(u'Value').suppress() + \ equals.setResultsName('nameExpand') + \ Optional(restOfLine.setResultsName('name') + \ regType + equals.setResultsName('dataExpand') + \ restOfLine.setResultsName('data'))) # A key can have many values in a row or none at all. values = ZeroOrMore(valueLine).setResultsName('values') # A full entry looks like this: # isolation_writecopy HKLM\Blah # Value=(... as above ...) entry = isolationMode + White().suppress() + \ restOfLine.setResultsName('path') + values ### Data types generated by ImportRegistry class RegistryDataError(Exception):
class ExplicitStateUpdater(StateUpdateMethod): ''' An object that can be used for defining state updaters via a simple description (see below). Resulting instances can be passed to the ``method`` argument of the `NeuronGroup` constructor. As other state updater functions the `ExplicitStateUpdater` objects are callable, returning abstract code when called with an `Equations` object. A description of an explicit state updater consists of a (multi-line) string, containing assignments to variables and a final "x_new = ...", stating the integration result for a single timestep. The assignments can be used to define an arbitrary number of intermediate results and can refer to ``f(x, t)`` (the function being integrated, as a function of ``x``, the previous value of the state variable and ``t``, the time) and ``dt``, the size of the timestep. For example, to define a Runge-Kutta 4 integrator (already provided as `rk4`), use:: k1 = dt*f(x,t) k2 = dt*f(x+k1/2,t+dt/2) k3 = dt*f(x+k2/2,t+dt/2) k4 = dt*f(x+k3,t+dt) x_new = x+(k1+2*k2+2*k3+k4)/6 Note that for stochastic equations, the function `f` only corresponds to the non-stochastic part of the equation. The additional function `g` corresponds to the stochastic part that has to be multiplied with the stochastic variable xi (a standard normal random variable -- if the algorithm needs a random variable with a different variance/mean you have to multiply/add it accordingly). Equations with more than one stochastic variable do not have to be treated differently, the part referring to ``g`` is repeated for all stochastic variables automatically. Stochastic integrators can also make reference to ``dW`` (a normal distributed random number with variance ``dt``) and ``g(x, t)``, the stochastic part of an equation. A stochastic state updater could therefore use a description like:: x_new = x + dt*f(x,t) + g(x, t) * dW For simplicity, the same syntax is used for state updaters that only support additive noise, even though ``g(x, t)`` does not depend on ``x`` or ``t`` in that case. There a some restrictions on the complexity of the expressions (but most can be worked around by using intermediate results as in the above Runge- Kutta example): Every statement can only contain the functions ``f`` and ``g`` once; The expressions have to be linear in the functions, e.g. you can use ``dt*f(x, t)`` but not ``f(x, t)**2``. Parameters ---------- description : str A state updater description (see above). stochastic : {None, 'additive', 'multiplicative'} What kind of stochastic equations this state updater supports: ``None`` means no support of stochastic equations, ``'additive'`` means only equations with additive noise and ``'multiplicative'`` means supporting arbitrary stochastic equations. Raises ------ ValueError If the parsing of the description failed. Notes ----- Since clocks are updated *after* the state update, the time ``t`` used in the state update step is still at its previous value. Enumerating the states and discrete times, ``x_new = x + dt*f(x, t)`` is therefore understood as :math:`x_{i+1} = x_i + dt f(x_i, t_i)`, yielding the correct forward Euler integration. If the integrator has to refer to the time at the end of the timestep, simply use ``t + dt`` instead of ``t``. See also -------- euler, rk2, rk4, milstein ''' #=========================================================================== # Parsing definitions #=========================================================================== #: Legal names for temporary variables TEMP_VAR = ~Literal('x_new') + Word( string.ascii_letters + '_', string.ascii_letters + string.digits + '_').setResultsName('identifier') #: A single expression EXPRESSION = restOfLine.setResultsName('expression') #: An assignment statement STATEMENT = Group(TEMP_VAR + Suppress('=') + EXPRESSION).setResultsName('statement') #: The last line of a state updater description OUTPUT = Group(Suppress(Literal('x_new')) + Suppress('=') + EXPRESSION).setResultsName('output') #: A complete state updater description DESCRIPTION = ZeroOrMore(STATEMENT) + OUTPUT def __init__(self, description, stochastic=None): self._description = description self.stochastic = stochastic try: parsed = ExplicitStateUpdater.DESCRIPTION.parseString( description, parseAll=True) except ParseException as p_exc: ex = SyntaxError('Parsing failed: ' + str(p_exc.msg)) ex.text = str(p_exc.line) ex.offset = p_exc.column ex.lineno = p_exc.lineno raise ex self.statements = [] self.symbols = SYMBOLS.copy() for element in parsed: expression = str_to_sympy(element.expression) # Replace all symbols used in state updater expressions by unique # names that cannot clash with user-defined variables or functions expression = expression.subs(sympy.Function('f'), self.symbols['__f']) expression = expression.subs(sympy.Function('g'), self.symbols['__g']) symbols = list(expression.atoms(sympy.Symbol)) unique_symbols = [] for symbol in symbols: if symbol.name == 'dt': unique_symbols.append(symbol) else: unique_symbols.append(_symbol('__' + symbol.name)) for symbol, unique_symbol in zip(symbols, unique_symbols): expression = expression.subs(symbol, unique_symbol) self.symbols.update( dict(((symbol.name, symbol) for symbol in unique_symbols))) if element.getName() == 'statement': self.statements.append(('__' + element.identifier, expression)) elif element.getName() == 'output': self.output = expression else: raise AssertionError('Unknown element name: %s' % element.getName()) def can_integrate(self, equations, variables): # Non-stochastic numerical integrators should work for all equations, # except for stochastic equations if equations.is_stochastic and self.stochastic is None: return False elif (equations.stochastic_type == 'multiplicative' and self.stochastic != 'multiplicative'): return False else: return True def __repr__(self): # recreate a description string description = '\n'.join( ['%s = %s' % (var, expr) for var, expr in self.statements]) if len(description): description += '\n' description += 'x_new = ' + str(self.output) r = "{classname}('''{description}''', stochastic={stochastic})" return r.format(classname=self.__class__.__name__, description=description, stochastic=repr(self.stochastic)) def __str__(self): s = '%s\n' % self.__class__.__name__ if len(self.statements) > 0: s += 'Intermediate statements:\n' s += '\n'.join([(var + ' = ' + sympy_to_str(expr)) for var, expr in self.statements]) s += '\n' s += 'Output:\n' s += sympy_to_str(self.output) return s def _latex(self, *args): from sympy import latex, Symbol s = [r'\begin{equation}'] for var, expr in self.statements: expr = expr.subs(Symbol('x'), Symbol('x_t')) s.append(latex(Symbol(var)) + ' = ' + latex(expr) + r'\\') expr = self.output.subs(Symbol('x'), 'x_t') s.append(r'x_{t+1} = ' + latex(expr)) s.append(r'\end{equation}') return '\n'.join(s) def _repr_latex_(self): return self._latex() def _generate_RHS(self, eqs, var, eq_symbols, temp_vars, expr, non_stochastic_expr, stochastic_expr): ''' Helper function used in `__call__`. Generates the right hand side of an abstract code statement by appropriately replacing f, g and t. For example, given a differential equation ``dv/dt = -(v + I) / tau`` (i.e. `var` is ``v` and `expr` is ``(-v + I) / tau``) together with the `rk2` step ``return x + dt*f(x + k/2, t + dt/2)`` (i.e. `non_stochastic_expr` is ``x + dt*f(x + k/2, t + dt/2)`` and `stochastic_expr` is ``None``), produces ``v + dt*(-v - _k_v/2 + I + _k_I/2)/tau``. ''' def replace_func(x, t, expr, temp_vars): ''' Used to replace a single occurance of ``f(x, t)`` or ``g(x, t)``: `expr` is the non-stochastic (in the case of ``f``) or stochastic part (``g``) of the expression defining the right-hand-side of the differential equation describing `var`. It replaces the variable `var` with the value given as `x` and `t` by the value given for `t. Intermediate variables will be replaced with the appropriate replacements as well. For example, in the `rk2` integrator, the second step involves the calculation of ``f(k/2 + x, dt/2 + t)``. If `var` is ``v`` and `expr` is ``-v / tau``, this will result in ``-(_k_v/2 + v)/tau``. Note that this deals with only one state variable `var`, given as an argument to the surrounding `_generate_RHS` function. ''' try: s_expr = str_to_sympy(str(expr)) except SympifyError as ex: raise ValueError('Error parsing the expression "%s": %s' % (expr, str(ex))) for var in eq_symbols: # Generate specific temporary variables for the state variable, # e.g. '_k_v' for the state variable 'v' and the temporary # variable 'k'. temp_var_replacements = dict( ((self.symbols[temp_var], _symbol(temp_var + '_' + var)) for temp_var in temp_vars)) # In the expression given as 'x', replace 'x' by the variable # 'var' and all the temporary variables by their # variable-specific counterparts. x_replacement = x.subs(self.symbols['__x'], eq_symbols[var]) x_replacement = x_replacement.subs(temp_var_replacements) # Replace the variable `var` in the expression by the new `x` # expression s_expr = s_expr.subs(eq_symbols[var], x_replacement) # Directly substitute the 't' expression for the symbol t, there # are no temporary variables to consider here. s_expr = s_expr.subs(self.symbols['__t'], t) return s_expr # Note: in the following we are silently ignoring the case that a # state updater does not care about either the non-stochastic or the # stochastic part of an equation. We do trust state updaters to # correctly specify their own abilities (i.e. they do not claim to # support stochastic equations but actually just ignore the stochastic # part). We can't really check the issue here, as we are only dealing # with one line of the state updater description. It is perfectly valid # to write the euler update as: # non_stochastic = dt * f(x, t) # stochastic = dt**.5 * g(x, t) * xi # return x + non_stochastic + stochastic # # In the above case, we'll deal with lines which do not define either # the stochastic or the non-stochastic part. non_stochastic, stochastic = expr.split_stochastic() # We do have a non-stochastic part in our equation and in the state # updater description if not (non_stochastic is None or non_stochastic_expr is None): # Replace the f(x, t) part replace_f = lambda x, t: replace_func(x, t, non_stochastic, temp_vars) non_stochastic_result = non_stochastic_expr.replace( self.symbols['__f'], replace_f) # Replace x by the respective variable non_stochastic_result = non_stochastic_result.subs( self.symbols['__x'], eq_symbols[var]) # Replace intermediate variables temp_var_replacements = dict( (self.symbols[temp_var], _symbol(temp_var + '_' + var)) for temp_var in temp_vars) non_stochastic_result = non_stochastic_result.subs( temp_var_replacements) else: non_stochastic_result = None # We do have a stochastic part in our equation and in the state updater # description if not (stochastic is None or stochastic_expr is None): stochastic_results = [] # We potentially have more than one stochastic variable for xi in stochastic: # Replace the g(x, t)*xi part replace_g = lambda x, t: replace_func(x, t, stochastic[xi], temp_vars) stochastic_result = stochastic_expr.replace( self.symbols['__g'], replace_g) # Replace x and xi by the respective variables stochastic_result = stochastic_result.subs( self.symbols['__x'], eq_symbols[var]) stochastic_result = stochastic_result.subs( self.symbols['__dW'], xi) # Replace intermediate variables temp_var_replacements = dict( (self.symbols[temp_var], _symbol(temp_var + '_' + var)) for temp_var in temp_vars) stochastic_result = stochastic_result.subs( temp_var_replacements) stochastic_results.append(stochastic_result) else: stochastic_results = [] RHS = [] # All the parts (one non-stochastic and potentially more than one # stochastic part) are combined with addition if non_stochastic_result is not None: RHS.append(sympy_to_str(non_stochastic_result)) for stochastic_result in stochastic_results: RHS.append(sympy_to_str(stochastic_result)) RHS = ' + '.join(RHS) return RHS def __call__(self, eqs, variables=None): ''' Apply a state updater description to model equations. Parameters ---------- eqs : `Equations` The equations describing the model variables: dict-like, optional The `Variable` objects for the model. Ignored by the explicit state updater. Examples -------- >>> from brian2 import * >>> eqs = Equations('dv/dt = -v / tau : volt') >>> print(euler(eqs)) _v = -dt*v/tau + v v = _v >>> print(rk4(eqs)) __k_1_v = -dt*v/tau __k_2_v = -dt*(0.5*__k_1_v + v)/tau __k_3_v = -dt*(0.5*__k_2_v + v)/tau __k_4_v = -dt*(__k_3_v + v)/tau _v = 0.166666666666667*__k_1_v + 0.333333333333333*__k_2_v + 0.333333333333333*__k_3_v + 0.166666666666667*__k_4_v + v v = _v ''' # The final list of statements statements = [] # The variables for the intermediate results in the state updater # description, e.g. the variable k in rk2 intermediate_vars = [var for var, expr in self.statements] # A dictionary mapping all the variables in the equations to their # sympy representations eq_variables = dict(((var, _symbol(var)) for var in eqs.eq_names)) # Generate the random numbers for the stochastic variables stochastic_variables = eqs.stochastic_variables for stochastic_variable in stochastic_variables: statements.append(stochastic_variable + ' = ' + 'dt**.5 * randn()') # Process the intermediate statements in the stateupdater description for intermediate_var, intermediate_expr in self.statements: # Split the expression into a non-stochastic and a stochastic part non_stochastic_expr, stochastic_expr = split_expression( intermediate_expr) # Execute the statement by appropriately replacing the functions f # and g and the variable x for every equation in the model. # We use the model equations where the subexpressions have # already been substituted into the model equations. for var, expr in eqs.substituted_expressions: RHS = self._generate_RHS(eqs, var, eq_variables, intermediate_vars, expr, non_stochastic_expr, stochastic_expr) statements.append(intermediate_var + '_' + var + ' = ' + RHS) # Process the "return" line of the stateupdater description non_stochastic_expr, stochastic_expr = split_expression(self.output) # Assign a value to all the model variables described by differential # equations for var, expr in eqs.substituted_expressions: RHS = self._generate_RHS(eqs, var, eq_variables, intermediate_vars, expr, non_stochastic_expr, stochastic_expr) statements.append('_' + var + ' = ' + RHS) # Assign everything to the final variables for var, expr in eqs.substituted_expressions: statements.append(var + ' = ' + '_' + var) return '\n'.join(statements)
# 'Admin' commands for point modifications. point_commands = ['addpoints', 'subpoints', 'setpoints'] # 'Admin' commands for channel metadata modifications. admin_commands = { 'setgame': api.set_game, 'settitle': api.set_title, } # Parser to grab command keywords from chat messages. username = Word(alphanums + '_').setResultsName('username') irc_garb = Word(alphanums + '_!@.') + 'PRIVMSG' + '#hwangbroxd' cmd = ':!' + Word(alphas).setResultsName('cmd') new_cmd = Optional(Combine('!' + Word(alphanums).setResultsName('new_cmd'))) msg = restOfLine.setResultsName('msg') parser = ':' + username + irc_garb + cmd + new_cmd + msg chat_parser = ':' + username + irc_garb + ':' + msg class Message: """Represents a chat message. Has methods to parse internally for different types of commands and to assign variables accordingly. """ def __init__(self, text): self.username = self.message = self.command = self.metacommand = self.command_body = self.points_user = '' self.is_command = False self.is_admin = False
def __init__(self): filename = os.path.join(paths.lib_dir(), 'bauble.glade') self.widgets = utils.load_widgets(filename) self.window = self.widgets.main_window self.window.hide() # restore the window size geometry = prefs[self.window_geometry_pref] if geometry is not None: self.window.set_default_size(*geometry) self.window.connect('delete-event', self.on_delete_event) self.window.connect("destroy", self.on_quit) self.window.set_title(self.title) try: pixbuf = gtk.gdk.pixbuf_new_from_file(bauble.default_icon) self.window.set_icon(pixbuf) except Exception: logger.warning( _('Could not load icon from %s') % bauble.default_icon) logger.warning(traceback.format_exc()) menubar = self.create_main_menu() self.widgets.menu_box.pack_start(menubar) combo = self.widgets.main_comboentry model = gtk.ListStore(str) combo.set_model(model) self.populate_main_entry() main_entry = combo.child main_entry.connect('activate', self.on_main_entry_activate) accel_group = gtk.AccelGroup() main_entry.add_accelerator("grab-focus", accel_group, ord('L'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.window.add_accel_group(accel_group) go_button = self.widgets.go_button go_button.connect('clicked', self.on_go_button_clicked) query_button = self.widgets.query_button query_button.connect('clicked', self.on_query_button_clicked) self.set_default_view() # add a progressbar to the status bar # Warning: this relies on gtk.Statusbar internals and could break in # future versions of gtk statusbar = self.widgets.statusbar statusbar.set_spacing(10) statusbar.set_has_resize_grip(True) self._cids = [] def on_statusbar_push(sb, cid, txt): if cid not in self._cids: self._cids.append(cid) statusbar.connect('text-pushed', on_statusbar_push) # remove label from frame frame = statusbar.get_children()[0] #frame.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FF0000')) label = frame.get_children()[0] frame.remove(label) # replace label with hbox and put label and progress bar in hbox hbox = gtk.HBox(False, 5) frame.add(hbox) hbox.pack_start(label, True, True, 0) vbox = gtk.VBox(True, 0) hbox.pack_end(vbox, False, True, 15) self.progressbar = gtk.ProgressBar() vbox.pack_start(self.progressbar, False, False, 0) self.progressbar.set_size_request(-1, 10) vbox.show() hbox.show() from pyparsing import StringStart, Word, alphanums, restOfLine, \ StringEnd cmd = StringStart() + ':' + Word(alphanums + '-_').setResultsName('cmd') arg = restOfLine.setResultsName('arg') self.cmd_parser = (cmd + StringEnd()) | (cmd + '=' + arg) | arg combo.grab_focus()
special_chars = ' -''' allchars = alphanums + alphas8bit + extended_chars + special_chars # Prepare months RUS_MONTH_NAMES = [u'января', u'февраля', u'марта', u'апреля', u'мая', u'июня', u'июля', u'августа', u'сентября', u'октября', u'ноября', u'декабря'] RUS_MONTH_MAP = {} i = 0 for k in RUS_MONTH_NAMES: i += 1 RUS_MONTH_MAP[k] = i PAT_YEAR = lineStart + Suppress(u'в') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + lineEnd PAT_RUDATE = lineStart + Word(nums, min=1, max=2).setResultsName('day') + oneOf(RUS_MONTH_NAMES).setResultsName('month_r') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + lineEnd PAT_RUDATE_WHO = lineStart + OneOrMore(Word(allchars)).setResultsName('who') + Word(nums, min=1, max=2).setResultsName('day') + oneOf(RUS_MONTH_NAMES).setResultsName('month_r') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + lineEnd PAT_OBV = lineStart + Suppress(u', обв.:') + restOfLine.setResultsName('restof') + lineEnd PAT_OBV_YEAR = lineStart + Suppress(u'в') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + Suppress(u', обв.:') + restOfLine.setResultsName('restof') + lineEnd PAT_OBV_RUDATE = lineStart + Word(nums, min=1, max=2).setResultsName('day') + oneOf(RUS_MONTH_NAMES).setResultsName('month_r') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + Suppress(u', обв.:') + restOfLine.setResultsName('restof') + lineEnd PAT_OBV_WHO = lineStart + OneOrMore(Word(allchars)).setResultsName('who') + Word(nums, min=1, max=2).setResultsName('day') + oneOf(RUS_MONTH_NAMES).setResultsName('month_r') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + Suppress(u', обв.:') + restOfLine.setResultsName('restof') + lineEnd PAT_BORN_P = lineStart + Suppress(u'в') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + Suppress(u',') + restOfLine.setResultsName('restof') + lineEnd #PATTERN_F_BORN = re.compile(u'^Родилась\sв\s(?P<year>[0-9]{4,4})\s(г|году)(\.\s|\s|\.|)$') #PATTERN_F_BORN = re.compile(r'^Родилась\s+в\s+(?P<year>[0-9]{4,4}).*$') #PATTERN_F_BORN = lineStart + Suppress(u'Родилась') + Suppress(u'в') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + lineEnd #PATTERN_M_BORN = lineStart + Suppress(u'Родился') + Suppress(u'в') + Word(nums, exact=4).setResultsName('year') + oneOf([u'г.', u'года']).suppress() + lineEnd PATTERN_PRIG = lineStart + Suppress(u'Приговор:') + restOfLine.setResultsName('restof') + lineEnd PATTERN_FBORN = lineStart + Suppress(u'Родилась') + restOfLine.setResultsName('restof') + lineEnd PATTERN_MBORN = lineStart + Suppress(u'Родился') + restOfLine.setResultsName('restof') + lineEnd
'REG_NONE', 'REG_SZ', 'REG_EXPAND_SZ', 'REG_BINARY', 'REG_DWORD', 'REG_DWORD_BIG_ENDIAN', 'REG_LINK', 'REG_MULTI_SZ', 'REG_RESOURCE_LIST', 'REG_FULL_RESOURCE_DESCRIPTOR', 'REG_RESOURCE_REQUIREMENTS_LIST', 'REG_QWORD' ]).setResultsName('regType') # Transforms the ~ or = into True or False. equals = oneOf(['~', '=' ]).setParseAction(lambda orig, match, tokens: tokens[0] == '~') # Example: # Value=Foobar # REG_SZ~Foobaz#2300 valueLine = Group(Literal(u'Value').suppress() + \ equals.setResultsName('nameExpand') + \ Optional(restOfLine.setResultsName('name') + \ regType + equals.setResultsName('dataExpand') + \ restOfLine.setResultsName('data'))) # A key can have many values in a row or none at all. values = ZeroOrMore(valueLine).setResultsName('values') # A full entry looks like this: # isolation_writecopy HKLM\Blah # Value=(... as above ...) entry = isolationMode + White().suppress() + \ restOfLine.setResultsName('path') + values ### Data types generated by ImportRegistry
from sympy import Symbol, Function from pyparsing import (Literal, Group, Word, ZeroOrMore, Suppress, restOfLine, ParseException) from brian2.utils.parsing import parse_to_sympy __all__ = ['euler', 'rk2', 'rk4', 'ExplicitStateUpdater'] #=============================================================================== # Parsing definitions #=============================================================================== TEMP_VAR = Word(string.ascii_letters + '_', string.ascii_letters + string.digits + '_').setResultsName('identifier') EXPRESSION = restOfLine.setResultsName('expression') STATEMENT = Group(TEMP_VAR + Suppress('=') + EXPRESSION).setResultsName('statement') OUTPUT = Group(Suppress(Literal('return ')) + EXPRESSION).setResultsName('output') DESCRIPTION = ZeroOrMore(STATEMENT) + OUTPUT #=============================================================================== # Class for simple definition of explicit state updaters #=============================================================================== # reserved standard symbols SYMBOLS = {'x' : Symbol('x'), 't' : Symbol('t'), 'dt': Symbol('dt'),
#define MAX_LOCS=100 #define USERNAME = "******" #define PASSWORD = "******" a = MAX_LOCS; CORBA::initORB("xyzzy", USERNAME, PASSWORD ); """ ################# print("Example of an extractor") print("----------------------") # simple grammar to match #define's ident = Word(alphas, alphanums+"_") macroDef = Literal("#define") + ident.setResultsName("name") + "=" + restOfLine.setResultsName("value") for t,s,e in macroDef.scanString( testData ): print(t.name,":", t.value) # or a quick way to make a dictionary of the names and values # (return only key and value tokens, and construct dict from key-value pairs) # - empty ahead of restOfLine advances past leading whitespace, does implicit lstrip during parsing macroDef = Suppress("#define") + ident + Suppress("=") + empty + restOfLine macros = dict(list(macroDef.searchString(testData))) print("macros =", macros) print() ################# print("Examples of a transformer") print("----------------------")
class ExplicitStateUpdater(StateUpdateMethod): """ An object that can be used for defining state updaters via a simple description (see below). Resulting instances can be passed to the ``method`` argument of the `NeuronGroup` constructor. As other state updater functions the `ExplicitStateUpdater` objects are callable, returning abstract code when called with an `Equations` object. A description of an explicit state updater consists of a (multi-line) string, containing assignments to variables and a final "x_new = ...", stating the integration result for a single timestep. The assignments can be used to define an arbitrary number of intermediate results and can refer to ``f(x, t)`` (the function being integrated, as a function of ``x``, the previous value of the state variable and ``t``, the time) and ``dt``, the size of the timestep. For example, to define a Runge-Kutta 4 integrator (already provided as `rk4`), use:: k1 = dt*f(x,t) k2 = dt*f(x+k1/2,t+dt/2) k3 = dt*f(x+k2/2,t+dt/2) k4 = dt*f(x+k3,t+dt) x_new = x+(k1+2*k2+2*k3+k4)/6 Note that for stochastic equations, the function `f` only corresponds to the non-stochastic part of the equation. The additional function `g` corresponds to the stochastic part that has to be multiplied with the stochastic variable xi (a standard normal random variable -- if the algorithm needs a random variable with a different variance/mean you have to multiply/add it accordingly). Equations with more than one stochastic variable do not have to be treated differently, the part referring to ``g`` is repeated for all stochastic variables automatically. Stochastic integrators can also make reference to ``dW`` (a normal distributed random number with variance ``dt``) and ``g(x, t)``, the stochastic part of an equation. A stochastic state updater could therefore use a description like:: x_new = x + dt*f(x,t) + g(x, t) * dW For simplicity, the same syntax is used for state updaters that only support additive noise, even though ``g(x, t)`` does not depend on ``x`` or ``t`` in that case. There a some restrictions on the complexity of the expressions (but most can be worked around by using intermediate results as in the above Runge- Kutta example): Every statement can only contain the functions ``f`` and ``g`` once; The expressions have to be linear in the functions, e.g. you can use ``dt*f(x, t)`` but not ``f(x, t)**2``. Parameters ---------- description : str A state updater description (see above). stochastic : {None, 'additive', 'multiplicative'} What kind of stochastic equations this state updater supports: ``None`` means no support of stochastic equations, ``'additive'`` means only equations with additive noise and ``'multiplicative'`` means supporting arbitrary stochastic equations. Raises ------ ValueError If the parsing of the description failed. Notes ----- Since clocks are updated *after* the state update, the time ``t`` used in the state update step is still at its previous value. Enumerating the states and discrete times, ``x_new = x + dt*f(x, t)`` is therefore understood as :math:`x_{i+1} = x_i + dt f(x_i, t_i)`, yielding the correct forward Euler integration. If the integrator has to refer to the time at the end of the timestep, simply use ``t + dt`` instead of ``t``. See also -------- euler, rk2, rk4, milstein """ #=========================================================================== # Parsing definitions #=========================================================================== #: Legal names for temporary variables TEMP_VAR = ~Literal('x_new') + Word(f"{string.ascii_letters}_", f"{string.ascii_letters + string.digits}_").setResultsName('identifier') #: A single expression EXPRESSION = restOfLine.setResultsName('expression') #: An assignment statement STATEMENT = Group(TEMP_VAR + Suppress('=') + EXPRESSION).setResultsName('statement') #: The last line of a state updater description OUTPUT = Group(Suppress(Literal('x_new')) + Suppress('=') + EXPRESSION).setResultsName('output') #: A complete state updater description DESCRIPTION = ZeroOrMore(STATEMENT) + OUTPUT def __init__(self, description, stochastic=None, custom_check=None): self._description = description self.stochastic = stochastic self.custom_check = custom_check try: parsed = ExplicitStateUpdater.DESCRIPTION.parseString(description, parseAll=True) except ParseException as p_exc: ex = SyntaxError(f"Parsing failed: {str(p_exc.msg)}") ex.text = str(p_exc.line) ex.offset = p_exc.column ex.lineno = p_exc.lineno raise ex self.statements = [] self.symbols = SYMBOLS.copy() for element in parsed: expression = str_to_sympy(element.expression) # Replace all symbols used in state updater expressions by unique # names that cannot clash with user-defined variables or functions expression = expression.subs(sympy.Function('f'), self.symbols['__f']) expression = expression.subs(sympy.Function('g'), self.symbols['__g']) symbols = list(expression.atoms(sympy.Symbol)) unique_symbols = [] for symbol in symbols: if symbol.name == 'dt': unique_symbols.append(symbol) else: unique_symbols.append(_symbol(f"__{symbol.name}")) for symbol, unique_symbol in zip(symbols, unique_symbols): expression = expression.subs(symbol, unique_symbol) self.symbols.update(dict(((symbol.name, symbol) for symbol in unique_symbols))) if element.getName() == 'statement': self.statements.append((f"__{element.identifier}", expression)) elif element.getName() == 'output': self.output = expression else: raise AssertionError(f'Unknown element name: {element.getName()}') def __repr__(self): # recreate a description string description = '\n'.join([f'{var} = {expr}' for var, expr in self.statements]) if len(description): description += '\n' description += f"x_new = {str(self.output)}" classname = self.__class__.__name__ return f"{classname}('''{description}''', stochastic={self.stochastic!r})" def __str__(self): s = f'{self.__class__.__name__}\n' if len(self.statements) > 0: s += 'Intermediate statements:\n' s += '\n'.join([f"{var} = {sympy_to_str(expr)}" for var, expr in self.statements]) s += '\n' s += 'Output:\n' s += sympy_to_str(self.output) return s def _latex(self, *args): from sympy import latex, Symbol s = [r'\begin{equation}'] for var, expr in self.statements: expr = expr.subs(Symbol('x'), Symbol('x_t')) s.append(f"{latex(Symbol(var))} = {latex(expr)}\\\\") expr = self.output.subs(Symbol('x'), 'x_t') s.append(f"x_{{t+1}} = {latex(expr)}") s.append(r'\end{equation}') return '\n'.join(s) def _repr_latex_(self): return self._latex() def replace_func(self, x, t, expr, temp_vars, eq_symbols, stochastic_variable=None): """ Used to replace a single occurance of ``f(x, t)`` or ``g(x, t)``: `expr` is the non-stochastic (in the case of ``f``) or stochastic part (``g``) of the expression defining the right-hand-side of the differential equation describing `var`. It replaces the variable `var` with the value given as `x` and `t` by the value given for `t`. Intermediate variables will be replaced with the appropriate replacements as well. For example, in the `rk2` integrator, the second step involves the calculation of ``f(k/2 + x, dt/2 + t)``. If `var` is ``v`` and `expr` is ``-v / tau``, this will result in ``-(_k_v/2 + v)/tau``. Note that this deals with only one state variable `var`, given as an argument to the surrounding `_generate_RHS` function. """ try: s_expr = str_to_sympy(str(expr)) except SympifyError as ex: raise ValueError(f'Error parsing the expression "{expr}": {str(ex)}') for var in eq_symbols: # Generate specific temporary variables for the state variable, # e.g. '_k_v' for the state variable 'v' and the temporary # variable 'k'. if stochastic_variable is None: temp_var_replacements = dict(((self.symbols[temp_var], _symbol(f"{temp_var}_{var}")) for temp_var in temp_vars)) else: temp_var_replacements = dict(((self.symbols[temp_var], _symbol(f"{temp_var}_{var}_{stochastic_variable}")) for temp_var in temp_vars)) # In the expression given as 'x', replace 'x' by the variable # 'var' and all the temporary variables by their # variable-specific counterparts. x_replacement = x.subs(self.symbols['__x'], eq_symbols[var]) x_replacement = x_replacement.subs(temp_var_replacements) # Replace the variable `var` in the expression by the new `x` # expression s_expr = s_expr.subs(eq_symbols[var], x_replacement) # If the expression given for t in the state updater description # is not just "t" (or rather "__t"), then replace t in the # equations by it, and replace "__t" by "t" afterwards. if t != self.symbols['__t']: s_expr = s_expr.subs(SYMBOLS['t'], t) s_expr = s_expr.replace(self.symbols['__t'], SYMBOLS['t']) return s_expr def _non_stochastic_part(self, eq_symbols, non_stochastic, non_stochastic_expr, stochastic_variable, temp_vars, var): non_stochastic_results = [] if stochastic_variable is None or len(stochastic_variable) == 0: # Replace the f(x, t) part replace_f = lambda x, t: self.replace_func(x, t, non_stochastic, temp_vars, eq_symbols) non_stochastic_result = non_stochastic_expr.replace( self.symbols['__f'], replace_f) # Replace x by the respective variable non_stochastic_result = non_stochastic_result.subs( self.symbols['__x'], eq_symbols[var]) # Replace intermediate variables temp_var_replacements = dict((self.symbols[temp_var], _symbol(f"{temp_var}_{var}")) for temp_var in temp_vars) non_stochastic_result = non_stochastic_result.subs( temp_var_replacements) non_stochastic_results.append(non_stochastic_result) elif isinstance(stochastic_variable, str): # Replace the f(x, t) part replace_f = lambda x, t: self.replace_func(x, t, non_stochastic, temp_vars, eq_symbols, stochastic_variable) non_stochastic_result = non_stochastic_expr.replace( self.symbols['__f'], replace_f) # Replace x by the respective variable non_stochastic_result = non_stochastic_result.subs( self.symbols['__x'], eq_symbols[var]) # Replace intermediate variables temp_var_replacements = dict((self.symbols[temp_var], _symbol( f"{temp_var}_{var}_{stochastic_variable}")) for temp_var in temp_vars) non_stochastic_result = non_stochastic_result.subs( temp_var_replacements) non_stochastic_results.append(non_stochastic_result) else: # Replace the f(x, t) part replace_f = lambda x, t: self.replace_func(x, t, non_stochastic, temp_vars, eq_symbols) non_stochastic_result = non_stochastic_expr.replace( self.symbols['__f'], replace_f) # Replace x by the respective variable non_stochastic_result = non_stochastic_result.subs( self.symbols['__x'], eq_symbols[var]) # Replace intermediate variables temp_var_replacements = dict((self.symbols[temp_var], reduce(operator.add, [_symbol( f"{temp_var}_{var}_{xi}") for xi in stochastic_variable])) for temp_var in temp_vars) non_stochastic_result = non_stochastic_result.subs( temp_var_replacements) non_stochastic_results.append(non_stochastic_result) return non_stochastic_results def _stochastic_part(self, eq_symbols, stochastic, stochastic_expr, stochastic_variable, temp_vars, var): stochastic_results = [] if isinstance(stochastic_variable, str): # Replace the g(x, t) part replace_f = lambda x, t: self.replace_func(x, t, stochastic.get(stochastic_variable, 0), temp_vars, eq_symbols, stochastic_variable) stochastic_result = stochastic_expr.replace(self.symbols['__g'], replace_f) # Replace x by the respective variable stochastic_result = stochastic_result.subs(self.symbols['__x'], eq_symbols[var]) # Replace dW by the respective variable stochastic_result = stochastic_result.subs(self.symbols['__dW'], stochastic_variable) # Replace intermediate variables temp_var_replacements = dict((self.symbols[temp_var], _symbol( f"{temp_var}_{var}_{stochastic_variable}")) for temp_var in temp_vars) stochastic_result = stochastic_result.subs(temp_var_replacements) stochastic_results.append(stochastic_result) else: for xi in stochastic_variable: # Replace the g(x, t) part replace_f = lambda x, t: self.replace_func(x, t, stochastic.get(xi, 0), temp_vars, eq_symbols, xi) stochastic_result = stochastic_expr.replace(self.symbols['__g'], replace_f) # Replace x by the respective variable stochastic_result = stochastic_result.subs(self.symbols['__x'], eq_symbols[var]) # Replace dW by the respective variable stochastic_result = stochastic_result.subs(self.symbols['__dW'], xi) # Replace intermediate variables temp_var_replacements = dict((self.symbols[temp_var], _symbol(f"{temp_var}_{var}_{xi}")) for temp_var in temp_vars) stochastic_result = stochastic_result.subs( temp_var_replacements) stochastic_results.append(stochastic_result) return stochastic_results def _generate_RHS(self, eqs, var, eq_symbols, temp_vars, expr, non_stochastic_expr, stochastic_expr, stochastic_variable=()): """ Helper function used in `__call__`. Generates the right hand side of an abstract code statement by appropriately replacing f, g and t. For example, given a differential equation ``dv/dt = -(v + I) / tau`` (i.e. `var` is ``v` and `expr` is ``(-v + I) / tau``) together with the `rk2` step ``return x + dt*f(x + k/2, t + dt/2)`` (i.e. `non_stochastic_expr` is ``x + dt*f(x + k/2, t + dt/2)`` and `stochastic_expr` is ``None``), produces ``v + dt*(-v - _k_v/2 + I + _k_I/2)/tau``. """ # Note: in the following we are silently ignoring the case that a # state updater does not care about either the non-stochastic or the # stochastic part of an equation. We do trust state updaters to # correctly specify their own abilities (i.e. they do not claim to # support stochastic equations but actually just ignore the stochastic # part). We can't really check the issue here, as we are only dealing # with one line of the state updater description. It is perfectly valid # to write the euler update as: # non_stochastic = dt * f(x, t) # stochastic = dt**.5 * g(x, t) * xi # return x + non_stochastic + stochastic # # In the above case, we'll deal with lines which do not define either # the stochastic or the non-stochastic part. non_stochastic, stochastic = expr.split_stochastic() if non_stochastic_expr is not None: # We do have a non-stochastic part in the state updater description non_stochastic_results = self._non_stochastic_part(eq_symbols, non_stochastic, non_stochastic_expr, stochastic_variable, temp_vars, var) else: non_stochastic_results = [] if not (stochastic is None or stochastic_expr is None): # We do have a stochastic part in the state # updater description stochastic_results = self._stochastic_part(eq_symbols, stochastic, stochastic_expr, stochastic_variable, temp_vars, var) else: stochastic_results = [] RHS = sympy.Number(0) # All the parts (one non-stochastic and potentially more than one # stochastic part) are combined with addition for non_stochastic_result in non_stochastic_results: RHS += non_stochastic_result for stochastic_result in stochastic_results: RHS += stochastic_result return sympy_to_str(RHS) def __call__(self, eqs, variables=None, method_options=None): """ Apply a state updater description to model equations. Parameters ---------- eqs : `Equations` The equations describing the model variables: dict-like, optional The `Variable` objects for the model. Ignored by the explicit state updater. method_options : dict, optional Additional options to the state updater (not used at the moment for the explicit state updaters). Examples -------- >>> from brian2 import * >>> eqs = Equations('dv/dt = -v / tau : volt') >>> print(euler(eqs)) _v = -dt*v/tau + v v = _v >>> print(rk4(eqs)) __k_1_v = -dt*v/tau __k_2_v = -dt*(__k_1_v/2 + v)/tau __k_3_v = -dt*(__k_2_v/2 + v)/tau __k_4_v = -dt*(__k_3_v + v)/tau _v = __k_1_v/6 + __k_2_v/3 + __k_3_v/3 + __k_4_v/6 + v v = _v """ extract_method_options(method_options, {}) # Non-stochastic numerical integrators should work for all equations, # except for stochastic equations if eqs.is_stochastic and self.stochastic is None: raise UnsupportedEquationsException("Cannot integrate " "stochastic equations with " "this state updater.") if self.custom_check: self.custom_check(eqs, variables) # The final list of statements statements = [] stochastic_variables = eqs.stochastic_variables # The variables for the intermediate results in the state updater # description, e.g. the variable k in rk2 intermediate_vars = [var for var, expr in self.statements] # A dictionary mapping all the variables in the equations to their # sympy representations eq_variables = dict(((var, _symbol(var)) for var in eqs.eq_names)) # Generate the random numbers for the stochastic variables for stochastic_variable in stochastic_variables: statements.append(f"{stochastic_variable} = dt**.5 * randn()") substituted_expressions = eqs.get_substituted_expressions(variables) # Process the intermediate statements in the stateupdater description for intermediate_var, intermediate_expr in self.statements: # Split the expression into a non-stochastic and a stochastic part non_stochastic_expr, stochastic_expr = split_expression(intermediate_expr) # Execute the statement by appropriately replacing the functions f # and g and the variable x for every equation in the model. # We use the model equations where the subexpressions have # already been substituted into the model equations. for var, expr in substituted_expressions: for xi in stochastic_variables: RHS = self._generate_RHS(eqs, var, eq_variables, intermediate_vars, expr, non_stochastic_expr, stochastic_expr, xi) statements.append(f"{intermediate_var}_{var}_{xi} = {RHS}") if not stochastic_variables: # no stochastic variables RHS = self._generate_RHS(eqs, var, eq_variables, intermediate_vars, expr, non_stochastic_expr, stochastic_expr) statements.append(f"{intermediate_var}_{var} = {RHS}") # Process the "return" line of the stateupdater description non_stochastic_expr, stochastic_expr = split_expression(self.output) if eqs.is_stochastic and (self.stochastic != 'multiplicative' and eqs.stochastic_type == 'multiplicative'): # The equations are marked as having multiplicative noise and the # current state updater does not support such equations. However, # it is possible that the equations do not use multiplicative noise # at all. They could depend on time via a function that is constant # over a single time step (most likely, a TimedArray). In that case # we can integrate the equations dt_value = variables['dt'].get_value()[0] if 'dt' in variables else None for _, expr in substituted_expressions: _, stoch = expr.split_stochastic() if stoch is None: continue # There could be more than one stochastic variable (e.g. xi_1, xi_2) for _, stoch_expr in stoch.items(): sympy_expr = str_to_sympy(stoch_expr.code) # The equation really has multiplicative noise, if it depends # on time (and not only via a function that is constant # over dt), or if it depends on another variable defined # via differential equations. if (not is_constant_over_dt(sympy_expr, variables, dt_value) or len(stoch_expr.identifiers & eqs.diff_eq_names)): raise UnsupportedEquationsException("Cannot integrate " "equations with " "multiplicative noise with " "this state updater.") # Assign a value to all the model variables described by differential # equations for var, expr in substituted_expressions: RHS = self._generate_RHS(eqs, var, eq_variables, intermediate_vars, expr, non_stochastic_expr, stochastic_expr, stochastic_variables) statements.append(f"_{var} = {RHS}") # Assign everything to the final variables for var, expr in substituted_expressions: statements.append(f"{var} = _{var}") return '\n'.join(statements)
EQ = WS + Suppress('=') + WS FRT = WS + Suppress('->') + WS HSTART = Suppress('[') HEND = Suppress(']') + WS comment = Literal('#') + restOfLine sec_directories = HSTART + CaselessLiteral("directories") + HEND sec_files = HSTART + CaselessLiteral("files") + HEND sec_settings = HSTART + CaselessLiteral("settings") + HEND section = HSTART + Word(printables + " ") + HEND keyvalue = ~HSTART + Dict(Group(Word(alphanums) + EQ + Word(printables))) fromto = Group(~HSTART + SkipTo(FRT).setResultsName("source").setParseAction( lambda x: x[0]) # whyyy + FRT + restOfLine.setResultsName("destination")) part_directories = Dict( Group(sec_directories + Group(ZeroOrMore(fromto)))).setName("part_directories") part_files = Dict(Group(sec_files + Group(ZeroOrMore(fromto)))).setName("part_files") part_settings = Dict(Group(sec_settings + OneOrMore(keyvalue))).setName("part_settings") g = Optional(part_directories) & Optional(part_files) & part_settings g.ignore(comment) # End Grammar Parsing instr = open(os.path.expanduser("~/.backup-settings"), "r").read()
HOSTNAME = NIL ^ Word(printables) HOSTNAME = HOSTNAME.setResultsName("hostname") HOSTNAME.setName("Hostname") APPNAME = Word("".join(set(printables) - {"["})) APPNAME = APPNAME.setResultsName("appname") APPNAME.setName("AppName") PROCID = Combine(LBRACKET + Word("".join(set(printables) - {"]"})) + RBRACKET) PROCID = PROCID.setResultsName("procid") PROCID.setName("ProcID") HEADER = PRIORITY + TIMESTAMP + SP + HOSTNAME + SP + APPNAME + PROCID MESSAGE = restOfLine.setResultsName("message") MESSAGE.setName("Message") SYSLOG_MESSAGE = HEADER + COLON + SP + MESSAGE SYSLOG_MESSAGE.leaveWhitespace() @attr.s(slots=True, frozen=True) class SyslogMessage: facility = attr.ib( type=Facility, converter=Facility, validator=attr.validators.in_(Facility) ) severity = attr.ib( type=Severity, converter=Severity, validator=attr.validators.in_(Severity) )
def __init__(self): filename = os.path.join(paths.lib_dir(), 'bauble.glade') self.widgets = utils.load_widgets(filename) self.window = self.widgets.main_window self.window.hide() self.previous_view = None # restore the window size geometry = prefs[self.window_geometry_pref] if geometry is not None: self.window.set_default_size(*geometry) self.window.connect('delete-event', self.on_delete_event) self.window.connect("destroy", self.on_quit) self.window.set_title(self.title) try: pixbuf = gtk.gdk.pixbuf_new_from_file(bauble.default_icon) self.window.set_icon(pixbuf) except Exception: logger.warning(_('Could not load icon from %s') % bauble.default_icon) logger.warning(traceback.format_exc()) menubar = self.create_main_menu() self.widgets.menu_box.pack_start(menubar) combo = self.widgets.main_comboentry model = gtk.ListStore(str) combo.set_model(model) self.populate_main_entry() main_entry = combo.child main_entry.connect('activate', self.on_main_entry_activate) accel_group = gtk.AccelGroup() main_entry.add_accelerator("grab-focus", accel_group, ord('L'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.window.add_accel_group(accel_group) self.widgets.home_button.connect( 'clicked', self.on_home_button_clicked) self.widgets.prev_view_button.connect( 'clicked', self.on_prev_view_button_clicked) self.widgets.go_button.connect( 'clicked', self.on_go_button_clicked) self.widgets.query_button.connect( 'clicked', self.on_query_button_clicked) self.set_default_view() # add a progressbar to the status bar # Warning: this relies on gtk.Statusbar internals and could break in # future versions of gtk statusbar = self.widgets.statusbar statusbar.set_spacing(10) statusbar.set_has_resize_grip(True) self._cids = [] def on_statusbar_push(sb, cid, txt): if cid not in self._cids: self._cids.append(cid) statusbar.connect('text-pushed', on_statusbar_push) # remove label from frame frame = statusbar.get_children()[0] #frame.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FF0000')) label = frame.get_children()[0] frame.remove(label) # replace label with hbox and put label and progress bar in hbox hbox = gtk.HBox(False, 5) frame.add(hbox) hbox.pack_start(label, True, True, 0) vbox = gtk.VBox(True, 0) hbox.pack_end(vbox, False, True, 15) self.progressbar = gtk.ProgressBar() vbox.pack_start(self.progressbar, False, False, 0) self.progressbar.set_size_request(-1, 10) vbox.show() hbox.show() from pyparsing import StringStart, Word, alphanums, restOfLine, \ StringEnd cmd = StringStart() + ':' + Word( alphanums + '-_').setResultsName('cmd') arg = restOfLine.setResultsName('arg') self.cmd_parser = (cmd + StringEnd()) | (cmd + '=' + arg) | arg combo.grab_focus()
def _item(self, code, name): return CaselessLiteral(code).suppress() + \ restOfLine.setResultsName(name) + \ LineEnd().suppress()
HOSTNAME = Combine(NIL | Word(printables)) HOSTNAME = HOSTNAME.setResultsName("hostname") HOSTNAME.setName("Hostname") APPNAME = Word("".join(set(printables) - {"["})) APPNAME = APPNAME.setResultsName("appname") APPNAME.setName("AppName") PROCID = Combine(LBRACKET + Word("".join(set(printables) - {"]"})) + RBRACKET) PROCID = PROCID.setResultsName("procid") PROCID.setName("ProcID") HEADER = PRIORITY + TIMESTAMP + SP + HOSTNAME + SP + APPNAME + PROCID MESSAGE = restOfLine.setResultsName("message") MESSAGE.setName("Message") SYSLOG_MESSAGE = HEADER + COLON + SP + MESSAGE SYSLOG_MESSAGE.leaveWhitespace() class SyslogMessage(pyrsistent.PClass): facility = pyrsistent.field(type=int, mandatory=True, factory=Facility) severity = pyrsistent.field(type=int, mandatory=True, factory=Severity) timestamp = pyrsistent.field( type=datetime.datetime, mandatory=True, factory=lambda t: arrow.get(t).datetime, )
def __init__(self, query): self._methods = { 'and': self.evaluate_and, 'or': self.evaluate_or, 'not': self.evaluate_not, 'parenthesis': self.evaluate_parenthesis, 'quotes': self.evaluate_quotes, 'word': self.evaluate_word, } self.line = '' self.query = query.lower() if query else '' if self.query: # TODO: Cleanup operator_or = Forward() operator_word = Group(Word(alphanums)).setResultsName('word') operator_quotes_content = Forward() operator_quotes_content << ( (operator_word + operator_quotes_content) | operator_word) operator_quotes = Group( Suppress('"') + operator_quotes_content + Suppress('"')).setResultsName('quotes') | operator_word operator_parenthesis = Group( (Suppress('(') + operator_or + Suppress(")") )).setResultsName('parenthesis') | operator_quotes operator_not = Forward() operator_not << ( Group(Suppress(Keyword('no', caseless=True)) + operator_not).setResultsName('not') | operator_parenthesis) operator_and = Forward() operator_and << ( Group(operator_not + Suppress(Keyword('and', caseless=True)) + operator_and).setResultsName('and') | Group(operator_not + OneOrMore(~oneOf('and or') + operator_and) ).setResultsName('and') | operator_not) operator_or << ( Group(operator_and + Suppress(Keyword('or', caseless=True)) + operator_or).setResultsName('or') | operator_and) self._query_parser = operator_or.parseString(self.query)[0] else: self._query_parser = False time_cmpnt = Word(nums).setParseAction(lambda t: t[0].zfill(2)) date = Combine((time_cmpnt + '-' + time_cmpnt + '-' + time_cmpnt) + ' ' + time_cmpnt + ':' + time_cmpnt) word = Word(printables) self._log_parser = ( date.setResultsName('timestamp') + word.setResultsName('log_level') + word.setResultsName('plugin') + (White(min=16).setParseAction( lambda s, l, t: [t[0].strip()]).setResultsName('task') | (White(min=1).suppress() & word.setResultsName('task'))) + restOfLine.setResultsName('message'))
#define USERNAME = "******" #define PASSWORD = "******" a = MAX_LOCS; CORBA::initORB("xyzzy", USERNAME, PASSWORD ); """ ################# print("Example of an extractor") print("----------------------") # simple grammar to match #define's ident = Word(alphas, alphanums + "_") macroDef = (Literal("#define") + ident.setResultsName("name") + "=" + restOfLine.setResultsName("value")) for t, s, e in macroDef.scanString(testData): print(t.name, ":", t.value) # or a quick way to make a dictionary of the names and values # (return only key and value tokens, and construct dict from key-value pairs) # - empty ahead of restOfLine advances past leading whitespace, does implicit lstrip during parsing macroDef = Suppress("#define") + ident + Suppress("=") + empty + restOfLine macros = dict(list(macroDef.searchString(testData))) print("macros =", macros) print() ################# print("Examples of a transformer") print("----------------------")