private string GetVariableText(TaskInfo info)
{
string text = info.Text;
MatchCollection mc = s_regexOwnData.Matches(text);
foreach (Match m in mc)
{
string s = string.Empty;
switch (m.Groups[1].Value.ToUpper())
{
case "COUNT":
if (!string.IsNullOrEmpty(info.SearchManagerClassName))
{
ISearchManager searchManager = ServiceProvider.GetService <IManagerFactory>().GenerateSearchManager(info.SearchManagerClassName, info.SearchManagerClassParams);
s = searchManager.GetCount(SearchExpression.Parse(EntityHelper.ReplaceExpression(info.SearchExpression))).ToString();
m_sms[info.Name] = searchManager;
}
break;
case "EXP":
string exp = m.Groups[3].Value.Trim();
object ret = PythonHelper.ExecutePythonExpression(exp, null);
s = ret == null ? string.Empty : ret.ToString();
break;
default:
throw new NotSupportedException("Invalid text of " + text);
}
text = text.Replace(m.Groups[0].Value, s);
}
return(text);
}
public override void BuildChildNodes(ITreeBuilder treeBuilder,
object dataObject)
{
PackagesNode packages = dataObject as PackagesNode;
foreach (ProjectFile projectFile in packages.Project.Files)
{
if (projectFile.BuildAction == BuildAction.Compile)
{
if (Path.GetExtension(projectFile.Name).ToLower() == ".py")
{
var name = PythonHelper.ModuleFromFilename(projectFile.Name);
// It's only a module unless there is a "." in the name
// or its the __init__.py inside the package folder.
if (name.Contains(".") || Path.GetFileName(projectFile.Name).ToLower() == "__init__.py")
{
name = PythonHelper.PackageFromFilename(projectFile.Name);
treeBuilder.AddChild(new PackageNode()
{
Name = name,
ProjectFile = projectFile,
});
}
}
}
}
}
/// <summary>
/// 执行方法
/// </summary>
/// <param name="processInfo"></param>
/// <param name="processParams"></param>
public static object ExecuteProcess(ProcessInfo processInfo, Dictionary <string, object> processParams)
{
if (processInfo == null)
{
return(null);
}
if (!processInfo.IsActive)
{
return(null);
}
switch (processInfo.Type)
{
case ProcessType.CSharp:
string[] ss = processInfo.ExecuteParam.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (ss.Length != 2)
{
throw new ArgumentException("processInfo.ExecuteParam of " + processInfo.Name + " count should be 2", "ExecuteParam");
}
if (processParams == null)
{
return(Feng.Utils.ReflectionHelper.RunStaticMethod(ss[0], ss[1], null));
}
else
{
object[] p = new object[processParams.Count];
int i = 0;
foreach (object j in processParams.Values)
{
p[i] = j;
i++;
}
return(Feng.Utils.ReflectionHelper.RunStaticMethod(ss[0], ss[1], p));
}
case ProcessType.PythonFile:
{
return(PythonHelper.ExecutePythonFile(processInfo.ExecuteParam, processParams));
}
case ProcessType.PythonStatement:
{
return(PythonHelper.ExecutePythonStatement(processInfo.ExecuteParam, processParams));
}
case ProcessType.Python:
{
return(TryExecutePython(processInfo.ExecuteParam, processParams));
}
default:
throw new NotSupportedException("processInfo.Type of " + processInfo.Name + "is Invalid!");
}
}
public void AddModuleFromPythonFile(string fileName, string moduleName = "", string entry = "Startup", params string[] paths)
{
var pythonHelper = new PythonHelper();
pythonHelper.SetSearchPaths(paths);
pythonHelper.SetSysVariable("PythonHelper", pythonHelper);
var module = pythonHelper.Execute(fileName, entry);
if (module == null)
{
throw new Exception($"{fileName}库返回值异常，返回值为null!");
}
var pythonModule = pythonHelper.GetMember(module, nameof(IModule));
pythonModule.ModuleName = moduleName;
AddModule(pythonModule);
}
void BuildClass(XmlElement element, StringReader content)
{
var compUnit = this.CompilationUnit as PythonCompilationUnit;
Console.WriteLine("Class({0})", element.GetAttribute("name"));
var name = element.GetAttribute("name");
var start = GetDomLocation(element);
var region = GetDomRegion(element);
var fullName = PythonHelper.ModuleFromFilename(FileName);
var klass = new DomType(fullName)
{
Name = name,
Location = start,
BodyRegion = region,
Modifiers = Modifiers.Public,
CompilationUnit = compUnit
};
compUnit.Add(klass);
}
protected override void Manipulate(IRandom random, ISymbolicExpressionTree symbolicExpressionTree)
{
MutationExceptionsParameter.ActualValue = new ItemCollection <StringValue>();
var pythonSemanticHelper = new PythonProcessSemanticHelper(ProblemData.Variables.GetVariableNames(), 1000); // hardcoded value!!! // TODO: object created for every mutation
var input = PythonHelper.ConvertToPythonValues(ProblemData.Input, ProblemData.TrainingIndices);
var output = PythonHelper.ConvertToPythonValues(ProblemData.Output, ProblemData.TrainingIndices);
var beforeResults = pythonSemanticHelper.EvaluateAndTraceProgram(PythonProcessParameter.ActualValue,
PythonHelper.FormatToProgram(symbolicExpressionTree, ProblemData.LoopBreakConst, ProblemData.FullHeader, ProblemData.FullFooter),
input,
output,
ProblemData.TrainingIndices,
ProblemData.FullHeader,
ProblemData.FullFooter,
symbolicExpressionTree,
Timeout);
ReplaceBranch(random, symbolicExpressionTree, ProblemData, Semantics, PythonProcess, Timeout, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value, MaxCompares.Value);
var afterResults = pythonSemanticHelper.EvaluateAndTraceProgram(PythonProcessParameter.ActualValue,
PythonHelper.FormatToProgram(symbolicExpressionTree, ProblemData.LoopBreakConst, ProblemData.FullHeader, ProblemData.FullFooter),
input,
output,
ProblemData.TrainingIndices,
ProblemData.FullHeader,
ProblemData.FullFooter,
symbolicExpressionTree,
Timeout);
if (SemanticallyEquivalentMutationParameter.ActualValue.Value == NoMutation)
{
AddStatisticsNoMutation();
}
else
{
AddStatistics(beforeResults, afterResults);
}
}
public async Task <Response> GetListSuggestedBooks(int userID)
{
var relatedList = PythonHelper.GetSuggestedBooks(userID);
return(await bookBal.GetListSuggestedBooks(relatedList));
}
/// <summary>
/// 执行Python。通过source和是否存在文件自动判别执行类型
/// 如果是文件（.py结尾）
/// 首先在Script目录下寻找.py源文件名，再在数据库ResourceInfo中寻找
/// 再在Script目录下寻找单个.py编译成的同名Assembly。
/// 如果还找不到，则在工作目录下找"PythonScript.dll，执行对应方法。
/// 在.py文件中，执行的是execute方法（如果带当前窗口参数，参数是masterForm)
/// 如果不是，则按照Statement执行。
/// </summary>
/// <param name="source"></param>
/// <param name="processParams"></param>
/// <returns></returns>
public static object TryExecutePython(string source, Dictionary <string, object> processParams)
{
try
{
if (source.EndsWith(".py", StringComparison.InvariantCulture))
{
string filePath = ServiceProvider.GetService <IApplicationDirectory>().GetLocalResourcePath(source);
if (System.IO.File.Exists(filePath))
{
return(PythonHelper.ExecutePythonFile(filePath, processParams));
}
else
{
ResourceContent pythonResource = ResourceInfoHelper.ResolveResource(source, ResourceType.PythonSource);
if (pythonResource != null)
{
switch (pythonResource.Type)
{
case ResourceContentType.File:
return(PythonHelper.ExecutePythonFile(pythonResource.Content.ToString(), processParams));
case ResourceContentType.String:
return(PythonHelper.ExecutePythonStatement(pythonResource.Content.ToString(), processParams));
default:
throw new NotSupportedException("Invalid Resource Content Type!");
}
}
else
{
string singleAssemblyPath = System.IO.Path.ChangeExtension(filePath, ".dll");
if (System.IO.File.Exists(singleAssemblyPath))
{
return(PythonHelper.ExecutePythonAssembly(singleAssemblyPath, System.IO.Path.GetFileName(filePath), processParams));
}
else
{
string combileAssemblyPath = System.IO.Path.Combine(ServiceProvider.GetService <IApplicationDirectory>().GetMainDirectory(), s_pythonCompiledAssembly);
if (System.IO.File.Exists(combileAssemblyPath))
{
return(PythonHelper.ExecutePythonAssembly(combileAssemblyPath, System.IO.Path.GetFileName(filePath), processParams));
}
else
{
return(null);
}
}
}
}
}
else
{
if (source.Contains("result = "))
{
return(PythonHelper.ExecutePythonStatement(source, processParams));
}
else
{
return(PythonHelper.ExecutePythonExpression(source, processParams));
}
}
}
catch (Exception ex)
{
throw new ArgumentException(string.Format("Python source {0} is invalid!", source), ex);
}
}
public void SemanticsTest()
{
BenchmarkSuiteInstanceProvider prov = new BenchmarkSuiteListInstanceProvider();
var prob = new CFGPythonProblem();
prob.Load(prov.LoadData(prov.GetDataDescriptors().First(x => x.Name == "Smallest")));
var grammar = prob.Grammar;
var root = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode();
root.SetGrammar(grammar.CreateExpressionTreeGrammar());
//var root = new SymbolicExpressionTreeNode(new ProgramRootSymbol());
var start = new SymbolicExpressionTreeNode(new StartSymbol());
root.AddSubtree(start);
var gstart = new SymbolicExpressionTreeNode(grammar.StartSymbol);
start.AddSubtree(gstart);
var predefined = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'i0 = int(); i1 = int(); i2 = int()'\r\n'b0 = bool(); b1 = bool(); b2 = bool()'\r\n'res0 = int()'\r\n<code>"));
gstart.AddSubtree(predefined);
var codestatementSym = GetSymbol(grammar, "<code><statement>'\\n'");
var code0 = new SymbolicExpressionTreeNode(codestatementSym);
var code1 = new SymbolicExpressionTreeNode(codestatementSym);
var code2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<statement>'\\n'"));
//predefined.AddSubtree(code1);
predefined.AddSubtree(code0);
code0.AddSubtree(code1);
code1.AddSubtree(code2);
var assign0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<assign>"));
var assign1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<assign>"));
code2.AddSubtree(assign0);
//code0.AddSubtree(assign1);
var if0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<if>"));
code1.AddSubtree(if0);
var bool_assign0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_var>' = '<bool>"));
var int_assign1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<int_var>' = '<int>"));
assign0.AddSubtree(bool_assign0);
assign1.AddSubtree(int_assign1);
var bool_var0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_var>"));
var int_var1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<int_var>"));
var b0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'b0'"));
var i1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'res0'"));
bool_assign0.AddSubtree(bool_var0);
int_assign1.AddSubtree(int_var1);
bool_var0.AddSubtree(b0);
int_var1.AddSubtree(i1);
var bool_const0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_const>"));
var int_const1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'int('<number>'.0)'"));
//var num0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<num>"));
var num1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<num>"));
var boolconstTrue = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'True'"));
var intconst2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'2'"));
bool_assign0.AddSubtree(bool_const0);
int_assign1.AddSubtree(int_const1);
bool_const0.AddSubtree(boolconstTrue);
int_const1.AddSubtree(num1);
num1.AddSubtree(intconst2);
var ifthenelse0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'if '<bool>':{:\\n'<code>':}else:{:\\n'<code>':}'"));
var b0_2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'b0'"));
if0.AddSubtree(ifthenelse0);
ifthenelse0.AddSubtree(b0_2);
var statement1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<statement>'\\n'"));
var assign2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<assign>"));
var int_assign2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<int_var>' = '<int>"));
var i1_2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'res0'"));
var intconst7 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'7'"));
ifthenelse0.AddSubtree(statement1);
statement1.AddSubtree(assign2);
assign2.AddSubtree(int_assign2);
int_assign2.AddSubtree(i1_2);
int_assign2.AddSubtree(intconst7);
var statement2 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<statement>'\\n'"));
var assign3 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<assign>"));
var int_assign3 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<int_var>' = '<int>"));
var i1_3 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'res0'"));
var intconst8 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'9'"));
ifthenelse0.AddSubtree(statement2);
statement2.AddSubtree(assign3);
assign3.AddSubtree(int_assign3);
int_assign3.AddSubtree(i1_3);
int_assign3.AddSubtree(intconst8);
var while0 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'loopBreak% = 0\\nwhile '<bool>':{:\\n'<code>'\\nif loopBreak% > loopBreakConst or stop.value:{:\\nbreak\\n:}loopBreak% += 1\\n:}'"));
var b0_3 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'b0'"));
var code4 = new SymbolicExpressionTreeNode(codestatementSym);
var statement3 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<statement>'\\n'"));
var bool_assign1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_var>' = '<bool>"));
var bool_var1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_var>"));
var b0_4 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'b0'"));
var bool_const1 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<bool_const>"));
var boolconstFalse = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'False'"));
bool_assign1.AddSubtree(bool_var1);
bool_var1.AddSubtree(b0_4);
bool_assign1.AddSubtree(bool_const1);
bool_const1.AddSubtree(boolconstFalse);
statement3.AddSubtree(bool_assign1);
//var statement4 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<statement>'\\n'"));
var assign4 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<assign>"));
var int_assign4 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "<int_var>' = '<int>"));
var i1_4 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'res0'"));
var intconst9 = new SymbolicExpressionTreeNode(GetSymbol(grammar, "'1'"));
//statement4.AddSubtree(assign4);
assign4.AddSubtree(int_assign4);
int_assign4.AddSubtree(i1_4);
int_assign4.AddSubtree(intconst9);
code4.AddSubtree(statement3);
code4.AddSubtree(assign4);
((List <string>)((CFGProduction)while0.Symbol).parts)[0] = "x = 5\n" + ((List <string>)((CFGProduction)while0.Symbol).parts)[0];
while0.AddSubtree(b0_3);
while0.AddSubtree(code4);
code0.AddSubtree(while0);
var tree = new SymbolicExpressionTree(root);
var code = CFGSymbolicExpressionTreeStringFormatter.StaticFormat(tree);
System.Console.WriteLine(code);
//PythonProcessSemanticHelper ppsh = new PythonProcessSemanticHelper(prob.ProblemData.Variables.GetVariableNames(), 10);
traceCodeWithVariables = String.Format(traceCode, String.Join("', '", prob.ProblemData.Variables.GetVariableNames().Where(x => !String.IsNullOrWhiteSpace(x))), 10);
var bla = PythonHelper.FormatToProgram(tree, prob.ProblemData.LoopBreakConst, prob.ProblemData.FullHeader, prob.ProblemData.FullFooter);
// var blub = ppsh.EvaluateAndTraceProgram(prob.PythonProcess,
var blub = EvaluateAndTraceProgram(prob.PythonProcess,
bla,
PythonHelper.ConvertToPythonValues(prob.ProblemData.Input, prob.ProblemData.TrainingIndices),
PythonHelper.ConvertToPythonValues(prob.ProblemData.Output, prob.ProblemData.TrainingIndices),
prob.ProblemData.TrainingIndices, prob.ProblemData.FullHeader, prob.ProblemData.FullFooter, tree);
Console.WriteLine(blub);
}
