protected override void ExecuteInternal()
{
var pc = HostingHelpers.GetLanguageContext(Engine) as PythonContext;
pc.SetModuleState(typeof(ScriptEngine), Engine);
Type t = pc.GetType();
Assembly ass = t.Assembly;
try {
base.ExecuteInternal();
}
catch (ImportException iex)
{
Console.WriteLine(iex.ToString(), Style.Warning);
}
}
public IPyCompiler.Tokenizer CreateTokenizer(string text)
{
ScriptEngine engine = Python.CreateEngine();
PythonContext context = HostingHelpers.GetLanguageContext(engine) as PythonContext;
StringTextContentProvider textProvider = new StringTextContentProvider(text);
SourceUnit source = context.CreateSourceUnit(textProvider, String.Empty, SourceCodeKind.SingleStatement);
PythonCompilerSink sink = new PythonCompilerSink();
IPyCompiler.PythonCompilerOptions options = new IPyCompiler.PythonCompilerOptions();
tokenizer = new IPyCompiler.Tokenizer(sink, options);
tokenizer.Initialize(source);
return(tokenizer);
}
void CreateDecompileEngine()
{
ScriptEngine python = Python.CreateEngine();
// Disable Zip (This causes a weird error)
var pc = HostingHelpers.GetLanguageContext(python) as PythonContext;
var hooks = pc.SystemState.Get__dict__()["path_hooks"] as List;
hooks.Clear();
python.SetSearchPaths(new List <string>()
{
@"Resources\DAKompiler", @"Lib"
});
_pythonDecompiler = python.CreateScriptSourceFromString(decompile_py).Compile();
}
public FromImportStatement ParseStatement(string text)
{
ScriptEngine engine = Python.CreateEngine();
PythonContext context = HostingHelpers.GetLanguageContext(engine) as PythonContext;
StringTextContentProvider textProvider = new StringTextContentProvider(text);
SourceUnit source = context.CreateSourceUnit(textProvider, String.Empty, SourceCodeKind.SingleStatement);
PythonCompilerSink sink = new PythonCompilerSink();
CompilerContext compilerContext = new CompilerContext(source, new PythonCompilerOptions(), sink);
PythonOptions options = new PythonOptions();
using (Parser parser = Parser.CreateParser(compilerContext, options)) {
return(parser.ParseSingleStatement().Body as FromImportStatement);
}
}
protected override void ExecuteInternal()
{
PythonContext ctx = HostingHelpers.GetLanguageContext(Engine) as PythonContext;
Runtime.IO.SetOutput(new MemoryStream(), _control.Output);
Runtime.IO.SetErrorOutput(new MemoryStream(), _control.Error);
ctx.SetModuleState(typeof(ScriptEngine), Engine);
Runtime.LoadAssembly(typeof(MainForm).Assembly);
ICollection <string> searchPaths = Engine.GetSearchPaths();
string item = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PythonLib");
searchPaths.Add(item);
Engine.SetSearchPaths(searchPaths);
base.ExecuteInternal();
}
private static string ExecutePython(string scriptContent, PythonModel model)
{
var engine = Python.CreateEngine();
var pc = HostingHelpers.GetLanguageContext(engine) as PythonContext;
var hooks = pc?.SystemState.Get__dict__()["path_hooks"] as List;
hooks?.Clear();
var searchPaths = engine.GetSearchPaths();
searchPaths.Add(ConfigurationManager.AppSettings["PythonLibPath"]);
engine.SetSearchPaths(searchPaths);
using (var ms = new MemoryStream())
using (var sw = new StreamWriter(ms))
{
engine.Runtime.IO.SetOutput(ms, sw);
engine.Runtime.IO.SetErrorOutput(ms, sw);
try
{
var sc = engine.CreateScriptSourceFromString(scriptContent);
var code = sc.Compile();
var scope = engine.CreateScope();
scope.SetVariable("model", model);
scope.SetVariable("Data", model.Data);
var qf = new QueryFunctions(model.db, model.dictionary);
scope.SetVariable("q", qf);
code.Execute(scope);
ms.Position = 0;
using (var sr = new StreamReader(ms))
{
var s = sr.ReadToEnd();
return(s);
}
}
catch (Exception ex)
{
var err = engine.GetService <ExceptionOperations>().FormatException(ex);
throw new Exception(err);
}
}
}
public static int Run(List <string> /*!*/ args)
{
if (Thread.CurrentThread.CurrentCulture.ToString() != "en-US")
{
Console.WriteLine("Current culture: {0}", Thread.CurrentThread.CurrentCulture);
}
if (!ParseArguments(args))
{
return(-3);
}
int status = 0;
if (_runTokenizerDriver)
{
TokenizerTestDriver driver = new TokenizerTestDriver((RubyContext)HostingHelpers.GetLanguageContext(Ruby.CreateEngine()));
if (!driver.ParseArgs(args))
{
return(-3);
}
status = driver.RunTests();
}
else
{
InitializeDomain();
Driver driver = new Driver();
if (Manual.TestCode.Trim().Length == 0)
{
status = driver.RunUnitTests(args);
}
else
{
driver.RunManualTest();
// for case the test is forgotten, this would fail the test suite:
status = -2;
}
}
// return failure on bad filter (any real failures throw)
return(status);
}
public void RestartEngine()
{
if (!m_runningScript)
{
if (ScriptEngineRestarting != null)
{
ScriptEngineRestarting(this, new EventArgs());
}
var context = HostingHelpers.GetLanguageContext(m_engine);
context.Shutdown();
m_engine = CreateAndInitEngine();
if (ScriptEngineRestarted != null)
{
ScriptEngineRestarted(this, new EventArgs());
}
}
}
public IronPythonInterpreter(ScriptEngine engine)
{
_engine = engine;
var pythonContext = HostingHelpers.GetLanguageContext(_engine) as PythonContext;
_codeContextCls = new ModuleContext(new PythonDictionary(), pythonContext).GlobalContext;
_codeContextCls.ModuleContext.ShowCls = true;
_codeContext = new ModuleContext(
new PythonDictionary(),
HostingHelpers.GetLanguageContext(_engine) as PythonContext
).GlobalContext;
_namespaceTracker = new TopNamespaceTracker(_codeContext.LanguageContext.DomainManager);
AddAssembly(LoadAssemblyInfo(typeof(string).Assembly));
AddAssembly(LoadAssemblyInfo(typeof(Debug).Assembly));
string installDir = GetPythonInstallDir();
if (installDir != null)
{
var dllDir = Path.Combine(installDir, "DLLs");
if (Directory.Exists(dllDir))
{
foreach (var assm in Directory.GetFiles(dllDir))
{
try {
var asm = Assembly.LoadFile(Path.Combine(dllDir, assm));
_engine.Runtime.LoadAssembly(asm);
AddAssembly(LoadAssemblyInfo(asm));
} catch {
}
}
}
}
LoadAssemblies();
LoadModules();
}
public TestRuntime(Driver /*!*/ driver, TestCase /*!*/ testCase)
{
_driver = driver;
_testName = testCase.Name;
if (testCase.Options.NoRuntime)
{
return;
}
#if !WIN8
if (_driver.SaveToAssemblies)
{
Environment.SetEnvironmentVariable("DLR_AssembliesFileName", _testName);
}
#endif
_engine = _driver.CreateRubyEngine(testCase.Options.PrivateBinding, testCase.Options);
_runtime = _engine.Runtime;
_context = (RubyContext)HostingHelpers.GetLanguageContext(_engine);
}
/// <summary>
/// This constructor creates an instance of the class named classname, and is called with pe.instance.Run().
/// It supports the old style of MorningBatch and RegisterEvent.
/// </summary>
public PythonModel(string dbname, string classname, string script)
: this(dbname)
{
var engine = Python.CreateEngine();
var pc = HostingHelpers.GetLanguageContext(engine) as PythonContext;
var hooks = pc?.SystemState.Get__dict__()["path_hooks"] as List;
hooks?.Clear();
var searchPaths = engine.GetSearchPaths();
searchPaths.Add(ConfigurationManager.AppSettings["PythonLibPath"]);
engine.SetSearchPaths(searchPaths);
var sc = engine.CreateScriptSourceFromString(script);
var code = sc.Compile();
var scope = engine.CreateScope();
scope.SetVariable("model", this);
code.Execute(scope);
dynamic Event = scope.GetVariable(classname);
instance = Event();
}
private void ParsePythonCode(TextContentProvider content, out PythonAst ast, out CollectingErrorSink errorSink)
{
ast = null;
errorSink = new CollectingErrorSink();
// parse the tree
var source = _engine.CreateScriptSource(content, "", SourceCodeKind.File);
var compOptions = (PythonCompilerOptions)HostingHelpers.GetLanguageContext(_engine).GetCompilerOptions();
var context = new CompilerContext(HostingHelpers.GetSourceUnit(source), compOptions, errorSink);
//compOptions.Verbatim = true;
using (var parser = MakeParser(context)) {
if (parser != null)
{
try {
ast = parser.ParseFile(false);
} catch (Exception e) {
Debug.Assert(false, String.Format("Failure in IronPython parser: {0}", e.ToString()));
}
}
}
}
private static void DoThePython()
{
var engine = Python.CreateEngine();
PythonContext context = HostingHelpers.GetLanguageContext(engine) as PythonContext;
ICollection <string> paths = context.GetSearchPaths();
paths.Add(@"C:\Program Files (x86)\IronPython 2.7\Lib");
context.SetSearchPaths(paths);
engine.ImportModule("xml");
engine.Runtime.LoadAssembly(System.Reflection.Assembly.GetEntryAssembly());
var scope = engine.CreateScope();
engine.ExecuteFile(@"C:\Users\aheumann\Documents\vvd\CommonGraphDiffer.py", scope);
var xmlToDS = scope.GetVariable <Func <string, dynamic> >("XMLToDS");
var myDS = xmlToDS(@"C:\Users\aheumann\Documents\vvd\foo.dsx");
foreach (var change in myDS.Changes)
{
//Console.WriteLine(change.ToString());
}
}
//spawns the python compiler and analyzes a script
// outputs: ParseInfo class containing:
// errors
// python ast
public ParseInfo Parse(string source)
{
var parseErrorSink = new ScriptErrorSink();
ScriptSource script_source = scriptEngine.CreateScriptSourceFromString(source, SourceCodeKind.File);
var source_unit = HostingHelpers.GetSourceUnit(script_source);
var language_context = HostingHelpers.GetLanguageContext(scriptEngine);
Parser parser = Parser.CreateParser(
new CompilerContext(source_unit, language_context.GetCompilerOptions(), parseErrorSink),
(PythonOptions)language_context.Options);
var python_ast = parser.ParseFile(false);
var info = new ParseInfo(parseErrorSink.Errors, python_ast);
//no need for that
//var walker = new TurtleScriptAstWalker(info);
//python_ast.Walk(walker);
return(info);
}
protected override void ExecuteInternal()
{
PythonContext ctx = HostingHelpers.GetLanguageContext(Engine) as PythonContext;
(HostingHelpers.GetLanguageContext(base.Engine) as PythonContext).SetModuleState(typeof(ScriptEngine), base.Engine);
ctx.SetModuleState(typeof(ScriptEngine), Engine);
Runtime.LoadAssembly(typeof(NetGraph).Assembly);
Runtime.LoadAssembly(typeof(NetGraphDocument).Assembly);
Runtime.LoadAssembly(typeof(ProxyNetworkService).Assembly);
Runtime.LoadAssembly(typeof(ExpressionResolver).Assembly);
Runtime.LoadAssembly(typeof(Program).Assembly);
Runtime.LoadAssembly(typeof(BaseDataEndpoint).Assembly);
Runtime.LoadAssembly(typeof(CertificateUtils).Assembly);
Runtime.LoadAssembly(typeof(Org.BouncyCastle.Asn1.Asn1Encodable).Assembly);
Runtime.LoadAssembly(typeof(NodeLibraryAttribute).Assembly);
ICollection <string> searchPaths = Engine.GetSearchPaths();
string item = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PythonLib");
searchPaths.Add(item);
Engine.SetSearchPaths(searchPaths);
base.ExecuteInternal();
}
public CodeFile Parse(string programText, string fileName)
{
ScriptEngine py = null;
SourceUnit src = null;
LanguageContext pythonLanguageContext = null;
CompilerContext cc = null;
IronPython.PythonOptions pyOptions;
IronPython.Compiler.Parser pyParser = null;
PythonAst ast = null;
try
{
py = IronPython.Hosting.Python.CreateEngine();
src = HostingHelpers.GetSourceUnit(py.CreateScriptSourceFromString(programText));
pythonLanguageContext = HostingHelpers.GetLanguageContext(py);
cc = new CompilerContext(src, pythonLanguageContext.GetCompilerOptions(), ErrorSink.Default);
pyOptions = pythonLanguageContext.Options as IronPython.PythonOptions;
pyParser = Parser.CreateParser(cc, pyOptions);
ast = pyParser.ParseFile(true);
}
finally
{
pyParser?.Dispose();
}
PythonEntityCollector collector = new PythonEntityCollector();
ast.Walk(collector);
var cf = collector.getCodeFile();
cf.Name = String.IsNullOrWhiteSpace(fileName) ? $"{rm.GetString("PythonString", CultureInfo.CurrentCulture)}" : fileName;
return(cf);
}
private static ScriptEngine CreateEngine(bool fromFile = false)
{
var engine = fromFile
? Python.CreateEngine(new Dictionary <string, object> {
["Debug"] = true
})
: Python.CreateEngine();
var pc = HostingHelpers.GetLanguageContext(engine) as PythonContext;
var hooks = pc?.SystemState.Get__dict__()["path_hooks"] as List;
hooks?.Clear();
var searchPaths = engine.GetSearchPaths();
var pythonLibPath = ConfigurationManager.AppSettings["PythonLibPath"];
if (pythonLibPath != null)
{
foreach (var path in pythonLibPath.Split(';'))
{
searchPaths.Add(path);
}
}
engine.SetSearchPaths(searchPaths);
return(engine);
}
public static void run(string path, Mml2vgmInfo info, int index)
{
ScriptEngine engine = null;
ScriptRuntime runtime = null;
try
{
engine = Python.CreateEngine();
var pc = HostingHelpers.GetLanguageContext(engine) as PythonContext;
var hooks = pc.SystemState.Get__dict__()["path_hooks"] as List;
hooks.Clear();
ScriptSource source = engine.CreateScriptSourceFromFile(path);
CompiledCode code = source.Compile();
ScriptScope scope = engine.CreateScope();
runtime = engine.Runtime;
Assembly assembly = typeof(Program).Assembly;
runtime.LoadAssembly(Assembly.LoadFile(assembly.Location));
source.Execute(scope);
dynamic pyClass = scope.GetVariable("Mml2vgmScript");
dynamic mml2vgmScript = pyClass();
ScriptInfo si = mml2vgmScript.run(info, index);
if (si != null && info.document != null)
{
info.document.editor.azukiControl.Document.Replace(si.responseMessage);
}
}
catch (Exception ex)
{
log.ForcedWrite(ex);
}
finally
{
runtime.Shutdown();
}
}
public void TestAnalyzeStdLib()
{
//string dir = Path.Combine(Environment.GetEnvironmentVariable("ProgramFiles"), "IronPython 2.6 for .NET 4.0 RC\\Lib");
string dir = Path.Combine("C:\\Python27\\Lib");
List <string> files = new List <string>();
CollectFiles(dir, files);
List <SourceUnit> sourceUnits = new List <SourceUnit>();
foreach (string file in files)
{
sourceUnits.Add(
new SourceUnit(
HostingHelpers.GetLanguageContext(_engine),
new FileTextContentProvider(new FileStreamContentProvider(file)),
Path.GetFileNameWithoutExtension(file),
SourceCodeKind.File
)
);
}
Stopwatch sw = new Stopwatch();
sw.Start();
long start0 = sw.ElapsedMilliseconds;
var projectState = new ProjectState(_engine);
List <ProjectEntry> modules = new List <ProjectEntry>();
PythonOptions EmptyOptions = new PythonOptions();
foreach (var sourceUnit in sourceUnits)
{
modules.Add(projectState.AddModule(Path.GetFileNameWithoutExtension(sourceUnit.Path), sourceUnit.Path, null));
}
long start1 = sw.ElapsedMilliseconds;
Console.WriteLine("AddSourceUnit: {0} ms", start1 - start0);
List <PythonAst> nodes = new List <PythonAst>();
for (int i = 0; i < modules.Count; i++)
{
PythonAst ast = null;
try {
var sourceUnit = sourceUnits[i];
var context = new CompilerContext(sourceUnit, HostingHelpers.GetLanguageContext(_engine).GetCompilerOptions(), ErrorSink.Null);
ast = Parser.CreateParser(context, EmptyOptions).ParseFile(false);
} catch (Exception) {
}
nodes.Add(ast);
}
long start2 = sw.ElapsedMilliseconds;
Console.WriteLine("Parse: {0} ms", start2 - start1);
for (int i = 0; i < modules.Count; i++)
{
var ast = nodes[i];
if (ast != null)
{
modules[i].UpdateTree(ast, null);
}
}
long start3 = sw.ElapsedMilliseconds;
for (int i = 0; i < modules.Count; i++)
{
Console.WriteLine("Analyzing {1}: {0} ms", sw.ElapsedMilliseconds - start3, sourceUnits[i].Path);
var ast = nodes[i];
if (ast != null)
{
modules[i].Analyze();
}
}
long start4 = sw.ElapsedMilliseconds;
Console.WriteLine("Analyze: {0} ms", start4 - start3);
Console.ReadLine();
}
public ProjectState(ScriptEngine pythonEngine)
{
_pythonEngine = pythonEngine;
_projectEntries = new List <ProjectEntry>();
_modules = new Dictionary <string, ModuleReference>();
_modulesByFilename = new Dictionary <string, ModuleInfo>(StringComparer.OrdinalIgnoreCase);
_itemCache = new Dictionary <object, object>();
var pythonContext = HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext;
_codeContextCls = new ModuleContext(new PythonDictionary(), pythonContext).GlobalContext;
_codeContextCls.ModuleContext.ShowCls = true;
_codeContext = new ModuleContext(
new PythonDictionary(),
HostingHelpers.GetLanguageContext(_pythonEngine) as PythonContext
).GlobalContext;
InitializeBuiltinModules();
// TODO: Use reflection-only!
_references = new List <KeyValuePair <Assembly, TopNamespaceTracker> >();
AddAssembly(LoadAssemblyInfo(typeof(string).Assembly));
AddAssembly(LoadAssemblyInfo(typeof(Debug).Assembly));
// cached for quick checks to see if we're a call to clr.AddReference
SpecializeFunction("clr", "AddReference", (n, unit, args) => AddReference(n, null));
SpecializeFunction("clr", "AddReferenceByPartialName", (n, unit, args) => AddReference(n, ClrModule.LoadAssemblyByPartialName));
SpecializeFunction("clr", "AddReferenceByName", (n, unit, args) => AddReference(n, null));
SpecializeFunction("clr", "AddReferenceToFile", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFile(_codeContext, s)));
SpecializeFunction("clr", "AddReferenceToFileAndPath", (n, unit, args) => AddReference(n, (s) => ClrModule.LoadAssemblyFromFileWithPath(_codeContext, s)));
try {
SpecializeFunction("wpf", "LoadComponent", LoadComponent);
} catch (KeyNotFoundException) {
// IronPython.Wpf.dll isn't available...
}
SpecializeFunction("__builtin__", "range", (n, unit, args) => unit.DeclaringModule.GetOrMakeNodeVariable(n, (nn) => new RangeInfo(ClrModule.GetPythonType(typeof(List)), unit.ProjectState).SelfSet));
SpecializeFunction("__builtin__", "min", ReturnUnionOfInputs);
SpecializeFunction("__builtin__", "max", ReturnUnionOfInputs);
_builtinModule = (BuiltinModule)Modules["__builtin__"].Module;
_propertyObj = GetBuiltin("property");
_classmethodObj = GetBuiltin("classmethod");
_staticmethodObj = GetBuiltin("staticmethod");
_typeObj = GetBuiltin("type");
_intType = GetBuiltin("int");
_stringType = (BuiltinClassInfo)GetBuiltin("str");
_objectSet = new HashSet <Namespace>(new[] { GetBuiltin("object") });
_setType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Set);
_rangeFunc = GetBuiltin("range");
_frozensetType = GetBuiltin("frozenset");
_functionType = GetNamespaceFromObjects(TypeCache.Function);
_generatorType = (BuiltinClassInfo)GetNamespaceFromObjects(DynamicHelpers.GetPythonTypeFromType(typeof(PythonGenerator)));
_dictType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Dict);
_boolType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.Boolean);
_noneInst = (ConstantInfo)GetNamespaceFromObjects(new object[] { null });
_listType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.List);
_tupleType = (BuiltinClassInfo)GetNamespaceFromObjects(TypeCache.PythonTuple);
_queue = new Queue <AnalysisUnit>();
_docProvider = CodeContext.LanguageContext.GetService <DocumentationProvider>();
}
private static PythonContext /*!*/ GetPythonContext(ScriptEngine /*!*/ engine)
{
return(HostingHelpers.GetLanguageContext(engine) as PythonContext);
}
public static int Run(List <string> /*!*/ args, string baseDirectory)
{
#if !WIN8
if (Thread.CurrentThread.CurrentCulture.ToString() != "en-US")
{
WriteOutput("Current culture: {0}", Thread.CurrentThread.CurrentCulture);
}
#endif
if (!ParseArguments(args))
{
return(-3);
}
#if !WIN8
if (_runTokenizerDriver)
{
TokenizerTestDriver tokenizerDriver = new TokenizerTestDriver((RubyContext)HostingHelpers.GetLanguageContext(Ruby.CreateEngine()));
if (!tokenizerDriver.ParseArgs(args))
{
return(-3);
}
return(tokenizerDriver.RunTests());
}
#endif
InitializeDomain();
Driver driver = new Driver(baseDirectory);
if (Manual.TestCode.Trim().Length == 0)
{
return(driver.RunUnitTests(args));
}
#if !WIN8
driver.RunManualTest();
#endif
// for case the test is forgotten, this would fail the test suite:
return(-2);
}
// TODO:
public static RubyContext /*!*/ GetExecutionContext(ScriptEngine /*!*/ engine)
{
ContractUtils.RequiresNotNull(engine, "engine");
return((RubyContext)HostingHelpers.GetLanguageContext(engine));
}
protected override bool ShouldEvaluateForCompletion(string source)
{
var scriptSrc = _localEngine.CreateScriptSource(new StringTextContentProvider(source), "", SourceCodeKind.Expression);
var context = new CompilerContext(HostingHelpers.GetSourceUnit(scriptSrc), HostingHelpers.GetLanguageContext(_localEngine).GetCompilerOptions(), ErrorSink.Null);
var parser = Parser.CreateParser(context, new PythonOptions());
var stmt = parser.ParseSingleStatement();
var exprWalker = new ExprWalker();
stmt.Walk(exprWalker);
return(exprWalker.ShouldExecute);
}
public static EssenceSharpContext essenceSharpContext(this ScriptEngine engine)
{
return((EssenceSharpContext)HostingHelpers.GetLanguageContext(engine));
}
protected SourceUnit CreateSourceUnit(string code)
{
var context = HostingHelpers.GetLanguageContext(_engine);
return(context.CreateSnippet(code, SourceCodeKind.InteractiveCode));
}
public PythonEnvironmentModule(IEventAggregator aggregator, IEntityManagerViewModel entityManager,
IThermodynamicSystemImporter importer,
IChartViewModelFactory chartFactory,
IFlowsheetEntityEditorFactory flowsheetFactory,
IPureComponentPropertyDatabase pureDB,
IThermodynamicSystemViewModelFactory thermoEditorFactory
)
{
_aggregator = aggregator;
_entityManager = entityManager;
_importer = importer;
_chartFactory = chartFactory;
_flowsheetFactory = flowsheetFactory;
_pyEngine = Python.CreateEngine();
_pyScope = _pyEngine.CreateScope();
_pureComponentDB = pureDB;
_thermoEditorFactory = thermoEditorFactory;
_pyScope.SetVariable("_host", this);
_pyScope.SetVariable("Items", _entityManager);
_pyEngine.SetSearchPaths(new List <string> {
Environment.CurrentDirectory
});
var pc = HostingHelpers.GetLanguageContext(_pyEngine) as PythonContext;
var hooks = pc.SystemState.Get__dict__()["path_hooks"] as List;
hooks.Clear();
Run("import sys");
Run("import clr");
Run("clr.AddReferenceToFile(\"OpenFMSL.Core.dll\")");
Run("clr.AddReferenceToFile(\"OpenFMSL.Contracts.dll\")");
Run("from OpenFMSL.Core.Expressions import *");
Run("from OpenFMSL.Core.Flowsheeting import *");
Run("from OpenFMSL.Core.Flowsheeting.Documentation import *");
Run("from OpenFMSL.Core.Numerics import *");
Run("from OpenFMSL.Core.Numerics.Solvers import *");
Run("from OpenFMSL.Core.UnitsOfMeasure import *");
Run("from OpenFMSL.Core.ModelLibrary import *");
Run("from OpenFMSL.Core.Thermodynamics import *");
Run("from OpenFMSL.Contracts.Entities import *");
Run("from OpenFMSL.Contracts.Infrastructure.Reporting import *");
Run("from System import Math");
Run("sys.stdout=_host");
Run("runFile= _host.RunFile");
Run("run= _host.RunEntity");
Run("pause= _host.WaitThread");
Run("CreateThermo= _host.LoadThermodynamicSystem");
_pureComponentDB.SetLogCallback(Write);
ipopt = new IpoptSolver();
ipopt.OnLog = (x) => Write(" " + x + Environment.NewLine);
_pyScope.SetVariable("_ipopt", ipopt);
_pyScope.SetVariable("Database", _pureComponentDB);
newton = new Newton();
newton.OnLog = (x) => Write(" " + x + Environment.NewLine);
newton.OnLogDebug = (x) => Write(x + Environment.NewLine);
newton.OnLogError = (x) => Write("!!! " + x + Environment.NewLine);
newton.OnLogSuccess = (x) => Write("+++ " + x + Environment.NewLine);
newton.OnLogWarning = (x) => Write("*** " + x + Environment.NewLine);
newton.OnLogInfo = (x) => Write("--- " + x + Environment.NewLine);
_pyScope.SetVariable("_newton", newton);
var flash = new FlashRoutines(newton);
_pyScope.SetVariable("_flash", flash);
decomp = new Decomposer();
decomp.OnLog = (x) => Write(" " + x + Environment.NewLine);
decomp.OnLogDebug = (x) => Write(x + Environment.NewLine);
decomp.OnLogError = (x) => Write("!!! " + x + Environment.NewLine);
decomp.OnLogSuccess = (x) => Write("+++ " + x + Environment.NewLine);
decomp.OnLogWarning = (x) => Write("*** " + x + Environment.NewLine);
decomp.OnLogInfo = (x) => Write("--- " + x + Environment.NewLine);
_pyScope.SetVariable("_decomp", decomp);
Run("solve= _host.Solve");
Run("decomp= _host.Decompose");
Run("report= _host.Report");
Run("show= _host.Show");
Run("check= _host.Check");
Run("info= _host.SendLogMessage");
Run("warn= _host.SendWarningMessage");
Run("error= _host.SendErrorMessage");
Run("FlashPT= _flash.CalculateTP");
Run("FlashPZ= _flash.CalculateZP");
Run("status= _host.SendStatusTextChangeMessage");
Run("print 'Python console running...");
}