def _compile_model(model_folder: str, model_name: str, compiler_options: Dict[str, str]): # Importing the antlr4 (generated modules) is rather slow. Avoid for this # ~100 ms startup overhead for cached models by importing only when # compiling. from pymoca import parser # Load folders tree = None for folder in [model_folder] + compiler_options['library_folders']: for root, dir, files in os.walk(folder, followlinks=True): for item in fnmatch.filter(files, "*.mo"): logger.info("Parsing {}".format(item)) with open(os.path.join(root, item), 'r') as f: if tree is None: tree = parser.parse(f.read()) else: tree.extend(parser.parse(f.read())) # Compile logger.info("Generating CasADi model") model = generator.generate(tree, model_name, compiler_options) if compiler_options['check_balanced']: model.check_balanced() model.simplify(compiler_options) if compiler_options['verbose']: model.check_balanced() model._post_checks() return model
def _compile_model(model_folder: str, model_name: str, compiler_options: Dict[str, str]): # Load folders tree = None for folder in [model_folder] + compiler_options.get('library_folders', []): for root, dir, files in os.walk(folder, followlinks=True): for item in fnmatch.filter(files, "*.mo"): logger.info("Parsing {}".format(item)) with open(os.path.join(root, item), 'r') as f: if tree is None: tree = parser.parse(f.read()) else: tree.extend(parser.parse(f.read())) # Compile logger.info("Generating CasADi model") model = generator.generate(tree, model_name, compiler_options) if compiler_options.get('check_balanced', True): model.check_balanced() model.simplify(compiler_options) if compiler_options.get('verbose', False): model.check_balanced() return model
def _compile_model(model_folder: str, model_name: str, compiler_options: Dict[str, str]): # Load folders tree = None for folder in [model_folder] + compiler_options.get('library_folders', []): for root, dir, files in os.walk(folder, followlinks=True): for item in fnmatch.filter(files, "*.mo"): logger.info("Parsing {}".format(item)) with open(os.path.join(root, item), 'r') as f: if tree is None: tree = parser.parse(f.read()) else: tree.extend(parser.parse(f.read())) # Compile logger.info("Generating CasADi model") model = generator.generate(tree, model_name, compiler_options) if compiler_options.get('check_balanced', True): model.check_balanced() model.simplify(compiler_options) if compiler_options.get('verbose', False): model.check_balanced() model._post_checks() return model
def test_modification_typo(self): with open(os.path.join(MODEL_DIR, 'ModificationTypo.mo'), 'r') as f: txt = f.read() for c in ["Wrong1", "Wrong2"]: with self.assertRaises(tree.ModificationTargetNotFound): ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name=c)) for c in ["Good1", "Good2"]: ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name=c))
def test_unit_type_array(self): txt = """ model A parameter Integer x[2, 2] = {{1, 2}, {3, 4}}; parameter Real y[2, 2] = {{1.0, 2.0}, {3.0, 4.0}}; end A; """ ast_tree = parser.parse(txt) class_name = 'A' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) # For the moment, we leave type conversions to the backends. We only want to # be sure that we read in the correct type in the parser. for i in range(2): for j in range(2): self.assertIsInstance( flat_tree.classes['A'].symbols['x'].value.values[i]. values[j].value, int) self.assertIsInstance( flat_tree.classes['A'].symbols['y'].value.values[i]. values[j].value, float)
def test_inheritance_symbol_modifiers(self): with open(os.path.join(MODEL_DIR, 'Inheritance.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='Sub')) self.assertEqual(flat_tree.classes['Sub'].symbols['x'].max.value, 30.0)
def test_extends_modification(self): with open(os.path.join(MODEL_DIR, 'ExtendsModification.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='MainModel')) self.assertEqual(flat_tree.classes['MainModel'].symbols['e.HQ.H'].min.name, "e.H_b")
def test_simple_circuit(self): # compile to ModelicaXML with open(os.path.join(MODEL_DIR, 'SimpleCircuit.mo'), 'r') as f: txt = f.read() ast_tree = mo_parser.parse(txt) model_xml = generator.generate(ast_tree, 'SimpleCircuit') # save xml model to disk with open(os.path.join(GENERATED_DIR, 'SimpleCircuit.xml'), 'w') as f: f.write(model_xml) # load xml model model = xml_parser.parse(model_xml, verbose=False) print(model) # convert to ode model_ode = model.to_ode() # type: model.HybridOde print(model_ode) # simulate data = sim_scipy.sim(model_ode, { 'tf': 1, 'dt': 0.001, 'verbose': True }) # plot analysis.plot(data, fields=['x', 'c', 'm']) plt.draw() plt.pause(0.1) plt.close()
def test_function_pull(self): with open(os.path.join(MODEL_DIR, 'FunctionPull.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'Level1.Level2.Level3.Function5' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) # Check if all referenced functions are pulled in self.assertIn('Level1.Level2.Level3.f', flat_tree.classes) self.assertIn('Level1.Level2.Level3.TestPackage.times2', flat_tree.classes) self.assertIn('Level1.Level2.Level3.TestPackage.square', flat_tree.classes) self.assertNotIn('Level1.Level2.Level3.TestPackage.not_called', flat_tree.classes) # Check if the classes in the flattened tree have the right type self.assertEqual(flat_tree.classes['Function5'].type, 'model') self.assertEqual(flat_tree.classes['Level1.Level2.Level3.f'].type, 'function') self.assertEqual(flat_tree.classes['Level1.Level2.Level3.TestPackage.times2'].type, 'function') self.assertEqual(flat_tree.classes['Level1.Level2.Level3.TestPackage.square'].type, 'function') # Check whether input/output information of functions comes along properly func_t2 = flat_tree.classes['Level1.Level2.Level3.TestPackage.times2'] self.assertIn("input", func_t2.symbols['x'].prefixes) self.assertIn("output", func_t2.symbols['y'].prefixes) # Check if built-in function call statement comes along properly func_f = flat_tree.classes['Level1.Level2.Level3.f'] self.assertEqual(func_f.statements[0].right.operator, '*') # Check if user-specified function call statement comes along properly self.assertEqual(func_f.statements[0].right.operands[0].operator, 'Level1.Level2.Level3.TestPackage.times2')
def test_deep_copy_timeout(self): with open(os.path.join(MODEL_DIR, 'DeepCopyTimeout.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) # Start a background thread which will run the flattening, such that # we can kill it if takes to long. # noinspection PyTypeChecker thread = threading.Thread(target=tree.flatten, args=( ast_tree, ast.ComponentRef(name='Test'), )) # Daemon threads automatically stop when the program stops (and do not # prevent the program from exiting) thread.setDaemon(True) thread.start() # Use a timeout of 5 seconds. We check every 100 ms sec, such that the # test is fast to succeed when everything works as expected. for i in range(50): time.sleep(0.1) if not thread.isAlive(): return self.assertFalse(thread.isAlive(), msg='Timeout occurred')
def test_duplicate_state(self): with open(os.path.join(MODEL_DIR, 'DuplicateState.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) print('AST TREE\n', ast_tree) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='DuplicateState')) print('AST TREE FLAT\n', flat_tree) self.flush()
def test_redeclare_nested(self): with open( os.path.join(MODEL_DIR, 'RedeclareNestedClass.mo.fail_parse'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) self.assertIsNone(ast_tree)
def test_extends_modification(self): with open(os.path.join(MODEL_DIR, 'ExtendsModification.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='MainModel')) self.assertEqual( flat_tree.classes['MainModel'].symbols['e.HQ.H'].min.name, "e.H_b")
def test_estimator(self): with open(os.path.join(MODEL_DIR, './Estimator.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) print('AST TREE\n', ast_tree) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='Estimator')) print('AST TREE FLAT\n', flat_tree) self.flush()
def test_spring(self): with open(os.path.join(MODEL_DIR, 'Spring.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) print('AST TREE\n', ast_tree) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='Spring')) print('AST TREE FLAT\n', flat_tree) self.flush()
def test_redeclare_nested(self): with open( os.path.join(MODEL_DIR, 'RedeclareNestedClass.mo.fail_parse'), 'r') as f: txt = f.read() with self.assertRaises(Exception): ast_tree = parser.parse(txt)
def test_nested_classes(self): with open(os.path.join(MODEL_DIR, 'NestedClasses.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='C2')) self.assertEqual(flat_tree.classes['C2'].symbols['v1'].nominal.value, 1000.0) self.assertEqual(flat_tree.classes['C2'].symbols['v2'].nominal.value, 1000.0)
def test_spring_system(self): with open(os.path.join(MODEL_DIR, 'SpringSystem.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) print('AST TREE\n', ast_tree) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='SpringSystem')) print('AST TREE FLAT\n', flat_tree) self.flush()
def test_inheritance(self): with open(os.path.join(MODEL_DIR, 'InheritanceInstantiation.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='C2')) self.assertEqual(flat_tree.classes['C2'].symbols['bcomp1.b'].value.value, 3.0) self.assertEqual(flat_tree.classes['C2'].symbols['bcomp3.a'].value.value, 1.0) self.assertEqual(flat_tree.classes['C2'].symbols['bcomp3.b'].value.value, 2.0)
def test_bouncing_ball(self): with open(os.path.join(MODEL_DIR, 'BouncingBall.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) print('AST TREE\n', ast_tree) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='BouncingBall')) print(flat_tree) print('AST TREE FLAT\n', flat_tree) self.flush()
def test_bouncing_ball(self): # generate with open(os.path.join(MODEL_DIR, 'BouncingBall.mo'), 'r') as f: txt = f.read() ast_tree = mo_parser.parse(txt) generator.generate(ast_tree, 'BouncingBall') # parse example_file = os.path.join(MODEL_DIR, 'bouncing-ball.xml') model = xml_parser.parse_file(example_file, verbose=False) print(model) # convert to ode model_ode = model.to_ode() # type: model.HybridOde model_ode.prop['x']['start'] = 1 print(model_ode) # simulate data = sim_scipy.sim(model_ode, { 'tf': 3.5, 'dt': 0.01, 'verbose': True }) # plot analysis.plot(data, linewidth=0.5, marker='.', markersize=0.5) plt.draw() plt.pause(0.1) plt.close() # simulate in soft real-time do_realtime = False if do_realtime: print('\nsoft-realtime simulation') time_start = time.time() def realtime_callback(t, x, y, m, p, c): t_real = time.time() - time_start lag = t_real - t if abs(lag) > 0.1: print("real: {:10f} > sim: {:10f}, lag: {:10f}".format( t_real, t, lag)) elif lag < 0: time.sleep(-lag) data = sim_scipy.sim(model_ode, { 'tf': 3.5, 'dt': 0.01, 'verbose': True }, user_callback=realtime_callback) # plt.gca().set_ylim(-2, 2) self.flush()
def test_parameter_modification_scope(self): with open(os.path.join(MODEL_DIR, 'ParameterScope.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'ScopeTest' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual(flat_tree.classes['ScopeTest'].symbols['nc.p'].value.name, 'p')
def test_extends_order(self): with open(os.path.join(MODEL_DIR, 'ExtendsOrder.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'P.M' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual(flat_tree.classes['M'].symbols['at.m'].value.value, 0.0)
def test_nested_symbol_modification(self): with open(os.path.join(MODEL_DIR, 'NestedSymbolModification.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'E' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual(flat_tree.classes['E'].symbols['c.x'].nominal.value, 2.0)
def test_redeclare_in_extends(self): with open(os.path.join(MODEL_DIR, 'RedeclareInExtends.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'ChannelZ' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertIn('down.Z', flat_tree.classes['ChannelZ'].symbols)
def test_connector(self): with open(os.path.join(MODEL_DIR, 'Connector.mo'), 'r') as f: txt = f.read() # noinspection PyUnusedLocal ast_tree = parser.parse(txt) # states = ast_tree.classes['Aircraft'].states # names = sorted([state.name for state in states]) # names_set = sorted(list(set(names))) # if names != names_set: # raise IOError('{:s} != {:s}'.format(str(names), str(names_set))) self.flush()
def test_extends_redeclareable(self): with open(os.path.join(MODEL_DIR, 'ExtendsRedeclareable.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'E' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertIn('z.y', flat_tree.classes['E'].symbols) self.assertEqual(flat_tree.classes['E'].symbols['z.y'].nominal.value, 2.0)
def test_constant_references(self): with open(os.path.join(MODEL_DIR, 'ConstantReferences.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'b' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual(flat_tree.classes['b'].symbols['m.p'].value.value, 2.0) self.assertEqual(flat_tree.classes['b'].symbols['M2.m.f'].value.value, 3.0)
def test_custom_units(self): with open(os.path.join(MODEL_DIR, 'CustomUnits.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'A' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual(flat_tree.classes['A'].symbols['dummy_parameter'].unit.value, "m/s") self.assertEqual(flat_tree.classes['A'].symbols['dummy_parameter'].value.value, 10.0)
def test_parameter_modification_scope(self): with open(os.path.join(MODEL_DIR, 'ParameterScope.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'ScopeTest' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual( flat_tree.classes['ScopeTest'].symbols['nc.p'].value.name, 'p')
def test_redeclaration_scope_alternative(self): with open(os.path.join(MODEL_DIR, 'RedeclarationScopeAlternative.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'ChannelZ' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertIn('c.up.Z', flat_tree.classes['ChannelZ'].symbols) self.assertIn('c.down.A', flat_tree.classes['ChannelZ'].symbols)
def test_inheritance(self): with open(os.path.join(MODEL_DIR, 'InheritanceInstantiation.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='C2')) self.assertEqual( flat_tree.classes['C2'].symbols['bcomp1.b'].value.value, 3.0) self.assertEqual( flat_tree.classes['C2'].symbols['bcomp3.a'].value.value, 1.0) self.assertEqual( flat_tree.classes['C2'].symbols['bcomp3.b'].value.value, 2.0)
def test_extend_from_self(self): txt = """ model A extends A; end A;""" ast_tree = parser.parse(txt) class_name = 'A' comp_ref = ast.ComponentRef.from_string(class_name) with self.assertRaisesRegex(Exception, "Cannot extend class 'A' with itself"): flat_tree = tree.flatten(ast_tree, comp_ref)
def test_estimator(self): with open(os.path.join(MODEL_DIR, 'Estimator.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) text = gen_sympy.generate(ast_tree, 'Estimator') with open(os.path.join(GENERATED_DIR, 'Estimator.py'), 'w') as f: f.write(text) from test.generated.Estimator import Estimator as Estimator e = Estimator() e.linearize_symbolic() e.linearize() # noinspection PyUnusedLocal res = e.simulate(x0=[1.0]) self.flush()
def test_quad(self): with open(os.path.join(MODEL_DIR, 'Quad.mo'), 'r') as f: txt = f.read() # noinspection PyUnusedLocal ast_tree = parser.parse(txt) text = gen_sympy.generate(ast_tree, 'Quad') with open(os.path.join(GENERATED_DIR, 'Quad.py'), 'w') as f: f.write(text) from test.generated.Quad import Quad as Quad e = Quad() e.linearize_symbolic() e.linearize() # noinspection PyUnusedLocal res = e.simulate() self.flush()
def test_aircraft(self): with open(os.path.join(MODEL_DIR, 'Aircraft.mo'), 'r') as f: txt = f.read() # noinspection PyUnusedLocal ast_tree = parser.parse(txt) text = gen_sympy.generate(ast_tree, 'Aircraft') with open(os.path.join(GENERATED_DIR, 'Aircraft.py'), 'w') as f: f.write(text) from test.generated.Aircraft import Aircraft as Aircraft e = Aircraft() e.linearize_symbolic() e.linearize() # noinspection PyUnusedLocal res = e.simulate() self.flush()
def test_custom_units(self): with open(os.path.join(MODEL_DIR, 'CustomUnits.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'A' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) self.assertEqual( flat_tree.classes['A'].symbols['dummy_parameter'].unit.value, "m/s") self.assertEqual( flat_tree.classes['A'].symbols['dummy_parameter'].value.value, 10.0)
def test_spring(self): with open(os.path.join(MODEL_DIR, 'SpringSystem.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='SpringSystem')) print(flat_tree) text = gen_sympy.generate(ast_tree, 'SpringSystem') with open(os.path.join(GENERATED_DIR, 'Spring.py'), 'w') as f: f.write(text) from test.generated.Spring import SpringSystem as SpringSystem e = SpringSystem() e.linearize_symbolic() e.linearize() # noinspection PyUnusedLocal res = e.simulate(x0=[1.0, 1.0]) self.flush()
def test_tree_lookup(self): with open(os.path.join(MODEL_DIR, 'TreeLookup.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) # The class we want to flatten. We first have to turn it into a # full-fledged ComponentRef. class_name = 'Level1.Level2.Level3.Test' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) # NOTE: We currently do not flatten the component ref in the final # tree's keys, so we use it once again to lookup the flattened class. self.assertIn('elem.tc.i', flat_tree.classes['Test'].symbols.keys()) self.assertIn('elem.tc.a', flat_tree.classes['Test'].symbols.keys()) self.assertIn('b', flat_tree.classes['Test'].symbols.keys())
def test_function_pull(self): with open(os.path.join(MODEL_DIR, 'FunctionPull.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) class_name = 'Level1.Level2.Level3.Function5' comp_ref = ast.ComponentRef.from_string(class_name) flat_tree = tree.flatten(ast_tree, comp_ref) # Check if all referenced functions are pulled in self.assertIn('Level1.Level2.Level3.f', flat_tree.classes) self.assertIn('Level1.Level2.Level3.TestPackage.times2', flat_tree.classes) self.assertIn('Level1.Level2.Level3.TestPackage.square', flat_tree.classes) self.assertNotIn('Level1.Level2.Level3.TestPackage.not_called', flat_tree.classes) # Check if the classes in the flattened tree have the right type self.assertEqual(flat_tree.classes['Function5'].type, 'model') self.assertEqual(flat_tree.classes['Level1.Level2.Level3.f'].type, 'function') self.assertEqual( flat_tree.classes['Level1.Level2.Level3.TestPackage.times2'].type, 'function') self.assertEqual( flat_tree.classes['Level1.Level2.Level3.TestPackage.square'].type, 'function') # Check whether input/output information of functions comes along properly func_t2 = flat_tree.classes['Level1.Level2.Level3.TestPackage.times2'] self.assertIn("input", func_t2.symbols['x'].prefixes) self.assertIn("output", func_t2.symbols['y'].prefixes) # Check if built-in function call statement comes along properly func_f = flat_tree.classes['Level1.Level2.Level3.f'] self.assertEqual(func_f.statements[0].right.operator, '*') # Check if user-specified function call statement comes along properly self.assertEqual(func_f.statements[0].right.operands[0].operator, 'Level1.Level2.Level3.TestPackage.times2')
def test_connector(self): with open(os.path.join(MODEL_DIR, 'Connector.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) # print(ast_tree) # noinspection PyUnusedLocal flat_tree = tree.flatten(ast_tree, ast.ComponentRef(name='Aircraft')) # print(flat_tree) # noinspection PyUnusedLocal walker = tree.TreeWalker() # noinspection PyUnusedLocal classes = ast_tree.classes # noinspection PyUnusedLocal root = ast_tree.classes['Aircraft'] # instantiator = tree.Instantiator(classes=classes) # walker.walk(instantiator, root) # print(instantiator.res[root].symbols.keys()) # print(instantiator.res[root]) # print('INSTANTIATOR\n-----------\n\n') # print(instantiator.res[root]) # connectExpander = tree.ConnectExpander(classes=classes) # walker.walk(connectExpander, instantiator.res[root]) # print('CONNECT EXPANDER\n-----------\n\n') # print(connectExpander.new_class) # text = gen_sympy.generate(ast_tree, 'Aircraft') # print(text) # with open(os.path.join(MODEL_DIR, 'generated/Connect.py'), 'w') as f: # f.write(text) # from generated.Connect import Aircraft as Aircraft # e = Aircraft() # res = e.simulate() self.flush()
def test_deep_copy_timeout(self): with open(os.path.join(MODEL_DIR, 'DeepCopyTimeout.mo'), 'r') as f: txt = f.read() ast_tree = parser.parse(txt) # Start a background thread which will run the flattening, such that # we can kill it if takes to long. # noinspection PyTypeChecker thread = threading.Thread(target=tree.flatten, args=(ast_tree, ast.ComponentRef(name='Test'),)) # Daemon threads automatically stop when the program stops (and do not # prevent the program from exiting) thread.setDaemon(True) thread.start() # Use a timeout of 5 seconds. We check every 100 ms sec, such that the # test is fast to succeed when everything works as expected. for i in range(50): time.sleep(0.1) if not thread.isAlive(): return self.assertFalse(thread.isAlive(), msg='Timeout occurred')
logging.basicConfig(level=logging.DEBUG if options.verbose else logging.INFO) # Import rest of pymoca from pymoca import parser, tree, ast # Compile if options.flatten_only: # Load folder _ast = None for root, dir, files in os.walk(model_folder, followlinks=True): for item in fnmatch.filter(files, "*.mo"): logger.info("Parsing {}".format(item)) with open(os.path.join(root, item), 'r') as f: if _ast is None: _ast = parser.parse(f.read()) else: _ast.extend(parser.parse(f.read())) logger.info("Flattening") _ast = tree.flatten(_ast, ast.ComponentRef.from_string(model_name)) print(_ast) else: # Set CasADi installation folder if options.casadi_folder is not None: sys.path.append(options.casadi_folder) from pymoca.backends.casadi.api import transfer_model import casadi as ca
def test_redeclare_nested(self): with open(os.path.join(MODEL_DIR, 'RedeclareNestedClass.mo.fail_parse'), 'r') as f: txt = f.read() with self.assertRaises(Exception): ast_tree = parser.parse(txt)