Update jupyter integration

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 val dataforgeVersion: String by extra("0.6.2")
-val visionforgeVersion by extra("0.3.0-dev-10")
+val visionforgeVersion by extra("0.3.0-dev-14")
 val ktorVersion: String by extra(space.kscience.gradle.KScienceVersions.ktorVersion)
 val rsocketVersion by extra("0.15.4")
 val xodusVersion by extra("2.0.1")

controls-jupyter/build.gradle.kts

@@ -0,0 +1,19 @@
+plugins {
+    id("space.kscience.gradle.mpp")
+}
+
+val visionforgeVersion: String by rootProject.extra
+
+kscience {
+    fullStack("js/controls-jupyter.js")
+    useKtor()
+    useContextReceivers()
+    jupyterLibrary()
+    dependencies {
+        implementation(projects.controlsVision)
+        implementation("space.kscience:visionforge-jupyter:$visionforgeVersion")
+    }
+    jvmMain {
+        implementation(spclibs.logback.classic)
+    }
+}

controls-jupyter/src/jsMain/kotlin/commonJupyter.kt

@@ -0,0 +1,14 @@
+import space.kscience.visionforge.jupyter.VFNotebookClient
+import space.kscience.visionforge.markup.MarkupPlugin
+import space.kscience.visionforge.plotly.PlotlyPlugin
+import space.kscience.visionforge.runVisionClient
+
+public fun main(): Unit = runVisionClient {
+//    plugin(DeviceManager)
+//    plugin(ClockManager)
+    plugin(PlotlyPlugin)
+    plugin(MarkupPlugin)
+//    plugin(TableVisionJsPlugin)
+    plugin(VFNotebookClient)
+}
+

controls-jupyter/src/jvmMain/kotlin/ControlsJupyter.kt

@@ -0,0 +1,71 @@
+import org.jetbrains.kotlinx.jupyter.api.declare
+import org.jetbrains.kotlinx.jupyter.api.libraries.resources
+import space.kscience.controls.manager.ClockManager
+import space.kscience.controls.manager.DeviceManager
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.plotly.Plot
+import space.kscience.tables.Table
+import space.kscience.visionforge.jupyter.VisionForge
+import space.kscience.visionforge.jupyter.VisionForgeIntegration
+import space.kscience.visionforge.markup.MarkupPlugin
+import space.kscience.visionforge.plotly.PlotlyPlugin
+import space.kscience.visionforge.plotly.asVision
+import space.kscience.visionforge.tables.toVision
+import space.kscience.visionforge.visionManager
+
+
+@OptIn(DFExperimental::class)
+public class ControlsJupyter : VisionForgeIntegration(CONTEXT.visionManager) {
+
+    override fun Builder.afterLoaded(vf: VisionForge) {
+
+        resources {
+            js("controls-jupyter") {
+                classPath("js/controls-jupyter.js")
+            }
+        }
+
+        onLoaded {
+            declare("context" to CONTEXT)
+        }
+
+        import(
+            "kotlin.time.*",
+            "kotlin.time.Duration.Companion.milliseconds",
+            "kotlin.time.Duration.Companion.seconds",
+            "space.kscience.tables.*",
+            "space.kscience.dataforge.meta.*",
+            "space.kscience.dataforge.context.*",
+            "space.kscience.plotly.*",
+            "space.kscience.plotly.models.*",
+            "space.kscience.visionforge.plotly.*",
+            "space.kscience.controls.manager.*",
+            "space.kscience.controls.constructor.*",
+            "space.kscience.controls.vision.*",
+            "space.kscience.controls.spec.*"
+        )
+
+        render<Table<*>> { table ->
+            vf.produceHtml {
+                vision { table.toVision() }
+            }
+        }
+
+        render<Plot> { plot ->
+            vf.produceHtml {
+                vision { plot.asVision() }
+            }
+        }
+    }
+
+    public companion object {
+        private val CONTEXT: Context = Context("controls-jupyter") {
+            plugin(DeviceManager)
+            plugin(ClockManager)
+            plugin(PlotlyPlugin)
+//            plugin(TableVisionPlugin)
+            plugin(MarkupPlugin)
+        }
+    }
+}

controls-server/build.gradle.kts

@@ -1,7 +1,7 @@
 import space.kscience.gradle.Maturity
 
 plugins {
-    id("space.kscience.gradle.jvm")
+    id("space.kscience.gradle.mpp")
     `maven-publish`
 }
 
@@ -12,16 +12,20 @@ description = """
 val dataforgeVersion: String by rootProject.extra
 val ktorVersion: String by rootProject.extra
 
-dependencies {
+
-    implementation(projects.controlsCore)
+kscience {
-    implementation(projects.controlsPortsKtor)
+    jvm()
-    implementation(projects.magix.magixServer)
+    dependencies {
-    implementation("io.ktor:ktor-server-cio:$ktorVersion")
+        implementation(projects.controlsCore)
-    implementation("io.ktor:ktor-server-websockets:$ktorVersion")
+        implementation(projects.controlsPortsKtor)
-    implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
+        implementation(projects.magix.magixServer)
-    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
+        implementation("io.ktor:ktor-server-cio:$ktorVersion")
-    implementation("io.ktor:ktor-server-html-builder:$ktorVersion")
+        implementation("io.ktor:ktor-server-websockets:$ktorVersion")
-    implementation("io.ktor:ktor-server-status-pages:$ktorVersion")
+        implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
+        implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
+        implementation("io.ktor:ktor-server-html-builder:$ktorVersion")
+        implementation("io.ktor:ktor-server-status-pages:$ktorVersion")
+    }
 }
 
 readme{

controls-vision/build.gradle.kts

@@ -7,7 +7,7 @@ description = """
     Dashboard and visualization extensions for devices
 """.trimIndent()
 
-val visionforgeVersion = "0.3.0-dev-10"
+val visionforgeVersion: String by rootProject.extra
 
 kscience {
     fullStack("js/controls-vision.js")

demo/constructor/src/jvmMain/kotlin/main.kt

@@ -42,7 +42,7 @@ class LinearDrive(
 }
 
 
-public fun main() {
+fun main() {
     val context = Context {
         plugin(DeviceManager)
         plugin(PlotlyPlugin)

demo/notebooks/constructor.ipynb

@@ -0,0 +1,162 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "USE(ControlsJupyter())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "class LinearDrive(\n",
+    "    context: Context,\n",
+    "    state: DoubleRangeState,\n",
+    "    mass: Double,\n",
+    "    pidParameters: PidParameters,\n",
+    "    meta: Meta = Meta.EMPTY,\n",
+    ") : DeviceConstructor(context.request(DeviceManager), meta) {\n",
+    "\n",
+    "    val drive by device(VirtualDrive.factory(mass, state))\n",
+    "    val pid by device(PidRegulator(drive, pidParameters))\n",
+    "\n",
+    "    val start by device(LimitSwitch.factory(state.atStartState))\n",
+    "    val end by device(LimitSwitch.factory(state.atEndState))\n",
+    "\n",
+    "\n",
+    "    val position by property(state)\n",
+    "    var target by mutableProperty(pid.mutablePropertyAsState(Regulator.target, 0.0))\n",
+    "}\n"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "import kotlin.time.Duration.Companion.milliseconds\n",
+    "import kotlin.time.Duration.Companion.seconds\n",
+    "\n",
+    "val state = DoubleRangeState(0.0, -5.0..5.0)\n",
+    "\n",
+    "val pidParameters = PidParameters(\n",
+    "    kp = 2.5,\n",
+    "    ki = 0.0,\n",
+    "    kd = -0.1,\n",
+    "    timeStep = 0.005.seconds\n",
+    ")\n",
+    "\n",
+    "val device = context.install(\"device\", LinearDrive(context, state, 0.005, pidParameters)).apply {\n",
+    "    val clock = context.clock\n",
+    "    val clockStart = clock.now()\n",
+    "    doRecurring(10.milliseconds) {\n",
+    "        val timeFromStart = clock.now() - clockStart\n",
+    "        val t = timeFromStart.toDouble(DurationUnit.SECONDS)\n",
+    "        val freq = 0.1\n",
+    "\n",
+    "        target = 5 * sin(2.0 * PI * freq * t) +\n",
+    "                sin(2 * PI * 21 * freq * t + 0.02 * (timeFromStart / pidParameters.timeStep))\n",
+    "    }\n",
+    "}"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "val maxAge = 10.seconds\n",
+    "\n",
+    "\n",
+    "VisionForge.fragment {\n",
+    "    vision {\n",
+    "        plotly {\n",
+    "            plotNumberState(context, state, maxAge = maxAge) {\n",
+    "                name = \"real position\"\n",
+    "            }\n",
+    "            plotDeviceProperty(device.pid, Regulator.position.name, maxAge = maxAge) {\n",
+    "                name = \"read position\"\n",
+    "            }\n",
+    "\n",
+    "            plotDeviceProperty(device.pid, Regulator.target.name, maxAge = maxAge) {\n",
+    "                name = \"target\"\n",
+    "            }\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    vision {\n",
+    "        plotly {\n",
+    "            plotDeviceProperty(device.start, LimitSwitch.locked.name, maxAge = maxAge) {\n",
+    "                name = \"start measured\"\n",
+    "                mode = ScatterMode.markers\n",
+    "            }\n",
+    "            plotDeviceProperty(device.end, LimitSwitch.locked.name, maxAge = maxAge) {\n",
+    "                name = \"end measured\"\n",
+    "                mode = ScatterMode.markers\n",
+    "            }\n",
+    "        }\n",
+    "    }\n",
+    "}"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "device.stop()"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Kotlin",
+   "language": "kotlin",
+   "name": "kotlin"
+  },
+  "language_info": {
+   "name": "kotlin",
+   "version": "1.9.0",
+   "mimetype": "text/x-kotlin",
+   "file_extension": ".kt",
+   "pygments_lexer": "kotlin",
+   "codemirror_mode": "text/x-kotlin",
+   "nbconvert_exporter": ""
+  },
+  "ktnbPluginMetadata": {
+   "projectDependencies": [
+    "controls-kt.controls-jupyter.jvmMain"
+   ]
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

gradle.properties

@@ -4,10 +4,7 @@ kotlin.native.ignoreDisabledTargets=true
 
 org.gradle.parallel=true
 
-publishing.github=false
-publishing.sonatype=false
-
 org.gradle.configureondemand=true
 org.gradle.jvmargs=-Xmx4096m
 
-toolsVersion=0.15.0-kotlin-1.9.20-RC2
+toolsVersion=0.15.0-kotlin-1.9.20

settings.gradle.kts

@@ -52,6 +52,7 @@ include(
     ":controls-storage:controls-xodus",
     ":controls-constructor",
     ":controls-vision",
+    ":controls-jupyter",
     ":magix",
     ":magix:magix-api",
     ":magix:magix-server",