public static CollisionObject FromPyCollisionObject(PyObject obj)
{
var frame = (string)PyConvert.ToClrObject(obj.GetAttr("frame_id"), typeof(string));
var primitives = (List <CollisionPrimitive>)PyConvert.ToClrObject(obj.GetAttr("primitives"), typeof(List <CollisionPrimitive>));
return(new CollisionObject(frame, primitives));
}
public static JointPath FromPyJointPath(PyObject obj)
{
var jointSet = (JointSet)PyConvert.ToClrObject(obj.GetAttr("joint_set"), typeof(JointSet));
var points = (List <JointValues>)PyConvert.ToClrObject(obj.GetAttr("points"), typeof(List <JointValues>));
return(new JointPath(jointSet, points));
}
public static JointValues FromPyJointValues(PyObject obj)
{
var jointSet = FromPyJointSet(obj.GetAttr("joint_set"));
var values = (A <double>)PyConvert.ToClrObject(obj.GetAttr("values"), typeof(A <double>));
return(new JointValues(jointSet, values));
}
public static HttpResponseLite GetFromPythonNET(string url)
{
if (!PythonEngine.IsInitialized)
{
PythonEngine.Initialize();
}
var sw = Stopwatch.StartNew();
var result = new HttpResponseLite();
try
{
// https://github.com/pythonnet/pythonnet/wiki/Threading
var mThreadState = PythonEngine.BeginAllowThreads();
using (Py.GIL())
{
dynamic cfscrape = Py.Import("cfscrape");
dynamic scraper = cfscrape.create_scraper();
PyObject response = scraper.get(url);
result.StatusCode = (HttpStatusCode)response.GetAttr("status_code").As <int>();
result.Html = response.GetAttr("text").As <string>();
result.ElapsedMs = sw.ElapsedMilliseconds;
}
PythonEngine.EndAllowThreads(mThreadState);
}
catch (Exception e)
{
result.ElapsedMs = sw.ElapsedMilliseconds;
result.Exception = e;
}
return(result);
}
public static JointStates FromPyJointStates(PyObject obj)
{
var positions = (JointValues)PyConvert.ToClrObject(obj.GetAttr("positions"), typeof(JointValues));
var velocities = (JointValues)PyConvert.ToClrObject(obj.GetAttr("velocities"), typeof(JointValues));
var efforts = (JointValues)PyConvert.ToClrObject(obj.GetAttr("efforts"), typeof(JointValues));
return(new JointStates(positions, velocities, efforts));
}
public static JointTrajectory FromPyJointTrajectory(PyObject obj)
{
var jointSet = (JointSet)PyConvert.ToClrObject(obj.GetAttr("joint_set"), typeof(JointSet));
var points = (List <JointTrajectoryPoint>)PyConvert.ToClrObject(obj.GetAttr("points"), typeof(List <JointTrajectoryPoint>));
var valid = (bool)PyConvert.ToClrObject(obj.GetAttr("is_valid"), typeof(bool));
return(new JointTrajectory(jointSet, points, valid));
}
public static TimeSpan FromPyTimeDelta(PyObject obj)
{
var days = (int)PyConvert.ToClrObject(obj.GetAttr("days"), typeof(int));
var seconds = (int)PyConvert.ToClrObject(obj.GetAttr("seconds"), typeof(int));
var microseconds = (int)PyConvert.ToClrObject(obj.GetAttr("microseconds"), typeof(int));
return(new TimeSpan((long)days * 864000000000 + (long)seconds * 10000000 + (long)microseconds * 10));
}
public static CollisionPrimitive FromPyCollisionPrimitive(PyObject obj)
{
var pyKind = obj.GetAttr("kind");
var kind = (CollisionPrimitiveKind)PyConvert.ToClrObject(pyKind.GetAttr("value"), typeof(int));
var parameters = (A <double>)PyConvert.ToClrObject(obj.GetAttr("parameters"), typeof(A <double>));
var pose = (Pose)PyConvert.ToClrObject(obj.GetAttr("pose"), typeof(Pose));
return(new CollisionPrimitive(kind, parameters.ToArray(), pose));
}
public static JointTrajectoryPoint FromPyJoinTrajectoryPoint(PyObject obj)
{
var timeFromStart = (TimeSpan)PyConvert.ToClrObject(obj.GetAttr("time_from_start"), typeof(TimeSpan));
var positions = (JointValues)PyConvert.ToClrObject(obj.GetAttr("positions"), typeof(JointValues));
var velocities = (JointValues)PyConvert.ToClrObject(obj.GetAttr("velocities"), typeof(JointValues));
var accelerations = (JointValues)PyConvert.ToClrObject(obj.GetAttr("accelerations"), typeof(JointValues));
var efforts = (JointValues)PyConvert.ToClrObject(obj.GetAttr("efforts"), typeof(JointValues));
return(new JointTrajectoryPoint(timeFromStart, positions, velocities, accelerations, efforts));
}
public static Pose FromPyPose(PyObject obj)
{
var t = (A <double>)PyConvert.ToClrObject(obj.GetAttr("translation"), typeof(A <double>));
var translationVector = new Vector3((float)t[0], (float)t[1], (float)t[2]);
var pyQuaternion = obj.GetAttr("quaternion");
var q = (A <double>)PyConvert.ToClrObject(pyQuaternion.GetAttr("elements"), typeof(A <double>));
var quaternion = new Quaternion((float)q[1], (float)q[2], (float)q[3], (float)q[0]);
var frame = (string)PyConvert.ToClrObject(obj.GetAttr("frame_id"), typeof(string));
return(new Pose(translationVector, quaternion, frame));
}
static PythonExtension()
{
using (Py.GIL())
{
PyObject module = Py.Import("builtins");
PyNone = module.GetAttr("None");
PyTrue = module.GetAttr("True");
PyBoolType = PyTrue.GetPythonType();
PySliceType = module.GetAttr("slice");
}
}
private void ConfigureModules()
{
PyObject sequentialModule = PythonEngine.ModuleFromString("sequential", "from keras.models import Sequential");
PyObject layersModule = PythonEngine.ModuleFromString("layers", "from keras.layers import Dense, Dropout");
dynamic Sequential = sequentialModule.GetAttr("Sequential");
this.keras = Py.Import("keras");
this.dropout = layersModule.GetAttr("Dropout");
this.denseLayer = layersModule.GetAttr("Dense");
this.model = Sequential();
}
private static object DecodeTime(PyObject py)
{
var result = new TimeSpan(
py.GetAttr("hour").As <int>(),
py.GetAttr("minute").As <int>(),
py.GetAttr("second").As <int>());
return(TimeSpan.FromTicks(
result.Ticks +
py.GetAttr("microsecond").As <int>() * 10));
}
/// <summary>
/// Get the indicator Name. If not defined, use the class name
/// </summary>
/// <param name="indicator">The python implementation of <see cref="IndicatorBase{IBaseDataBar}"/></param>
/// <returns>The indicator Name.</returns>
private static string GetIndicatorName(PyObject indicator)
{
using (Py.GIL())
{
var name = indicator.HasAttr("Name")
? indicator.GetAttr("Name")
: indicator.GetAttr("__class__").GetAttr("__name__");
return(name.GetAndDispose <string>());
}
}
public void Load()
{
if (Lock == null)
{
return;
}
using (Py.GIL())
{
Plugin = PythonEngine.ImportModule(File);
Plugin.InvokeMethod("Load");
Name = Plugin.GetAttr("Name").As <string>();
Explanation = Plugin.GetAttr("Explanation").As <string>();
}
}
/// <summary>
/// <see cref = "AlgorithmPythonWrapper"/> constructor.
/// Creates and wraps the algorithm written in python.
/// </summary>
/// <param name="module">Python module with the algorithm written in Python</param>
public AlgorithmPythonWrapper(PyObject module)
{
_algorithm = null;
try
{
using (Py.GIL())
{
if (!module.HasAttr("QCAlgorithm"))
{
return;
}
var baseClass = module.GetAttr("QCAlgorithm");
// Load module with util methods
_util = ImportUtil();
var moduleName = module.Repr().Split('\'')[1];
foreach (var name in module.Dir())
{
var attr = module.GetAttr(name.ToString());
if (attr.IsSubclass(baseClass) && attr.Repr().Contains(moduleName))
{
attr.SetAttr("OnPythonData", _util.GetAttr("OnPythonData"));
_algorithm = attr.Invoke();
// QCAlgorithm reference for LEAN internal C# calls (without going from C# to Python and back)
_baseAlgorithm = (QCAlgorithm)_algorithm;
// write events such that when the base handles an event it
// will also invoke event handlers defined on this instance
_baseAlgorithm.AlphasGenerated += AlphasGenerated;
// Set pandas
_baseAlgorithm.SetPandasConverter();
return;
}
}
}
}
catch (Exception e)
{
Logging.Log.Error(e);
}
}
private static object DecodeDateTime(PyObject py)
{
var utcDelta = TimeSpan.Zero;
var kind = DateTimeKind.Local;
var tz = py.GetAttr("tzinfo");
if (tz.HasAttr("utcoffset"))
{
kind = DateTimeKind.Utc;
utcDelta = py.InvokeMethod("utcoffset")
.DecodeTimeDelta();
}
var result = new DateTime(
py.GetAttr("year").As <int>(),
py.GetAttr("month").As <int>(),
py.GetAttr("day").As <int>(),
py.GetAttr("hour").As <int>(),
py.GetAttr("minute").As <int>(),
py.GetAttr("second").As <int>(),
kind);
return(result.AddTicks(-utcDelta.Ticks + py.GetAttr("microsecond").As <int>() * 10)
.ToLocalTime());
}
private void ConfigureModules()
{
PyObject SequentialModule = PythonEngine.ModuleFromString("sequential", "from keras.models import Sequential");
PyObject layersModule = PythonEngine.ModuleFromString("standardLayers", "from keras.layers import Dense, Dropout, Flatten");
PyObject layersCnnModule = PythonEngine.ModuleFromString("conEvoLayers", "from keras.layers import Conv2D, MaxPooling2D");
dynamic sequential = SequentialModule.GetAttr("Sequential");
this.model = sequential();
this.denseLayer = layersModule.GetAttr("Dense");
this.dropoutLayer = layersModule.GetAttr("Dropout");
this.flattenLayer = layersModule.GetAttr("Flatten");
this.convolutional2DLayer = layersCnnModule.GetAttr("Conv2D");
this.maxPooling2DLayer = layersCnnModule.GetAttr("MaxPooling2D");
}
/// <summary>
/// Sets the python implementation of the indicator
/// </summary>
/// <param name="indicator">The python implementation of <see cref="IndicatorBase{IBaseDataBar}"/></param>
public void SetIndicator(PyObject indicator)
{
using (Py.GIL())
{
foreach (var attributeName in new[] { "IsReady", "Update", "Value" })
{
if (!indicator.HasAttr(attributeName))
{
var name = indicator.GetAttr("__class__").GetAttr("__name__");
var message = $"Indicator.{attributeName} must be implemented. " +
$"Please implement this missing method in {name}";
if (attributeName == "IsReady")
{
message += " or use PythonIndicator as base:" +
$"{Environment.NewLine}class {name}(PythonIndicator):";
}
throw new NotImplementedException(message);
}
}
}
_indicator = indicator;
}
public bool TryDecode <T>(PyObject pyObj, out T value)
{
var message = pyObj.GetAttr("args")[0].As <string>();
value = (T)(object)new ValueErrorWrapper(message);
return(true);
}
public static PyObject _load_clr_module(PyObject spec)
{
using var modname = spec.GetAttr("name");
string name = modname.As <string?>() ?? throw new ArgumentException("name must not be None");
var mod = ImportHook.Import(name);
return(mod);
}
private PyList GetSysPaths()
{
// set sys paths
PyObject sys = PythonEngine.ImportModule("sys");
PyObject sysPathsObj = sys.GetAttr("path");
return(PyList.AsList(sysPathsObj));
}
/// <summary>
/// This method calls back into the CPython runtime - tests
/// call this from Python to check that we don't hang on
/// nested transitions from managed to Python code and back.
/// </summary>
public static string CallEchoString(string arg)
{
using (Py.GIL())
{
if (module == null)
{
module = PyModule.FromString("tt", testmod);
}
PyObject func = module.GetAttr("echostring");
var parg = new PyString(arg);
PyObject temp = func.Invoke(parg);
var result = (string)temp.AsManagedObject(typeof(string));
func.Dispose();
parg.Dispose();
temp.Dispose();
return(result);
}
}
public static IEnumerable <PyType> GetDecorators(PyObject func)
{
while (func.HasAttr("__func__"))
{
yield return(func.GetPythonType() as PyType);
func = func.GetAttr("__func__");
}
}
/// <summary>
/// <see cref = "AlgorithmPythonWrapper"/> constructor.
/// Creates and wraps the algorithm written in python.
/// </summary>
/// <param name="module">Python module with the algorithm written in Python</param>
public AlgorithmPythonWrapper(PyObject module)
{
_algorithm = null;
try
{
using (Py.GIL())
{
if (!module.HasAttr("QCAlgorithm"))
{
return;
}
var baseClass = module.GetAttr("QCAlgorithm");
// Load module with util methods
var onPythonData = Py.Import("AlgorithmPythonUtil").GetAttr("OnPythonData");
var moduleName = module.Repr().Split('\'')[1];
foreach (var name in module.Dir())
{
var attr = module.GetAttr(name.ToString());
if (attr.IsSubclass(baseClass) && attr.Repr().Contains(moduleName))
{
attr.SetAttr("OnPythonData", onPythonData);
_pyAlgorithm = attr.Invoke();
_algorithm = Impromptu.ActLike <IAlgorithm>(_pyAlgorithm);
// QCAlgorithm reference for LEAN internal C# calls (without going from C# to Python and back)
_baseAlgorithm = _algorithm.UndoActLike();
return;
}
}
}
}
catch (Exception e)
{
Logging.Log.Error(e);
}
}
// This method calls back into the CPython runtime - tests
// call this from Python to check that we don't hang on
// nested transitions from managed to Python code and back.
public static string CallEchoString(string arg)
{
IntPtr gs = PythonEngine.AcquireLock();
if (module == null)
{
module = PythonEngine.ModuleFromString("tt", testmod);
}
PyObject func = module.GetAttr("echostring");
PyString parg = new PyString(arg);
PyObject temp = func.Invoke(parg);
string result = (string)temp.AsManagedObject(typeof(String));
func.Dispose();
parg.Dispose();
temp.Dispose();
PythonEngine.ReleaseLock(gs);
return(result);
}
// from https://stackoverflow.com/questions/4601373/better-way-to-shuffle-two-numpy-arrays-in-unison
static void Shuffle <T1, T2>(ndarray <T1> array1, ndarray <T2> array2)
{
using var _ = Py.GIL();
var random = numPy.GetAttr("random");
var randomState = random.InvokeMethod("get_state");
random.InvokeMethod("shuffle", array1.PythonObject);
random.InvokeMethod("set_state", randomState);
random.InvokeMethod("shuffle", array2.PythonObject);
}
/// <summary>
/// Returns the type nam eof a Python object as a string.
/// </summary>
/// <param name="handle">Handle to the Pyhton object.</param>
/// <returns>Name of the Python object.</returns>
private static string GetPythonTypeName(IntPtr handle)
{
using (var excType = new PyObject(handle))
{
using (var typeName = excType.GetAttr("__name__"))
{
return(typeName.ToString());
}
}
}
public static PySignature GetSignature(PyScope scope, string functionName)
{
var s = new PySignature();
PyObject fn = scope.Get(functionName);
var inspect = Py.Import("inspect");
var signature = inspect.InvokeMethod("signature", fn);
var parameters = signature.GetAttr("parameters");
var keys = parameters.InvokeMethod("keys");
var argumentNames = new List <string>();
foreach (var key in keys.OfType <PyObject>())
{
var p = parameters[key];
var name = p.GetAttr("name").As <string>();
argumentNames.Add(name);
}
PyDict annotations = new PyDict(fn.GetAttr("__annotations__"));
foreach (var argumentName in argumentNames)
{
Type type;
if (annotations.HasKey(argumentName))
{
var pyType = annotations.GetItem(argumentName);
type = ToClrType(pyType);
}
else
{
type = typeof(object);
}
s.Arguments.Add(new PyArgument {
Name = argumentName, Type = type
});
}
Type returnType;
if (annotations.HasKey("return"))
{
var returnPyType = annotations.GetItem("return");
returnType = ToClrType(returnPyType);
}
else
{
returnType = typeof(object);
}
s.ReturnType = returnType;
return(s);
}
public void InheritedFromInheritedClassIsSelf()
{
using var scope = Py.CreateScope();
scope.Exec($"from {typeof(Inherited).Namespace} import {nameof(Inherited)}");
scope.Exec($"class B({nameof(Inherited)}): pass");
PyObject b = scope.Eval("B");
PyObject bInstance = b.Invoke();
PyObject bInstanceClass = bInstance.GetAttr("__class__");
Assert.IsTrue(PythonReferenceComparer.Instance.Equals(b, bInstanceClass));
}