Direct rendering into DOM element.

I've been testing this package out and so far so amazing!

I'm consuming a Flow and when it completes I would like to stop the live server as there are no further updates to send. How can I get a reference to the ApplicationServer in order to stop it?

I'm using https://github.com/mipt-npm/plotly.kt/blob/master/examples/src/main/kotlin/complexDynamicServer.kt as the starting point, but as an example instead of doing while(true) on the flow producer I'm doing repeat(100)

Look here: https://github.com/Kotlin/kotlin-jupyter#supported-libraries and here: https://github.com/Kotlin/kotlin-jupyter#rich-output.

Add a renderer for plot object in a separate subproject.

trace{
  type = Type.histogram
  ...
}

convert to

histogram{
  ...
}

This is follow-up issue for #24.

Offline mode means that assets will be downloaded, stored in a separate folder and referenced from HTML files using relative path.

The problem is that current build generates an unnecessary gradle metadata file for plotlykt-server and it enforces use of java 11 in gradle 5.4+.

It will be fixed once we move to a common build plugin for all scientifik projects.

A workaround is to use nightly build from artifactory:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.3.40"
}

repositories {
    jcenter()
    maven("https://dl.bintray.com/mipt-npm/dataforge")
    maven("https://dl.bintray.com/mipt-npm/scientifik")
    maven("https://dl.bintray.com/kotlin/ktor/")
    maven("http://npm.mipt.ru:8081/artifactory/gradle-dev")
}

dependencies {
    implementation("scientifik:plotlykt-server:0.1.2-dev-1")
}

tasks.withType<KotlinCompile> {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Hi me again with another bug I'm afraid

0.3.0 fixes the issue raised in #51 however there remains a very similar issue, this time it is the textsList property that is not updated correctly, however I suspect the source of the issue is different as the data going through the websocket appears correct.

Repro based on the example one

import hep.dataforge.meta.invoke
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import kscience.plotly.Plotly
import kscience.plotly.models.Bar
import kscience.plotly.plot
import kscience.plotly.server.close
import kscience.plotly.server.pushUpdates
import kscience.plotly.server.serve
import kscience.plotly.server.show
import kotlin.random.Random


fun main() {
    val initialValue = (1..10).toList()

    val traces = (0..2).associate { i ->
        val name = "Series $i"

        name to Bar {
            x.strings = initialValue.map { "Column: $it" }
            y.numbers = initialValue
            textsList = initialValue.map { "Initial value of this datapoint is: ${it}"} // <-- LINE ADDED
            this.name = name
        }
    }

    val server = Plotly.serve(port = 3872) {

        //root level plots go to default page
        page { plotly ->
            plot(renderer = plotly) {
                traces(traces.values)
                layout {
                    title = "Other dynamic plot"
                    xaxis.title = "x axis name"
                    yaxis.title = "y axis name"
                }
            }
        }

        pushUpdates(100)       // start sending updates via websocket to the front-end
    }

    server.show()

    //Start pushing updates
    GlobalScope.launch {
        delay(1000)
        while (isActive) {
            repeat(10) { columnIndex ->
                repeat(3) { seriesIndex ->
                    delay(200)
                    traces["Series $seriesIndex"]?.let {bar->
                        println("Updating ${bar.name}, Column $columnIndex")
                        //TODO replace with dynamic data API
                        val yValues = bar.y.doubles
                        yValues[columnIndex] = Random.nextInt(0,100).toDouble()
                        bar.y.doubles = yValues
                        bar.textsList = yValues.map { "Updated value of this datapoint is: ${it}"} // <-- LINE ADDED
                    }
                }
            }
        }
    }

    println("Press Enter to close server")
    readLine()

    server.close()
}

See my two // <-- LINE ADDED comments for the diff.

When running this example you would expect the hover label to contain the text "Updated value of this datapoint is: ${it}" where it is the y value of that bar, however the value appears to be being set to the value of the first bar in that series always.

Dynamic updates collector is currently started on server start and could not be modified after. Need to find a way to start and stop updates on page show.

Requires #3

Add mathjax local/cdn optional header to plot pages.

Replace it by basic flex css.

As in this plotly behaviour.

This would be greatly helpful, as I can see no other way at the moment to display a map behind a set of coordinates. If there is such a method in PlotlyKt, please tell me and feel free to close the issue.

Thank you.

I get the warning:
warning workspace-aggregator-6ad3d204-022c-4712-bd57-40e22af0df44 > plotly.kt-plotlykt-core > [email protected]: no longer maintained

not sure if it is important or not.

As requested for example in #47 .

Right now some HTML file assets are loaded from the Internet.

I can implement solution for building self-contained HTML files for offline use.

https://github.com/plotly/orca

• JVM 11 requirement
• kotlin-logging workaround

Fix SciProgCentre/dataforge-core#8 and introduce Kotlin-friendly aliases for enums.

It seems ok with Plotly.js:

var data = [
  {
    x: ['giraffes'],
    y: [20],
    type: 'bar'
  }
];

Plotly.newPlot('myDiv', data);

https://codepen.io/zakhenry/pen/YzGPQMm

but not so with Plotly.kt

    val plot = Plotly.plot {
        bar {
            x("giraffes")
            y(20)
        }
    }
    plot.makeFile()

Requires #4 to properly use JavaFX tabs.

• scatter plot
• bar chart
• pie chart
• heatmap
• contour plot
• box plot
• violin plot
• histogram

If user is trying to export plot to /home/user/myproject/Plot.html but directory ~/myproject does not exists - we should create it instead of failing with exception.

https://github.com/Kotlin/dokka

We need that for embedding device property plots.

In order to use with dataforge-vis configuration editor.

Probably at first, use reflective generators for JVM only.

I have a Kotlin/JS for browser targeted program that builds fine how it is, until I add Plotlykt as a Gradle dependency. This causes one of my files, which contains Kotlinx Serialization, to fail to compile. I created an issue report for the Kotlinx Serialization repo first, but nothing suggests the issue is necessarily on that end.
Please see this issue for a detailed error:
Kotlin/kotlinx.serialization#1030
and this project for a reproducible error (contains everything from the Intellij project to the Build Script):
https://github.com/CaptainZidgel/Erroring_Project

I hope this finds you well, please let me know if there are any other details I can give you.

Wait for oshai/kotlin-logging#153 or drop kotlin-logging completely for native targets.

1. Version 0.1.2 is absent in bintray
2. Version 0.1.1 in bintray don't work with Java 1.8

Leave root scientifik.plotly package for core functionality, flatten the rest inside scientifik.plotly.models package.

Some additional functionality like geoscape could have its own packages.

• Appendable traces
• Fixed range traces
• Time series

Currently in many places the API looks like:

foo {
   param1 = 2
   param2 = "hello"
   ...
}

For example:

xaxis {
   name = "x axis name"
   mode = Mode.lines
}

The api would be easier to use if it was in this form:

xaxis = Axis(
   title = "sin"
   type= Type.`-`
)

There are a couple of upsides to this:

1. By looking at the function signature of xaxis{} you don't know what kind of configuration is available. Sometimes the available variables are not even in the same file as the builder.
   When having Axis() accept the parameters directly, they are available immediately in the call site with their default values, and will be shown by IntelliJ when you type the constructor.
2. With named parameters IntelliJ will nicely autocomplete all of the available parameters, unlike when using lambdas.
3. Having a function body implies you can do something other than assign variables, which is not true in many cases.
4. Calling the constructor of Foo is the natural way to create an object of type Foo, instead of some Foo.build{} function.

Places where passing parameters in receiver lambdas is still appropriate:

• When additional function calls are nested, like plot in Plotly.Page{} (title should still be a named parameter though), or trace in plot.

@altavir If you agree I would like to submit a PR to start improving the API in this direction.

Hey, I made a new Kotlin Multi Platform project with the following build.gradle:

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '1.3.40'
}
repositories {
    mavenCentral()
    maven { url "https://dl.bintray.com/mipt-npm/scientifik/"}
}
group 'com.example'
version '0.0.1'

apply plugin: 'maven-publish'

kotlin {
    jvm()
    js {
        browser {
        }
        nodejs {
        }
    }
    // For ARM, should be changed to iosArm32 or iosArm64
    // For Linux, should be changed to e.g. linuxX64
    // For MacOS, should be changed to e.g. macosX64
    // For Windows, should be changed to e.g. mingwX64
    mingwX64("mingw")
    sourceSets {
        commonMain {
            dependencies {
                implementation kotlin('stdlib-common')
                implementation "scientifik:plotlykt-core:0.1.1"
            }
        }
        commonTest {
            dependencies {
                implementation kotlin('test-common')
                implementation kotlin('test-annotations-common')
            }
        }
        jvmMain {
            dependencies {
                implementation kotlin('stdlib-jdk8')
            }
        }
        jvmTest {
            dependencies {
                implementation kotlin('test')
                implementation kotlin('test-junit')
            }
        }
        jsMain {
            dependencies {
                implementation kotlin('stdlib-js')
            }
        }
        jsTest {
            dependencies {
                implementation kotlin('test-js')
            }
        }
        mingwMain {
        }
        mingwTest {
        }
    }
}

Although trying to import scientifik.* does not compile.
I tried again in a gradle-jvm project:

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.3.40'
}

group 'plot'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
    maven { url "https://dl.bintray.com/mipt-npm/scientifik/"}
}

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    compile 'scientifik:plotlykt-core:0.1.1'
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

And still no luck.
If I change scientifik:plotlykt-core:0.1.1 to scientifik:plotlykt-core-jvm:0.1.1 it does work seems to work, but build failes.
Please explain how to use the library as a dependency.

TraceValues or something similar.

Generate schemes for plotly models and integrate JS property editor.

I running into some issue with the setup:

1. Try to use in Jupyter, based on the documentation I red, just copy the plotly.json and plotyly-server.json into my ..../run_kotlin_kernel/libraries folder then kotlin jupyter kernel should load it in. However I checked that it does not show up. (by type :help in my kotlin notebook, can not see those two libraries listed). I can not see any errors

2. Then I try to set up in my project and hope to get some clue what is going on, here are portion of my build.gradle.kts

plugins {
    java
    kotlin("jvm") version "1.4.0"
//    kotlin("plugin.serialization") version "1.4.0"
}

repositories {
    mavenCentral()
    jcenter()

    // for plotly.kt
    maven("https://dl.bintray.com/mipt-npm/dataforge")
    maven("https://dl.bintray.com/mipt-npm/kscience")
    maven("https://dl.bintray.com/mipt-npm/dev")
    maven("https://kotlin.bintray.com/kotlinx")
    maven("https://dl.bintray.com/kotlin/ktor")
}


dependencies {
    implementation(kotlin("stdlib-jdk8"))
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9")
    implementation("org.nield:kotlin-statistics:1.2.1")
    implementation("org.apache.commons:commons-collections4:4.4")
    implementation( "org.jetbrains.kotlin:kotlin-reflect:1.4.0" )

    implementation( "org.jetbrains.lets-plot-kotlin:lets-plot-kotlin-api:1.0.0")

    // for json support
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")
//    implementation("io.jhdf:jhdf:0.5.8")
    implementation("de.mpicbg.scicomp:krangl:0.13")
//    implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.0.0-RC") // JVM dependency

    // for plotly.kt
    implementation("scientifik:plotlykt-core:0.2.0")
    implementation("scientifik:plotlykt-server:0.2.0")


    testImplementation("org.junit.jupiter:junit-jupiter:5.6.0")

}

when I try to build, got following complain

Could not determine the dependencies of task ':jar'.
> Could not resolve all files for configuration ':runtimeClasspath'.
   > Could not find scientifik:plotlykt-core:0.2.0.
     Searched in the following locations:
       - https://repo.maven.apache.org/maven2/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://jcenter.bintray.com/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/dataforge/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/kscience/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/dev/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://kotlin.bintray.com/kotlinx/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
       - https://dl.bintray.com/kotlin/ktor/scientifik/plotlykt-core/0.2.0/plotlykt-core-0.2.0.pom
     Required by:
         project :
   > Could not find scientifik:plotlykt-server:0.2.0.
     Searched in the following locations:
       - https://repo.maven.apache.org/maven2/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://jcenter.bintray.com/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/dataforge/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/kscience/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://dl.bintray.com/mipt-npm/dev/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://kotlin.bintray.com/kotlinx/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
       - https://dl.bintray.com/kotlin/ktor/scientifik/plotlykt-server/0.2.0/plotlykt-server-0.2.0.pom
     Required by:
         project :

Possible solution:
 - Declare repository providing the artifact, see the documentation at https://docs.gradle.org/current/userguide/declaring_repositories.html

Include kotlinx-datetime and provide API to use it with TraceValues.

Allow template to use a custom library path instead of hardcoded one. Needed for #25.

Steps to reproduce:

Create multiple traces, and in dynamic server mode try to update the values of each trace. All values appear to be assigned to the first trace.

I've narrowed this down to Plot.collectUpdates

fun Plot.collectUpdates(plotId: String, scope: CoroutineScope, updateInterval: Long): Flow<Update> {
    return config.flowChanges(scope, updateInterval).flatMapMerge { change ->
        flow<Update> {
            change["layout"].node?.let { emit(Update.Layout(plotId, it)) }
            change.getIndexed("data").values.mapNotNull { it.node }.forEachIndexed { index, metaItem ->
                emit(Update.Trace(plotId, index, metaItem))
            }
        }
    }

The index param that is passed to Update.Trace is always 0. This appears to be because there needs to be another inner loop like metaItem.getIndexed to actually iterate through the traces.

The result of this is evident when inspecting the websocket messages, as I can see the json message field "trace" is always 0, despite having the data for each one of the traces that I am updating.

I must apologise, I'm very new to Kotlin so I'm not really sure how to raise a PR that I can test locally to verify my fix.

When I try to use a newer version of Plotly.kt (v0.3.0) in a Kotlin Jupyter notebook, it doesn't work due to the following error when trying to plot something:

Line_9.jupyter.kts (2:5 - 12) Cannot inline bytecode built with JVM target 11 into bytecode that is being built with JVM target 1.8. Please specify proper '-jvm-target' option
Line_9.jupyter.kts (3:5 - 11) Cannot inline bytecode built with JVM target 11 into bytecode that is being built with JVM target 1.8. Please specify proper '-jvm-target' option

I guess this error is caused by the fact that the Kotlin notebook kernel is compiled against version 1.8 while newer versions of Plotly.kt use JVM version 11 as build target.

Is there any known solution to make this combination working?

I've checked out the repo, imported it into Intellij as gradle project. When running the dynamicServer.kt, it starts up correctly, but the plot is missing:

Judging from the sources I'd expect some sinus/cosinus action to happen.

Create or adjust meta delegate for plotly types.

List of plotly types:

• data_array --- An {array} of data. The value MUST be an {array}, or we ignore it. Note that typed arrays (e.g. Float32Array) are supported.
• enumerated --- Enumerated value type. The available values are listed in values.
• boolean --- A boolean (true/false) value.
• number --- A number or a numeric value (e.g. a number inside a string). When applicable, values greater (less) than max (min) are coerced to the dflt.
• integer --- An integer or an integer inside a string. When applicable, values greater (less) than max (min) are coerced to the dflt.
• string --- A string value. Numbers are converted to strings except for attributes with strict set to true.
• color --- A string describing color. Supported formats: - hex (e.g. '#d3d3d3') - rgb (e.g. 'rgb(255, 0, 0)') - rgba (e.g. 'rgb(255, 0, 0, 0.5)') - hsl (e.g. 'hsl(0, 100%, 50%)') - hsv (e.g. 'hsv(0, 100%, 100%)') - named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)
• colorlist --- A list of colors. Must be an {array} containing valid colors.
• colorscale --- A Plotly colorscale either picked by a name: (any of Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis ) customized as an {array} of 2-element {arrays} where the first element is the normalized color level value (starting at 0 and ending at 1), and the second item is a valid color string.
• angle --- A number (in degree) between -180 and 180.
• subplotid --- An id string of a subplot type (given by dflt), optionally followed by an integer >1. e.g. if dflt='geo', we can have 'geo', 'geo2', 'geo3', ...
• flaglist --- A string representing a combination of flags (order does not matter here). Combine any of the available flags with +. (e.g. ('lines+markers')). Values in extras cannot be combined.
• any --- Any type.
• info_array --- An {array} of plot information.

Implement grid on client-side.

An error occurs if pass emptyList in trace.

Is it possible to add some text annotations to the plots? Probably similar to the following snippet:

  plt.plot(1, 8) {
        trace(trace)
        text { 
            x=0.4
            y=0.9
            text = "asdfsafdasfdasdf"
        }
        layout {
            title = plot_title
            xaxis { title = xlabel }
            yaxis { title = ylabel }
        }
    }

The project tag is jetbrains-reaearch. I think it should read "jetbrains-research."