Split expression and python scripting packages

Author: glopesdev

Bonsai.Scripting.Python/Bonsai.Scripting.Python.csproj

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <Title>Bonsai - Python Scripting Library</Title>
+    <Description>Bonsai Scripting Library containing Python scripting infrastructure for Bonsai.</Description>
+    <PackageTags>Bonsai Rx Scripting Python</PackageTags>
+    <TargetFramework>net462</TargetFramework>
+    <Version>2.7.0</Version>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="IronPython" Version="2.7.5" />
+    <PackageReference Include="IronPython.StdLib" Version="2.7.5" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Bonsai.Core\Bonsai.Core.csproj" />
+  </ItemGroup>
+</Project>

Bonsai.Scripting.Python/IScriptingElement.cs

@@ -0,0 +1,7 @@
+namespace Bonsai.Scripting.Python
+{
+    interface IScriptingElement : INamedElement
+    {
+        string Description { get; }
+    }
+}

Bonsai.Scripting.Python/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using Bonsai;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: XmlNamespacePrefix("clr-namespace:Bonsai.Scripting.Python", "py")]
+[assembly: WorkflowNamespaceIcon("Bonsai:ElementIcon.Scripting")]

Bonsai.Scripting.Python/Properties/launchSettings.json

@@ -0,0 +1,9 @@
+{
+  "profiles": {
+    "Bonsai": {
+      "commandName": "Executable",
+      "executablePath": "$(SolutionDir)Bonsai/bin/$(Configuration)/net472/Bonsai.exe",
+      "commandLineArgs": "--lib:$(TargetDir)."
+    }
+  }
+}

Bonsai.Scripting.Python/PythonCondition.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Linq;
+using System.ComponentModel;
+using System.Reactive.Linq;
+
+namespace Bonsai.Scripting.Python
+{
+    /// <summary>
+    /// Represents an operator that uses a Python script to filter the elements
+    /// of an observable sequence.
+    /// </summary>
+    [Obsolete]
+    [DefaultProperty(nameof(Script))]
+    [WorkflowElementCategory(ElementCategory.Condition)]
+    [Description("A Python script used to determine which elements of the input sequence are accepted.")]
+    public class PythonCondition : Combinator
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PythonCondition"/> class.
+        /// </summary>
+        public PythonCondition()
+        {
+            Script = "def process(value):\n  return True";
+        }
+
+        /// <summary>
+        /// Gets or sets the script that determines the criteria for the condition.
+        /// </summary>
+        [Editor("Bonsai.Scripting.Python.Design.PythonScriptEditor, Bonsai.Scripting.Python.Design", DesignTypes.UITypeEditor)]
+        [Description("The script that determines the criteria for the condition.")]
+        public string Script { get; set; }
+
+        /// <summary>
+        /// Uses a Python script to filter the elements of an observable sequence.
+        /// </summary>
+        /// <typeparam name="TSource">
+        /// The type of the elements in the <paramref name="source"/> sequence.
+        /// </typeparam>
+        /// <param name="source">
+        /// The observable sequence to filter.
+        /// </param>
+        /// <returns>
+        /// An observable sequence that contains the elements of the <paramref name="source"/>
+        /// sequence that satisfy the condition.
+        /// </returns>
+        public override IObservable<TSource> Process<TSource>(IObservable<TSource> source)
+        {
+            return Observable.Defer(() =>
+            {
+                var engine = PythonEngine.Create();
+                var scope = engine.CreateScope();
+                engine.Execute(Script, scope);
+
+                PythonProcessor<TSource, bool> processor;
+                if (PythonHelper.TryGetClass(scope, "Condition", out object condition))
+                {
+                    processor = new PythonProcessor<TSource, bool>(engine.Operations, condition);
+                }
+                else processor = new PythonProcessor<TSource, bool>(scope);
+
+                if (processor.Load != null)
+                {
+                    processor.Load();
+                }
+
+                var result = source.Where(processor.Process);
+                if (processor.Unload != null)
+                {
+                    result = result.Finally(processor.Unload);
+                }
+
+                return result;
+            });
+        }
+    }
+}

Bonsai.Scripting.Python/PythonEngine.cs

@@ -0,0 +1,23 @@
+using Microsoft.Scripting.Hosting;
+using System.IO;
+using System.Reflection;
+
+namespace Bonsai.Scripting.Python
+{
+    static class PythonEngine
+    {
+        internal static ScriptEngine Create()
+        {
+            var engine = IronPython.Hosting.Python.CreateEngine();
+            var basePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            var libPath = Directory.GetDirectories(Path.Combine(basePath, "../../../"), "IronPython.StdLib.*");
+            if (libPath.Length == 1)
+            {
+                var lib = Path.Combine(libPath[0], $"content/Lib");
+                var sitePackages = Path.Combine(lib, "site-packages");
+                engine.SetSearchPaths(new[] { lib, sitePackages });
+            }
+            return engine;
+        }
+    }
+}

Bonsai.Scripting.Python/PythonHelper.cs

@@ -0,0 +1,66 @@
+using IronPython.Runtime;
+using IronPython.Runtime.Types;
+using Microsoft.Scripting.Hosting;
+using System;
+
+namespace Bonsai.Scripting.Python
+{
+    static class PythonHelper
+    {
+        internal const string ReturnsDecorator = "import clr\ndef returns(type):\n  def decorator(func):\n    func.__returntype__ = clr.GetClrType(type)\n    return func\n  return decorator\n\n";
+        internal const string ReturnTypeAttribute = "__returntype__";
+        internal const string LoadFunction = "load";
+        internal const string UnloadFunction = "unload";
+        internal const string ProcessFunction = "process";
+        internal const string GenerateFunction = "generate";
+
+        internal static bool TryGetClass(ScriptScope scope, string className, out object pythonClass)
+        {
+            if (scope.TryGetVariable(className, out object variable))
+            {
+                pythonClass = variable as OldClass;
+                if (pythonClass != null)
+                {
+                    return true;
+                }
+
+                pythonClass = variable as PythonType;
+                return pythonClass != null;
+            }
+
+            pythonClass = null;
+            return false;
+        }
+
+        internal static Type GetOutputType(ObjectOperations op, object pythonClass, string methodName)
+        {
+            var function = (PythonFunction)op.GetMember<Method>(pythonClass, methodName).__func__;
+            if (function.func_dict.TryGetValue(ReturnTypeAttribute, out object returnType))
+            {
+                return (Type)returnType;
+            }
+
+            return typeof(object);
+        }
+
+        internal static Type GetOutputType(ScriptScope scope, string functionName)
+        {
+            var function = scope.GetVariable<PythonFunction>(functionName);
+            if (function.func_dict.TryGetValue(ReturnTypeAttribute, out object returnType))
+            {
+                return (Type)returnType;
+            }
+            else
+            {
+                if (scope.TryGetVariable("getOutputType", out Func<Type> getOutputType))
+                {
+                    return getOutputType();
+                }
+                else
+                {
+                    return typeof(object);
+                }
+            }
+        }
+    }
+}

Bonsai.Scripting.Python/PythonProcessor.cs

@@ -0,0 +1,37 @@
+using Microsoft.Scripting.Hosting;
+using System;
+
+namespace Bonsai.Scripting.Python
+{
+    class PythonProcessor<TSource, TResult>
+    {
+        internal PythonProcessor(ScriptScope scope)
+        {
+            scope.TryGetVariable(PythonHelper.LoadFunction, out Action load);
+            scope.TryGetVariable(PythonHelper.UnloadFunction, out Action unload);
+            Process = scope.GetVariable<Func<TSource, TResult>>(PythonHelper.ProcessFunction);
+            Load = load;
+            Unload = unload;
+        }
+
+        internal PythonProcessor(ObjectOperations op, object processorClass)
+        {
+            var processor = (object)op.CreateInstance(processorClass);
+            Process = op.GetMember<Func<TSource, TResult>>(processor, PythonHelper.ProcessFunction);
+            if (op.ContainsMember(processor, PythonHelper.UnloadFunction))
+            {
+                Unload = op.GetMember<Action>(processor, PythonHelper.UnloadFunction);
+            }
+            if (op.ContainsMember(processor, PythonHelper.LoadFunction))
+            {
+                Load = op.GetMember<Action>(processor, PythonHelper.LoadFunction);
+            }
+        }
+
+        internal Action Load { get; private set; }
+
+        internal Action Unload { get; private set; }
+
+        internal Func<TSource, TResult> Process { get; private set; }
+    }
+}