/// <summary>
/// Calls the specified function and assigns the result to this variable
/// </summary>
/// <param name="function"></param>
/// <param name="arguments"></param>
/// <param name="escapeMethod"></param>
/// <returns></returns>
public dynamic CallAssign(
PyFunction function,
List <object> arguments = null,
EscapeFlags escapeMethod = EscapeFlags.Quotes | EscapeFlags.StripNullItems,
PyVariable target = null
)
{
string argumentsText = "";
if (arguments != null)
{
List <string> textArguments = PythonInterop.EscapeArguments(arguments, escapeMethod);
argumentsText = string.Join(", ", textArguments);
}
if (target == null)
{
target = this;
}
PythonInterop.EvalToVar(target, "{0}({1})", new List <object> {
function.ToString(), argumentsText
}, EscapeFlags.None);
return(this.Value);
}
public PyVariable NewInstance(PyVariableFlags flags = PyVariableFlags.Object, List <object> arguments = null)
{
PyVariable instance = PyVariableManager.NewVariable(flags: flags);
instance.CallAssign(new PythonFunction(this.ClassName), arguments);
return(instance);
}
public dynamic CallFunction(
string function,
List <object> arguments = null,
EscapeFlags escapeMethod = EscapeFlags.Quotes | EscapeFlags.StripNullItems,
PyVariable target = null
)
{
return(CallFunction(PyFunction.ClassFunction(function), arguments, escapeMethod, target: target));
}
/// <summary>
/// Allocates a new variable
/// </summary>
/// <param name="variableName">Name of the variable to add</param>
/// <param name="isObject">Indicates the variable will store non-serializable data (like class instances)</param>
/// <returns>The newly added variable, or null if the variable already exists</returns>
public static PyVariable NewVariable(string variableName = null, PyVariableFlags flags = PyVariableFlags.Normal)
{
if (variableName == null)
{
variableName = "_var" + _variables.Count;
}
if (!_variables.ContainsKey(variableName))
{
PyVariable variable = new PyVariable(variableName, flags: flags);
_variables.Add(variableName, new WeakReference <PyVariable>(variable));
return(variable);
}
return(null);
}
public dynamic CallFunction(
PyFunction function,
string argumentsBody,
PyVariable target = null
)
{
if (target == null)
{
target = PyVariableManager.LastResult;
}
return((PythonInterop.EvalToVar(target, string.Format("{0}.{1}({2})",
this.PyName, function.Function, argumentsBody
))).Value);
}
public dynamic CallFunction(
PyFunction function,
List <object> arguments = null,
EscapeFlags escapeMethod = EscapeFlags.Quotes | EscapeFlags.StripNullItems,
PyVariable target = null
)
{
if (arguments == null)
{
arguments = new List <object>();
}
List <string> textArguments = PythonInterop.EscapeArguments(arguments, escapeMethod);
return(CallFunction(function, string.Join(", ", textArguments), target: target));
}
public PyVariable NewInstance(List <object> arguments = null)
{
PyVariable instance = PyVariableManager.Get.NewVariable();
List <object> args = new List <object>()
{
"self.bridge"
};
if (arguments != null)
{
args.AddRange(arguments);
}
return(instance.CallAssign(PyFunction.ClassFunction(this.ClassName), args));
}
public PyDict(PyVariable var)
{
Instance = var;
Instance.EvalAssign(EmptyDict);
}
public static void DestroyVariable(PyVariable variable)
{
DestroyVariable(variable.Name);
}
/// <summary>
/// Copies a Python variable to another by using an assignment (var_dest=var_src)
/// </summary>
/// <param name="dest"></param>
/// <param name="source"></param>
public static void CopyVariable(PyVariable dest, PyVariable source)
{
PythonInterop.EvalToVar(dest, source.PyName);
}
public void DeleteVariable(PyVariable pyVariable)
{
//pyVariable has absolute path here, dict['var']
variables.Remove(pyVariable.Basename);
}
public PyDict(PyVariable var)
{
Instance = var;
Instance.EvalAssign("{}");
}
