Operators to extend interactivity with python objects

src/Bonsai.Scripting.Python/Args.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections;
+using System.Reactive.Linq;
+using Pythonnet = Python.Runtime;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Reflection;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that takes a sequence of python objects and converts them to a type of PyTuple to pass as arguments to a function.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class Args
+    {
+        public IObservable<Pythonnet.PyTuple> Process(IObservable<object> source)
+        {
+            return source.Select(obj =>
+            {
+                using (Pythonnet.Py.GIL())
+                {
+                    if (!(obj is ITuple || obj is IList || obj is Array))
+                    {
+                        if (obj is Pythonnet.PyObject pyObj)
+                        {
+                            return new Pythonnet.PyTuple(new Pythonnet.PyObject[] {pyObj});
+                        }
+
+                        return new Pythonnet.PyTuple(new Pythonnet.PyObject[] {Pythonnet.PyObject.FromManagedObject(obj)});
+                    }
+
+                    PropertyInfo[] properties = obj.GetType().GetProperties();
+                    Pythonnet.PyObject[] pyObjects = new Pythonnet.PyObject[properties.Length];
+
+                    for (int i = 0; i < properties.Length; i++)
+                    {
+                        object value = properties[i].GetValue(obj, null);
+
+                        if (!(value is Pythonnet.PyObject))
+                        {
+                            throw new ArgumentException($"All elements of the tuple must be of type PyObject. Instead, found {value.GetType()} for Item{i+1}.");
+                        }
+
+                        pyObjects[i] = (Pythonnet.PyObject)value;
+                    }
+                    return new Pythonnet.PyTuple(pyObjects);
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/EnvironmentConfig.cs

@@ -26,17 +26,14 @@ public EnvironmentConfig(string pythonHome, string pythonVersion)
 
         public static EnvironmentConfig FromConfigFile(string configFileName)
         {
-            var config = new EnvironmentConfig();
-            config.Path = System.IO.Path.GetDirectoryName(configFileName);
+            var config = new EnvironmentConfig
+            {
+                Path = System.IO.Path.GetDirectoryName(configFileName)
+            };
             using var configReader = new StreamReader(File.OpenRead(configFileName));
             while (!configReader.EndOfStream)
             {
                 var line = configReader.ReadLine();
-                static string GetConfigValue(string line)
-                {
-                    var parts = line.Split('=');
-                    return parts.Length > 1 ? parts[1].Trim() : string.Empty;
-                }
 
                 if (line.StartsWith("home"))
                 {
@@ -59,5 +56,11 @@ static string GetConfigValue(string line)
 
             return config;
         }
+
+        private static string GetConfigValue(string line)
+        {
+            var parts = line.Split('=');
+            return parts.Length > 1 ? parts[1].Trim() : string.Empty;
+        }
     }
 }

src/Bonsai.Scripting.Python/GetAttr.cs

@@ -0,0 +1,40 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Reactive.Linq;
+using Python.Runtime;
+using System.Xml.Serialization;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that gets an attribute from a python object if the attribute exists.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class GetAttr
+    {
+        [Description("The name of the attribute to get.")]
+        public string Attribute { get; set; }
+
+        public IObservable<PyObject> Process(IObservable<PyObject> source)
+        {
+            if (string.IsNullOrEmpty(Attribute))
+            {
+                throw new Exception("Attribute cannot be null or empty.");
+            }
+            return source.Select(obj =>
+            {
+                using (Py.GIL())
+                {
+                    if (!obj.HasAttr(Attribute))
+                    {
+                        throw new Exception($"PyObject does not have attribute {Attribute}.");
+                    }
+                    return obj.GetAttr(Attribute);
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/GetItem.cs

@@ -0,0 +1,44 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Reactive.Linq;
+using Python.Runtime;
+using System.Xml.Serialization;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that gets an item from a generic python iterable using either a numbered index, or a string key.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class GetItem
+    {
+        [Description("The index to get.")]
+        public int? Index { get; set; } = null;
+
+        [Description("The key to get.")]
+        public string Key { get; set; } = null;
+
+        public IObservable<PyObject> Process(IObservable<PyObject> source)
+        {
+            if (!(Index.HasValue ^ !string.IsNullOrEmpty(Key)))
+            {
+                throw new Exception("Either an index or a key must be provided.");
+            }
+
+            return source.Select(obj =>
+            {
+                using (Py.GIL())
+                {
+                    if (!obj.IsIterable())
+                    {
+                        throw new Exception($"PyObject is not iterable.");
+                    }
+                    return Index != null ? obj.GetItem(Index.Value) : obj.GetItem(Key);
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/GetPythonType.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Reactive.Linq;
+using Python.Runtime;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that gets the type of a python object. Equivalent to calling type(obj) in python.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class GetPythonType
+    {
+
+        public IObservable<PyObject> Process(IObservable<PyObject> source)
+        {
+            return source.Select(obj => 
+            {
+                using (Py.GIL())
+                {
+                    return obj.GetPythonType();
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/Import.cs

@@ -0,0 +1,59 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Reactive.Linq;
+using Python.Runtime;
+using System.Xml.Serialization;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that will import the name of a package as a user-defined named package into the input module.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class Import
+    {
+        [Description("The name of the package.")]
+        public string Package { get; set; }
+
+        [Description("The \"as name\" of the package. For example, in \"import numpy as np\", np is the as name.")]
+        public string AsName { get; set; }
+
+        public IObservable<PyObject> Process(IObservable<PyModule> source)
+        {
+            if (string.IsNullOrEmpty(Package))
+            {
+                throw new ArgumentException(nameof(Package), "A package must be specified.");
+            }
+            return source.Select(module => 
+            {
+                using (Py.GIL())
+                {
+                    if (!string.IsNullOrEmpty(AsName))
+                    {
+                        return module.Import(Package, AsName);
+                    }
+
+                    if (!Package.Contains('.'))
+                    {
+                        return module.Import(Package);
+                    }
+
+                    var packages = Package.Split('.');
+                    var packagePath = string.Empty;
+
+                    PyObject obj = null;
+                    for (int i = 0; i < packages.Length; i++)
+                    {
+                        packagePath = string.IsNullOrEmpty(packagePath) ? packages[i] : $"{packagePath}.{packages[i]}";
+                        obj = module.Import(packagePath);
+                    }
+
+                    return obj;
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/Invoke.cs

@@ -0,0 +1,42 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Reactive.Linq;
+using Pythonnet = Python.Runtime;
+using System.Xml.Serialization;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that will invoke a callable object and pass the given arguments to the call. The input can either be the callable object itself, or can be an object which has a named callable attribute.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class Invoke
+    {
+        [Description("The name of the callable object to invoke.")]
+        public string Callable { get; set; }
+
+        [XmlIgnore]
+        [Description("The args to pass to the callable.")]
+        public Pythonnet.PyTuple Args { get; set; } = null;
+
+        public IObservable<Pythonnet.PyObject> Process(IObservable<Pythonnet.PyObject> source)
+        {
+            return source.Select(obj =>
+            {
+                using (Pythonnet.Py.GIL())
+                {
+                    var callable = string.IsNullOrEmpty(Callable) ? obj : obj.GetAttr(Callable);
+                    if (!callable.IsCallable())
+                    {
+                        throw new Exception($"Cannot invoke callable: {callable} because it is not callable.");
+                    }
+                    var args = Args == null ? new Pythonnet.PyTuple() : Args;
+                    return callable.Invoke(args);
+                }
+            });
+        }
+    }
+}

src/Bonsai.Scripting.Python/InvokeMethod.cs

@@ -0,0 +1,43 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Reactive.Linq;
+using Pythonnet = Python.Runtime;
+using System.Xml.Serialization;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that will invoke a method of the object and pass the given arguments to the method.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Transform)]
+    public class InvokeMethod
+    {
+        [Description("The name of the method to invoke.")]
+        public string Method { get; set; }
+
+        [XmlIgnore]
+        [Description("The args to pass to the callable.")]
+        public Pythonnet.PyTuple Args { get; set; } = null;
+
+        public IObservable<Pythonnet.PyObject> Process(IObservable<Pythonnet.PyObject> source)
+        {
+            if (string.IsNullOrEmpty(Method))
+            {
+                throw new Exception("Method name cannot be null or empty.");
+            }
+
+            return source.Select(obj =>
+            {
+                using (Pythonnet.Py.GIL())
+                {
+                    var args = Args == null ? new Pythonnet.PyTuple() : Args;
+                    return obj.InvokeMethod(Method, args);
+                }
+            });
+        }
+
+    }
+}

src/Bonsai.Scripting.Python/PyFloat.cs

@@ -0,0 +1,42 @@
+using System;
+using System.ComponentModel;
+using System.Reactive.Linq;
+using Pythonnet = Python.Runtime;
+using System.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents the creation of a float python data type.
+    /// </summary>
+    [Combinator]
+    [WorkflowElementCategory(ElementCategory.Source)]
+    public class PyFloat
+    {
+
+        [Description("The value of the float.")]
+        public double Value { get; set; }
+
+        public IObservable<Pythonnet.PyFloat> Process()
+        {
+            return Observable.Defer(() =>
+            {
+                using (Pythonnet.Py.GIL())
+                {
+                    return Observable.Return(new Pythonnet.PyFloat(Value));
+                }
+            });
+        }
+
+        public IObservable<Pythonnet.PyFloat> Process<TSource>(IObservable<TSource> source)
+        {
+            return source.Select(obj =>
+            {
+                using (Pythonnet.Py.GIL())
+                {
+                    return new Pythonnet.PyFloat(Value);
+                }
+            });
+        }
+    }
+}