zeppelin-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From k..@apache.org
Subject svn commit: r1800231 [12/13] - in /zeppelin/site/docs/0.8.0-SNAPSHOT: ./ assets/themes/zeppelin/css/ assets/themes/zeppelin/js/ interpreter/ quickstart/
Date Thu, 29 Jun 2017 06:21:53 GMT
Modified: zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json
URL: http://svn.apache.org/viewvc/zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json?rev=1800231&r1=1800230&r2=1800231&view=diff
==============================================================================
--- zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json (original)
+++ zeppelin/site/docs/0.8.0-SNAPSHOT/search_data.json Thu Jun 29 06:21:53 2017
@@ -3,104 +3,214 @@
   
   
 
-    "/development/contribution/how_to_contribute_code.html": {
+    "/development/howtocontribute.html": {
       "title": "Contributing to Apache Zeppelin (Code)",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Contributing to Apache Zeppelin ( Code )NOTE : Apache Zeppelin is an Apache2 License Software.Any contributions to Zeppelin (Source code, Documents, Image, Website) means you agree with license all your contributions as Apache2 License.Setting upHere are some tools you will need to build and test Zeppelin.Software Configuration Management ( SCM )Since Zeppelin uses Git for it's SCM system, you need git client installed in y
 our development machine.Integrated Development Environment ( IDE )You are free to use whatever IDE you prefer, or your favorite command line editor.Build ToolsTo build the code, installOracle Java 7Apache MavenGetting the source codeFirst of all, you need Zeppelin source code. The official location of Zeppelin is http://git.apache.org/zeppelin.git.git accessGet the source code on your development machine using git.git clone git://git.apache.org/zeppelin.git zeppelinYou may also want to develop against a specific branch. For example, for branch-0.5.6git clone -b branch-0.5.6 git://git.apache.org/zeppelin.git zeppelinApache Zeppelin follows Fork & Pull as a source control workflow.If you want to not only build Zeppelin but also make any changes, then you need to fork Zeppelin github mirror repository and make a pull request.Before making a pull request, please take a look Contribution Guidelines.Buildmvn installTo skip testmvn install -DskipTestsTo build with specific spark / 
 hadoop versionmvn install -Dspark.version=x.x.x -Dhadoop.version=x.x.xFor the further Run Zeppelin server in development modecd zeppelin-serverHADOOP_HOME=YOUR_HADOOP_HOME JAVA_HOME=YOUR_JAVA_HOME mvn exec:java -Dexec.mainClass="org.apache.zeppelin.server.ZeppelinServer" -Dexec.args=""Note: Make sure you first run mvn clean install -DskipTests on your zeppelin root directory, otherwise your server build will fail to find the required dependencies in the local repro.or use daemon scriptbin/zeppelin-daemon startServer will be run on http://localhost:8080.Generating Thrift CodeSome portions of the Zeppelin code are generated by Thrift. For most Zeppelin changes, you don't need to worry about this. But if you modify any of the Thrift IDL files (e.g. zeppelin-interpreter/src/main/thrift/*.thrift), then you also need to regenerate these files and submit their updated version as part of your patch.To regenerate the code, install thrift-0.9.2 and 
 then run the following command to generate thrift code.cd <zeppelin_home>/zeppelin-interpreter/src/main/thrift./genthrift.shRun Selenium testZeppelin has set of integration tests using Selenium. To run these test, first build and run Zeppelin and make sure Zeppelin is running on port 8080. Then you can run test using following commandTEST_SELENIUM=true mvn test -Dtest=[TEST_NAME] -DfailIfNoTests=false -pl 'zeppelin-interpreter,zeppelin-zengine,zeppelin-server'For example, to run ParagraphActionIT,TEST_SELENIUM=true mvn test -Dtest=ParagraphActionsIT -DfailIfNoTests=false -pl 'zeppelin-interpreter,zeppelin-zengine,zeppelin-server'You'll need Firefox web browser installed in your development environment. While CI server uses Firefox 31.0 to run selenium test, it is good idea to install the same version (disable auto update to keep the version).Where to StartYou can find issues for beginner & newbieStay involvedContributors 
 should join the Zeppelin mailing lists.dev@zeppelin.apache.org is for people who want to contribute code to Zeppelin. subscribe, unsubscribe, archivesIf you have any issues, create a ticket in JIRA.",
-      "url": " /development/contribution/how_to_contribute_code.html",
-      "group": "development/contribution",
+      "url": " /development/howtocontribute.html",
+      "group": "development",
       "excerpt": "How can you contribute to Apache Zeppelin project? This document covers from setting up your develop environment to making a pull request on Github."
     }
     ,
     
   
 
-    "/development/contribution/how_to_contribute_website.html": {
+    "/development/howtocontributewebsite.html": {
       "title": "Contributing to Apache Zeppelin (Website)",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Contributing to Apache Zeppelin ( Website )This page will give you an overview of how to build and contribute to the documentation of Apache Zeppelin.The online documentation at zeppelin.apache.org is also generated from the files found here.NOTE : Apache Zeppelin is an Apache2 License Software.Any contributions to Zeppelin (Source code, Documents, Image, Website) means you agree with license all your contributions as Apache2 Licen
 se.Getting the source codeFirst of all, you need Zeppelin source code. The official location of Zeppelin is http://git.apache.org/zeppelin.git.Documentation website is hosted in 'master' branch under /docs/ dir.git accessFirst of all, you need the website source code. The official location of mirror for Zeppelin is http://git.apache.org/zeppelin.git.Get the source code on your development machine using git.git clone git://git.apache.org/zeppelin.gitcd docsApache Zeppelin follows Fork & Pull as a source control workflow.If you want to not only build Zeppelin but also make any changes, then you need to fork Zeppelin github mirror repository and make a pull request.BuildYou'll need to install some prerequisites to build the code. Please check Build documentation section in docs/README.md.Run website in development modeWhile you're modifying website, you might want to see preview of it. Please check Run website section in docs/README.md.Then you&a
 mp;#39;ll be able to access it on http://localhost:4000 with your web browser.Making a Pull RequestWhen you are ready, just make a pull-request.Alternative wayYou can directly edit .md files in /docs/ directory at the web interface of github and make pull-request immediately.Stay involvedContributors should join the Zeppelin mailing lists.dev@zeppelin.apache.org is for people who want to contribute code to Zeppelin. subscribe, unsubscribe, archivesIf you have any issues, create a ticket in JIRA.",
-      "url": " /development/contribution/how_to_contribute_website.html",
-      "group": "development/contribution",
+      "url": " /development/howtocontributewebsite.html",
+      "group": "development",
       "excerpt": "How can you contribute to Apache Zeppelin project website? This document covers from building Zeppelin documentation site to making a pull request on Github."
     }
     ,
     
   
 
-    "/development/contribution/useful_developer_tools.html": {
-      "title": "Useful Developer Tools",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Useful Developer ToolsDeveloping zeppelin-webCheck zeppelin-web: Local Development.ToolsSVM: Scala Version Managersvm would be useful when changing scala version frequently.JDK change script: OSXthis script would be helpful when changing JDK version frequently.function setjdk() {  if [ $# -ne 0 ]; then  # written based on OSX.   # use diffrent base path for other OS  removeFromPath '/System/Library/Frameworks/JavaVM.framewo
 rk/Home/bin'  if [ -n "${JAVA_HOME+x}" ]; then    removeFromPath $JAVA_HOME  fi  export JAVA_HOME=`/usr/libexec/java_home -v $@`  export PATH=$JAVA_HOME/bin:$PATH  fi}function removeFromPath() {  export PATH=$(echo $PATH | sed -E -e "s;:$1;;" -e "s;$1:?;;")}you can use this function like setjdk 1.8 / setjdk 1.7Building Submodules Selectively# build `zeppelin-web` onlymvn clean -pl 'zeppelin-web' package -DskipTests;# build `zeppelin-server` and its dependencies onlymvn clean package -pl 'spark,spark-dependencies,python,markdown,zeppelin-server' --am -DskipTests# build spark related modules with default profiles: scala 2.10 mvn clean package -pl 'spark,spark-dependencies,zeppelin-server' --am -DskipTests# build spark related modules with profiles: scala 2.11, spark 2.1 hadoop 2.7 ./dev/change_scala_version.sh 2.11mvn clean package -Pspark-2.1 -Phadoop-2.7 -Pscala-2.11 -pl &am
 p;#39;spark,spark-dependencies,zeppelin-server' --am -DskipTests# build `zeppelin-server` and `markdown` with dependenciesmvn clean package -pl 'markdown,zeppelin-server' --am -DskipTestsRunning Individual Tests# run the `HeliumBundleFactoryTest` test classmvn test -pl 'zeppelin-server' --am -DfailIfNoTests=false -Dtest=HeliumBundleFactoryTestRunning Selenium TestsMake sure that Zeppelin instance is started to execute integration tests (= selenium tests).# run the `SparkParagraphIT` test classTEST_SELENIUM="true" mvn test -pl 'zeppelin-server' --am -DfailIfNoTests=false -Dtest=SparkParagraphIT# run the `testSqlSpark` test function only in the `SparkParagraphIT` class# but note that, some test might be dependent on the previous testsTEST_SELENIUM="true" mvn test -pl 'zeppelin-server' --am -DfailIfNoTests=false -Dtest=SparkParagraphIT#testSqlSpark",
-      "url": " /development/contribution/useful_developer_tools.html",
-      "group": "development/contribution",
-      "excerpt": ""
-    }
-    ,
-    
-  
-
-    "/development/helium/overview.html": {
-      "title": "Helium",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Helium OverviewWhat is Helium?Helium is a plugin system that can extend Zeppelin a lot. For example, you can write custom display system or install already published one in Heliun Online Registry. Currently, Helium supports 4 types of package.Helium Visualization: Adding a new chart typeHelium Spell: Adding new interpreter, display system running on browserHelium Application Helium Interpreter: Adding a new custom interpreter",
-      "url": " /development/helium/overview.html",
-      "group": "development/helium",
-      "excerpt": ""
+    "/development/writingzeppelinapplication.html": {
+      "title": "Writing a new Application",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a new ApplicationWhat is Apache Zeppelin ApplicationApache Zeppelin Application is a package that runs on Interpreter process and displays it's output inside of the notebook. While application runs on Interpreter process, it's able to access resources provided by Interpreter through ResourcePool. Output is always rendered by AngularDisplaySystem. Therefore application provides all the possiblities of making 
 interactive graphical application that uses data and processing power of any Interpreter.Make your own ApplicationWriting Application means extending org.apache.zeppelin.helium.Application. You can use your favorite IDE and language while Java class files are packaged into jar. Application class looks like/** * Constructor. Invoked when application is loaded */public Application(ApplicationContext context);/** * Invoked when there're (possible) updates in required resource set. * i.e. invoked after application load and after paragraph finishes. */public abstract void run(ResourceSet args);/** * Invoked before application unload. * Application is automatically unloaded with paragraph/notebook removal */public abstract void unload();You can check example applications under ./zeppelin-examples directory.Development modeIn the development mode, you can run your Application in your IDE as a normal java application and see the result inside of Zeppelin notebook.org.apache.zeppelin
 .helium.ZeppelinApplicationDevServer can run Zeppelin Application in development mode.// entry point for development modepublic static void main(String[] args) throws Exception {  // add resources for development mode  LocalResourcePool pool = new LocalResourcePool("dev");  pool.put("date", new Date());  // run application in devlopment mode with given resource  // in this case, Clock.class.getName() will be the application class name    org.apache.zeppelin.helium.ZeppelinApplicationDevServer devServer = new org.apache.zeppelin.helium.ZeppelinApplicationDevServer(    Clock.class.getName(), pool.getAll());  // start development mode  devServer.start();  devServer.join();}In the Zeppelin notebook, run %dev run will connect to application running in development mode.Package filePackage file is a json file that provides information about the application.Json file contains the following information{  "name" : "[organization].
 [name]",  "description" : "Description",  "artifact" : "groupId:artifactId:version",  "className" : "your.package.name.YourApplicationClass",  "resources" : [    ["resource.name", ":resource.class.name"],    ["alternative.resource.name", ":alternative.class.name"]  ],  "icon" : "<i class='icon'></i>"}nameName is a string in [group].[name] format.[group] and [name] allow only [A-Za-z0-9_].Group is normally the name of an organization who creates this application.descriptionA short description about the applicationartifactLocation of the jar artifact."groupId:artifactId:version" will load artifact from maven repository.If jar exists in the local filesystem, absolute/relative can be use
 d.e.g.When artifact exists in Maven repositoryartifact: "org.apache.zeppelin:zeppelin-examples:0.6.0"When artifact exists in the local filesystemartifact: "zeppelin-example/target/zeppelin-example-0.6.0.jar"classNameEntry point. Class that extends org.apache.zeppelin.helium.ApplicationresourcesTwo dimensional array that defines required resources by name or by className. Helium Application launcher will compare resources in the ResourcePool with the information in this field and suggest application only when all required resources are available in the ResourcePool.Resouce name is a string which will be compared with the name of objects in the ResourcePool. className is a string with ":" prepended, which will be compared with className of the objects in the ResourcePool.Application may require two or more resources. Required resources can be listed inside of the json array. For example, if the application requires object &quot
 ;name1", "name2" and "className1" type of object to run, resources field can beresources: [  [ "name1", "name2", ":className1", ...]]If Application can handle alternative combination of required resources, alternative set can be listed as below.resources: [  [ "name", ":className"],  [ "altName", ":altClassName1"],  ...]Easier way to understand this scheme isresources: [   [ 'resource' AND 'resource' AND ... ] OR   [ 'resource' AND 'resource' AND ... ] OR   ...]iconIcon to be used on the application button. String in this field will be rendered as a HTML tag.e.g.icon: "<i class='fa fa-clock-o'></i>"",
+      "url": " /development/writingzeppelinapplication.html",
+      "group": "development",
+      "excerpt": "Apache Zeppelin Application is a package that runs on Interpreter process and displays it's output inside of the notebook. Make your own Application in Apache Zeppelin is quite easy."
     }
     ,
     
   
 
-    "/development/helium/writing_application.html": {
-      "title": "Writing a new Helium Application",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a new ApplicationWhat is Apache Zeppelin ApplicationApache Zeppelin Application is a package that runs on Interpreter process and displays it's output inside of the notebook. While application runs on Interpreter process, it's able to access resources provided by Interpreter through ResourcePool. Output is always rendered by AngularDisplaySystem. Therefore application provides all the possiblities of making 
 interactive graphical application that uses data and processing power of any Interpreter.Make your own ApplicationWriting Application means extending org.apache.zeppelin.helium.Application. You can use your favorite IDE and language while Java class files are packaged into jar. Application class looks like/** * Constructor. Invoked when application is loaded */public Application(ApplicationContext context);/** * Invoked when there're (possible) updates in required resource set. * i.e. invoked after application load and after paragraph finishes. */public abstract void run(ResourceSet args);/** * Invoked before application unload. * Application is automatically unloaded with paragraph/notebook removal */public abstract void unload();You can check example applications under ./zeppelin-examples directory.Development modeIn the development mode, you can run your Application in your IDE as a normal java application and see the result inside of Zeppelin notebook.org.apache.zeppelin
 .helium.ZeppelinApplicationDevServer can run Zeppelin Application in development mode.// entry point for development modepublic static void main(String[] args) throws Exception {  // add resources for development mode  LocalResourcePool pool = new LocalResourcePool("dev");  pool.put("date", new Date());  // run application in devlopment mode with given resource  // in this case, Clock.class.getName() will be the application class name    org.apache.zeppelin.helium.ZeppelinApplicationDevServer devServer = new org.apache.zeppelin.helium.ZeppelinApplicationDevServer(    Clock.class.getName(), pool.getAll());  // start development mode  devServer.start();  devServer.join();}In the Zeppelin notebook, run %dev run will connect to application running in development mode.Package filePackage file is a json file that provides information about the application.Json file contains the following information{  "name" : "[organization].
 [name]",  "description" : "Description",  "artifact" : "groupId:artifactId:version",  "className" : "your.package.name.YourApplicationClass",  "resources" : [    ["resource.name", ":resource.class.name"],    ["alternative.resource.name", ":alternative.class.name"]  ],  "icon" : "<i class='icon'></i>"}nameName is a string in [group].[name] format.[group] and [name] allow only [A-Za-z0-9_].Group is normally the name of an organization who creates this application.descriptionA short description about the applicationartifactLocation of the jar artifact."groupId:artifactId:version" will load artifact from maven repository.If jar exists in the local filesystem, absolute/relative can be use
 d.e.g.When artifact exists in Maven repositoryartifact: "org.apache.zeppelin:zeppelin-examples:0.6.0"When artifact exists in the local filesystemartifact: "zeppelin-example/target/zeppelin-example-0.6.0.jar"classNameEntry point. Class that extends org.apache.zeppelin.helium.ApplicationresourcesTwo dimensional array that defines required resources by name or by className. Helium Application launcher will compare resources in the ResourcePool with the information in this field and suggest application only when all required resources are available in the ResourcePool.Resouce name is a string which will be compared with the name of objects in the ResourcePool. className is a string with ":" prepended, which will be compared with className of the objects in the ResourcePool.Application may require two or more resources. Required resources can be listed inside of the json array. For example, if the application requires object &quot
 ;name1", "name2" and "className1" type of object to run, resources field can beresources: [  [ "name1", "name2", ":className1", ...]]If Application can handle alternative combination of required resources, alternative set can be listed as below.resources: [  [ "name", ":className"],  [ "altName", ":altClassName1"],  ...]Easier way to understand this scheme isresources: [   [ 'resource' AND 'resource' AND ... ] OR   [ 'resource' AND 'resource' AND ... ] OR   ...]iconIcon to be used on the application button. String in this field will be rendered as a HTML tag.e.g.icon: "<i class='fa fa-clock-o'></i>"",
-      "url": " /development/helium/writing_application.html",
-      "group": "development/helium",
-      "excerpt": "Apache Zeppelin Application is a package that runs on Interpreter process and displays it's output inside of the notebook. Make your own Application in Apache Zeppelin is quite easy."
+    "/development/writingzeppelininterpreter.html": {
+      "title": "Writing a New Interpreter",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a New InterpreterWhat is Apache Zeppelin InterpreterApache Zeppelin Interpreter is a language backend. For example to use scala code in Zeppelin, you need a scala interpreter.Every Interpreters belongs to an InterpreterGroup.Interpreters in the same InterpreterGroup can reference each other. For example, SparkSqlInterpreter can reference SparkInterpreter to get SparkContext from it while they're in the same group.In
 terpreterSetting is configuration of a given InterpreterGroup and a unit of start/stop interpreter.All Interpreters in the same InterpreterSetting are launched in a single, separate JVM process. The Interpreter communicates with Zeppelin engine via Thrift.In 'Separate Interpreter(scoped / isolated) for each note' mode which you can see at the Interpreter Setting menu when you create a new interpreter, new interpreter instance will be created per note. But it still runs on the same JVM while they're in the same InterpreterSettings.Make your own InterpreterCreating a new interpreter is quite simple. Just extend org.apache.zeppelin.interpreter abstract class and implement some methods.You can include org.apache.zeppelin:zeppelin-interpreter:[VERSION] artifact in your build system. And you should put your jars under your interpreter directory with a specific directory name. Zeppelin server reads interpreter directories recursively and initializes interpreters inc
 luding your own interpreter.There are three locations where you can store your interpreter group, name and other information. Zeppelin server tries to find the location below. Next, Zeppelin tries to find interpreter-setting.json in your interpreter jar.{ZEPPELIN_INTERPRETER_DIR}/{YOUR_OWN_INTERPRETER_DIR}/interpreter-setting.jsonHere is an example of interpreter-setting.json on your own interpreter.[  {    "group": "your-group",    "name": "your-name",    "className": "your.own.interpreter.class",    "properties": {      "properties1": {        "envName": null,        "propertyName": "property.1.name",        "defaultValue": "propertyDefaultValue",        "description": "Property description"      },      "p
 roperties2": {        "envName": PROPERTIES_2,        "propertyName": null,        "defaultValue": "property2DefaultValue",        "description": "Property 2 description"      }, ...    },    "editor": {      "language": "your-syntax-highlight-language",      "editOnDblClick": false    }  },  {    ...  }]Finally, Zeppelin uses static initialization with the following:static {  Interpreter.register("MyInterpreterName", MyClassName.class.getName());}Static initialization is deprecated and will be supported until 0.6.0.The name will appear later in the interpreter name option box during the interpreter configuration process.The name of the interpreter is what you later write to identify a paragraph which should be interpreted using this interpreter.%MyInterpreterNamesome interpreter
  specific code...Editor setting for InterpreterYou can add editor object to interpreter-setting.json file to specify paragraph editor settings.LanguageIf the interpreter uses a specific programming language (like Scala, Python, SQL), it is generally recommended to add a syntax highlighting supported for that to the note paragraph editor.To check out the list of languages supported, see the mode-*.js files under zeppelin-web/bower_components/ace-builds/src-noconflict or from github.com/ajaxorg/ace-builds.If you want to add a new set of syntax highlighting,  Add the mode-*.js file to zeppelin-web/bower.json (when built, zeppelin-web/src/index.html will be changed automatically).Add language field to editor object. Note that if you don't specify language field, your interpreter will use plain text mode for syntax highlighting. Let's say you want to set your language to java, then add:"editor": {  "language": "java"}E
 dit on double clickIf your interpreter uses mark-up language such as markdown or HTML, set editOnDblClick to true so that text editor opens on pargraph double click and closes on paragraph run. Otherwise set it to false."editor": {  "editOnDblClick": false}Install your interpreter binaryOnce you have built your interpreter, you can place it under the interpreter directory with all its dependencies.[ZEPPELIN_HOME]/interpreter/[INTERPRETER_NAME]/Configure your interpreterTo configure your interpreter you need to follow these steps:Add your interpreter class name to the zeppelin.interpreters property in conf/zeppelin-site.xml.Property value is comma separated [INTERPRETER_CLASS_NAME].For example,<property><name>zeppelin.interpreters</name><value>org.apache.zeppelin.spark.SparkInterpreter,org.apache.zeppelin.spark.PySparkInterpreter,org.apache.zeppelin.spark.SparkSqlInterpreter,org.apache.zeppeli
 n.spark.DepInterpreter,org.apache.zeppelin.markdown.Markdown,org.apache.zeppelin.shell.ShellInterpreter,org.apache.zeppelin.hive.HiveInterpreter,com.me.MyNewInterpreter</value></property>Add your interpreter to the default configuration which is used when there is no zeppelin-site.xml.Start Zeppelin by running ./bin/zeppelin-daemon.sh start.In the interpreter page, click the +Create button and configure your interpreter properties.Now you are done and ready to use your interpreter.Note : Interpreters released with zeppelin have a default configuration which is used when there is no conf/zeppelin-site.xml.Use your interpreter0.5.0Inside of a note, %[INTERPRETER_NAME] directive will call your interpreter.Note that the first interpreter configuration in zeppelin.interpreters will be the default one.For example,%myintpval a = "My interpreter"println(a)0.6.0 and laterInside of a note, %[INTERPRETER_GROUP].[INTERPRETER_NAME] directive will cal
 l your interpreter.You can omit either [INTERPRETER_GROUP] or [INTERPRETER_NAME]. If you omit [INTERPRETER_NAME], then first available interpreter will be selected in the [INTERPRETER_GROUP].Likewise, if you skip [INTERPRETER_GROUP], then [INTERPRETER_NAME] will be chosen from default interpreter group.For example, if you have two interpreter myintp1 and myintp2 in group mygrp, you can call myintp1 like%mygrp.myintp1codes for myintp1and you can call myintp2 like%mygrp.myintp2codes for myintp2If you omit your interpreter name, it'll select first available interpreter in the group ( myintp1 ).%mygrpcodes for myintp1You can only omit your interpreter group when your interpreter group is selected as a default group.%myintp2codes for myintp2ExamplesCheckout some interpreters released with Zeppelin by default.sparkmarkdownshelljdbcContributing a new Interpreter to Zeppelin releasesWe welcome contribution to a new interpreter. Please follow these few steps:First, check out the gene
 ral contribution guide here.Follow the steps in Make your own Interpreter section and Editor setting for Interpreter above.Add your interpreter as in the Configure your interpreter section above; also add it to the example template zeppelin-site.xml.template.Add tests! They are run by Travis for all changes and it is important that they are self-contained.Include your interpreter as a module in pom.xml.Add documentation on how to use your interpreter under docs/interpreter/. Follow the Markdown style as this example. Make sure you list config settings and provide working examples on using your interpreter in code boxes in Markdown. Link to images as appropriate (images should go to docs/assets/themes/zeppelin/img/docs-img/). And add a link to your documentation in the navigation menu (docs/_includes/themes/zeppelin/_navigation.html).Most importantly, ensure licenses of the transitive closure of all dependencies are list in license file.Commit your changes and open a Pull Request on 
 the project Mirror on GitHub; check to make sure Travis CI build is passing.",
+      "url": " /development/writingzeppelininterpreter.html",
+      "group": "development",
+      "excerpt": "Apache Zeppelin Interpreter is a language backend. Every Interpreters belongs to an InterpreterGroup. Interpreters in the same InterpreterGroup can reference each other."
     }
     ,
     
   
 
-    "/development/helium/writing_spell.html": {
-      "title": "Writing a new Helium Spell",
+    "/development/writingzeppelinspell.html": {
+      "title": "Writing a new Spell",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a new SpellWhat is Apache Zeppelin SpellSpell is a kind of interpreter that runs on browser not on backend. So, technically it's the frontend interpreter.It can provide many benefits.Spell is pluggable frontend interpreter. So it can be installed and removed easily using helium registry.Every spell is written in javascript. It means you can use existing javascript libraries whatever you want.Spell runs on browser li
 ke display system (%html, %table). In other words, every spell can be used as display system as well.How it worksHelium Spell works like Helium Visualization.Every helium packages are loaded from central (online) registry or local registryYou can see loaded packages in /helium page.When you enable a spell, it's built from server and sent to clientFinally it will be loaded into browser.How to use spell1. EnablingFind a spell what you want to use in /helium package and click Enable button.2. UsingSpell works like an interpreter. Use the MAGIC value to execute spell in a note. (you might need to refresh after enabling)For example, Use %echo for the Echo Spell.Write a new SpellMaking a new spell is similar to Helium Visualization#write-new-visualization.Add framework dependency called zeppelin-spell into package.jsonWrite code using frameworkPublish your spell to npm1. Create a npm packageCreate a package.json in new directory for spell.You have to add a framework called zeppeli
 n-spell as a dependency to create spell (zeppelin-spell)Also, you can add any dependencies you want to utilise.Here's an example{  "name": "zeppelin-echo-spell",  "description": "Zeppelin Echo Spell (example)",  "version": "1.0.0",  "main": "index",  "author": "",  "license": "Apache-2.0",  "dependencies": {    "zeppelin-spell": "*"  },  "helium": {    "icon" : "<i class='fa fa-repeat'></i>",    "spell": {      "magic": "%echo",      "usage": "%echo <TEXT>"    }  }}2. Write spell using frameworkHere are some exa
 mples you can referEcho SpellMarkdown Spell: Using libraryFlowchart Spell: Using DOMGoogle Translation API Spell: Using API (returning promise)Now, you need to write code to create spell which processing text.import {    SpellBase,    SpellResult,    DefaultDisplayType,} from 'zeppelin-spell';export default class EchoSpell extends SpellBase {    constructor() {        /** pass magic to super class's constructor parameter */        super("%echo");    }    interpret(paragraphText) {        const processed = paragraphText + '!';        /**         * should return `SpellResult` which including `data` and `type`         * default type is `TEXT` if you don't specify.           */        return new SpellResult(processed);    }}Here is another example. Let's say we want to create markdown spell. First of all, we should add a dependency for markdown in package.json// package.json "dependencies": {    
 "markdown": "0.5.0",    "zeppelin-spell": "*"  },And here is spell code.import {    SpellBase,    SpellResult,    DefaultDisplayType,} from 'zeppelin-spell';import md from 'markdown';const markdown = md.markdown;export default class MarkdownSpell extends SpellBase {    constructor() {        super("%markdown");    }    interpret(paragraphText) {        const parsed = markdown.toHTML(paragraphText);        /**         * specify `DefaultDisplayType.HTML` since `parsed` will contain DOM         * otherwise it will be rendered as `DefaultDisplayType.TEXT` (default)         */        return new SpellResult(parsed, DefaultDisplayType.HTML);    }}You might want to manipulate DOM directly (e.g google d3.js), then refer Flowchart SpellYou might want to return promise not string (e.g API call), then refer Google Translation API Spell3. Create Helium package file for local 
 deploymentYou don't want to publish your package every time you make a change in your spell. Zeppelin provides local deploy.The only thing you need to do is creating a Helium Package file (JSON) for local deploy.It's automatically created when you publish to npm repository but in local case, you should make it by yourself.{  "type" : "SPELL",  "name" : "zeppelin-echo-spell",  "version": "1.0.0",  "description" : "Return just what receive (example)",  "artifact" : "./zeppelin-examples/zeppelin-example-spell-echo",  "license" : "Apache-2.0",  "spell": {    "magic": "%echo",    "usage": "%echo <TEXT>"  }}Place this file in your local registry directory (de
 fault $ZEPPELIN_HOME/helium).type should be SPELLMake sure that artifact should be same as your spell directory.You can get information about other fields in Helium Visualization#3-create-helium-package-file-and-locally-deploy.4. Run in dev modecd zeppelin-webyarn run dev:heliumYou can browse localhost:9000. Every time refresh your browser, Zeppelin will rebuild your spell and reload changes.5. Publish your spell to the npm repositorySee Publishing npm packages",
-      "url": " /development/helium/writing_spell.html",
-      "group": "development/helium",
+      "url": " /development/writingzeppelinspell.html",
+      "group": "development",
       "excerpt": "Spell is a kind of interpreter that runs on browser not on backend. So, technically it's the frontend interpreter. "
     }
     ,
     
   
 
-    "/development/helium/writing_visualization_basic.html": {
-      "title": "Writing a new Helium Visualization: basic",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a new VisualizationWhat is Apache Zeppelin VisualizationApache Zeppelin Visualization is a pluggable package that can be loaded/unloaded on runtime through Helium framework in Zeppelin. A Visualization is a javascript npm package and user can use them just like any other built-in visualization in notebook.How it works1. Load Helium package files from registryZeppelin needs to know what Visualization packages are available. 
 Zeppelin will read information of packages from both online and local registry.Registries are configurable through ZEPPELIN_HELIUM_LOCALREGISTRY_DEFAULT env variable or zeppelin.helium.localregistry.default property.2. Enable packagesOnce Zeppelin loads Helium package files from registries, available packages are displayed in Helium menu.Click 'enable' button.3. Create and load visualization bundle on the flyOnce a Visualization package is enabled, HeliumBundleFactory creates a js bundle. The js bundle is served by helium/bundle/load rest api endpoint.4. Run visualizationZeppelin shows additional button for loaded Visualizations.User can use just like any other built-in visualizations.Write new Visualization1. Create a npm packageCreate a package.json in your new Visualization directory. You can add any dependencies in package.json, but you must include two dependencies: zeppelin-vis and zeppelin-tabledata.Here's an example{  "name": &qu
 ot;zeppelin_horizontalbar",  "description" : "Horizontal Bar chart",  "version": "1.0.0",  "main": "horizontalbar",  "author": "",  "license": "Apache-2.0",  "dependencies": {    "zeppelin-tabledata": "*",    "zeppelin-vis": "*"  }}2. Create your own visualizationTo create your own visualization, you need to create a js file and import Visualization class from zeppelin-vis package and extend the class. zeppelin-tabledata package provides some useful transformations, like pivot, you can use in your visualization. (you can create your own transformation, too).Visualization class, there're several methods that you need to override and implement. Here's simple visualization that just prints Hello 
 world.import Visualization from 'zeppelin-vis'import PassthroughTransformation from 'zeppelin-tabledata/passthrough'export default class helloworld extends Visualization {  constructor(targetEl, config) {    super(targetEl, config)    this.passthrough = new PassthroughTransformation(config);  }  render(tableData) {    this.targetEl.html('Hello world!')  }  getTransformation() {    return this.passthrough  }}To learn more about Visualization class, check visualization.js.You can check complete visualization package example here.Zeppelin's built-in visualization uses the same API, so you can check built-in visualizations as additional examples.3. Create Helium package file and locally deployHelium Package file is a json file that provides information about the application.Json file contains the following information{  "type" : "VISUALIZATION",  "name" : "zeppelin_hori
 zontalbar",  "description" : "Horizontal Bar chart (example)",  "license" : "Apache-2.0",  "artifact" : "./zeppelin-examples/zeppelin-example-horizontalbar",  "icon" : "<i class='fa fa-bar-chart rotate90flipX'></i>"}Place this file in your local registry directory (default ./helium).typeWhen you're creating a visualization, 'type' should be 'VISUALIZATION'. Check these types as well.Helium ApplicationHelium SpellnameName of visualization. Should be unique. Allows [A-Za-z90-9_].descriptionA short description about visualization.artifactLocation of the visualization npm package. Support npm package with version or local filesystem path.e.g.When artifact exists in npm repository"artifact": "my-visualiztion@1.0.0"When 
 artifact exists in local file system"artifact": "/path/to/my/visualization"licenseLicense information.e.g."license": "Apache-2.0"iconIcon to be used in visualization select button. String in this field will be rendered as a HTML tag.e.g."icon": "<i class='fa fa-coffee'></i>"4. Run in dev modePlace your Helium package file in local registry (ZEPPELIN_HOME/helium).Run Zeppelin. And then run zeppelin-web in visualization dev mode.cd zeppelin-webyarn run dev:heliumYou can browse localhost:9000. Everytime refresh your browser, Zeppelin will rebuild your visualization and reload changes.5. Publish your visualizationOnce it's done, publish your visualization package using npm publish.That's it. With in an hour, your visualization will be available in Zeppelin's helium menu.See MoreCheck Helium Visualization: Transfor
 mation for more complex examples.",
-      "url": " /development/helium/writing_visualization_basic.html",
-      "group": "development/helium",
+    "/development/writingzeppelinvisualization.html": {
+      "title": "Writing a new Visualization",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a new VisualizationWhat is Apache Zeppelin VisualizationApache Zeppelin Visualization is a pluggable package that can be loaded/unloaded on runtime through Helium framework in Zeppelin. A Visualization is a javascript npm package and user can use them just like any other built-in visualization in notebook.How it works1. Load Helium package files from registryZeppelin needs to know what Visualization packages are available. 
 Zeppelin will read information of packages from both online and local registry.Registries are configurable through ZEPPELIN_HELIUM_LOCALREGISTRY_DEFAULT env variable or zeppelin.helium.localregistry.default property.2. Enable packagesOnce Zeppelin loads Helium package files from registries, available packages are displayed in Helium menu.Click 'enable' button.3. Create and load visualization bundle on the flyOnce a Visualization package is enabled, HeliumBundleFactory creates a js bundle. The js bundle is served by helium/bundle/load rest api endpoint.4. Run visualizationZeppelin shows additional button for loaded Visualizations.User can use just like any other built-in visualizations.Write new Visualization1. Create a npm packageCreate a package.json in your new Visualization directory. You can add any dependencies in package.json, but you must include two dependencies: zeppelin-vis and zeppelin-tabledata.Here's an example{  "name": &qu
 ot;zeppelin_horizontalbar",  "description" : "Horizontal Bar chart",  "version": "1.0.0",  "main": "horizontalbar",  "author": "",  "license": "Apache-2.0",  "dependencies": {    "zeppelin-tabledata": "*",    "zeppelin-vis": "*"  }}2. Create your own visualizationTo create your own visualization, you need to create a js file and import Visualization class from zeppelin-vis package and extend the class. zeppelin-tabledata package provides some useful transformations, like pivot, you can use in your visualization. (you can create your own transformation, too).Visualization class, there're several methods that you need to override and implement. Here's simple visualization that just prints Hello 
 world.import Visualization from 'zeppelin-vis'import PassthroughTransformation from 'zeppelin-tabledata/passthrough'export default class helloworld extends Visualization {  constructor(targetEl, config) {    super(targetEl, config)    this.passthrough = new PassthroughTransformation(config);  }  render(tableData) {    this.targetEl.html('Hello world!')  }  getTransformation() {    return this.passthrough  }}To learn more about Visualization class, check visualization.js.You can check complete visualization package example here.Zeppelin's built-in visualization uses the same API, so you can check built-in visualizations as additional examples.3. Create Helium package file and locally deployHelium Package file is a json file that provides information about the application.Json file contains the following information{  "type" : "VISUALIZATION",  "name" : "zeppelin_hori
 zontalbar",  "description" : "Horizontal Bar chart (example)",  "license" : "Apache-2.0",  "artifact" : "./zeppelin-examples/zeppelin-example-horizontalbar",  "icon" : "<i class='fa fa-bar-chart rotate90flipX'></i>"}Place this file in your local registry directory (default ./helium).typeWhen you're creating a visualization, 'type' should be 'VISUALIZATION'.Check application type if you're interested in the other types of package.nameName of visualization. Should be unique. Allows [A-Za-z90-9_].descriptionA short description about visualization.artifactLocation of the visualization npm package. Support npm package with version or local filesystem path.e.g.When artifact exists in npm repository"artifact": "my-visualiz
 tion@1.0.0"When artifact exists in local file system"artifact": "/path/to/my/visualization"licenseLicense information.e.g."license": "Apache-2.0"iconIcon to be used in visualization select button. String in this field will be rendered as a HTML tag.e.g."icon": "<i class='fa fa-coffee'></i>"4. Run in dev modePlace your Helium package file in local registry (ZEPPELIN_HOME/helium).Run Zeppelin. And then run zeppelin-web in visualization dev mode.cd zeppelin-webyarn run dev:heliumYou can browse localhost:9000. Everytime refresh your browser, Zeppelin will rebuild your visualization and reload changes.5. Publish your visualizationOnce it's done, publish your visualization package using npm publish.That's it. With in an hour, your visualization will be available in Zeppelin's helium menu.",
+      "url": " /development/writingzeppelinvisualization.html",
+      "group": "development",
       "excerpt": "Apache Zeppelin Visualization is a pluggable package that can be loaded/unloaded on runtime through Helium framework in Zeppelin. A Visualization is a javascript npm package and user can use them just like any other built-in visualization in a note."
     }
     ,
     
   
 
-    "/development/helium/writing_visualization_transformation.html": {
-      "title": "Transformations in Zeppelin Visualization",
+    "/development/writingzeppelinvisualization_transformation.html": {
+      "title": "Transformations for Zeppelin Visualization",
       "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Transformations for Zeppelin VisualizationOverviewTransformations renders setting which allows users to set columns and transforms table rows according to the configured columns.Zeppelin provides 4 types of transformations.1. PassthroughTransformationPassthroughTransformation is the simple transformation which does not convert original tabledata at all.See passthrough.js2. ColumnselectorTransformationColumnselectorTransformation is
  uses when you need N axes but do not need aggregation. See columnselector.js3. PivotTransformationPivotTransformation provides group by and aggregation. Every chart using PivotTransformation has 3 axes. Keys, Groups and Values.See pivot.js4. AdvancedTransformationAdvancedTransformation has more detailed options while providing existing features of PivotTransformation and ColumnselectorTransformationmultiple sub chartsconfigurable chart axesparameter widgets: input, checkbox, option, textareaparsing parameters automatically based on their typesexpand / fold axis and parameter panelsmultiple transformation methods while supporting lazy converting re-initialize the whole configuration based on spec hash.SpecAdvancedTransformation requires spec which includes axis and parameter details for charts.Let's create 2 sub-charts called line and no-group. Each sub chart can have different axis and parameter depending on their requirements.class AwesomeVisualization extends Visualizatio
 n {  constructor(targetEl, config) {    super(targetEl, config)    const spec = {      charts: {        'line': {          transform: { method: 'object', },          sharedAxis: false, /** set if you want to share axes between sub charts, default is `false` */          axis: {            'xAxis': { dimension: 'multiple', axisType: 'key', description: 'serial', },            'yAxis': { dimension: 'multiple', axisType: 'aggregator', description: 'serial', },            'category': { dimension: 'multiple', axisType: 'group', description: 'categorical', },          },          parameter: {            'xAxisUnit': { valueType: 'string', defaultValue: '', description: 'unit of xAxis', },            &#3
 9;yAxisUnit': { valueType: 'string', defaultValue: '', description: 'unit of yAxis', },            'lineWidth': { valueType: 'int', defaultValue: 0, description: 'width of line', },          },        },        'no-group': {          transform: { method: 'object', },          sharedAxis: false,          axis: {            'xAxis': { dimension: 'single', axisType: 'key', },            'yAxis': { dimension: 'multiple', axisType: 'value', },          },          parameter: {            'xAxisUnit': { valueType: 'string', defaultValue: '', description: 'unit of xAxis', },            'yAxisUnit': { valueType: 'string', defaultValue: '', description: 
 'unit of yAxis', },        },      },    }    this.transformation = new AdvancedTransformation(config, spec)  }  ...  // `render` will be called whenever `axis` or `parameter` is changed   render(data) {    const { chart, parameter, column, transformer, } = data    if (chart === 'line') {      const transformed = transformer()      // draw line chart     } else if (chart === 'no-group') {      const transformed = transformer()      // draw no-group chart     }  }}Spec: axisField NameAvailable Values (type)DescriptiondimensionsingleAxis can contains only 1 columndimensionmultipleAxis can contains multiple columnsaxisTypekeyColumn(s) in this axis will be used as key like in PivotTransformation. These columns will be served in column.keyaxisTypeaggregatorColumn(s) in this axis will be used as value like in PivotTransformation. These columns will be served in column.aggregatoraxisTypegroupColumn(s) in this axis will be used as group like i
 n PivotTransformation. These columns will be served in column.groupaxisType(string)Any string value can be used here. These columns will be served in column.custommaxAxisCount (optional)(int)The max number of columns that this axis can contain. (unlimited if undefined)minAxisCount (optional)(int)The min number of columns that this axis should contain to draw chart. (1 in case of single dimension)description (optional)(string)Description for the axis.Here is an example.axis: {  'xAxis': { dimension: 'multiple', axisType: 'key',  },  'yAxis': { dimension: 'multiple', axisType: 'aggregator'},  'category': { dimension: 'multiple', axisType: 'group', maxAxisCount: 2, valueType: 'string', },},Spec: sharedAxisIf you set sharedAxis: false for sub charts, then their axes are persisted in global space (shared). It's useful for 
 when you creating multiple sub charts sharing their axes but have different parameters. For example, basic-column, stacked-column, percent-columnpie and donutHere is an example.    const spec = {      charts: {        'column': {          transform: { method: 'array', },          sharedAxis: true,          axis: { ... },          parameter: { ... },        },        'stacked': {          transform: { method: 'array', },          sharedAxis: true,          axis: { ... }          parameter: { ... },        },Spec: parameterField NameAvailable Values (type)DescriptionvalueTypestringParameter which has string valuevalueTypeintParameter which has int valuevalueTypefloatParameter which has float valuevalueTypebooleanParameter which has boolean value used with checkbox widget usuallyvalueTypeJSONParameter which has JSON value used with textarea widget usually. defaultValue should be "" (empty string). Thisdes
 cription(string)Description of this parameter. This value will be parsed as HTML for pretty outputwidgetinputUse input widget. This is the default widget (if widget is undefined)widgetcheckboxUse checkbox widget.widgettextareaUse textarea widget.widgetoptionUse select + option widget. This parameter should have optionValues field as well.optionValues(Array)Available option values used with the option widgetHere is an example.parameter: {  // string type, input widget  'xAxisUnit': { valueType: 'string', defaultValue: '', description: 'unit of xAxis', },  // boolean type, checkbox widget  'inverted': { widget: 'checkbox', valueType: 'boolean', defaultValue: false, description: 'invert x and y axes', },  // string type, option widget with `optionValues`  'graphType': { widget: 'option', valueType: 'string', defa
 ultValue: 'line', description: 'graph type', optionValues: [ 'line', 'smoothedLine', 'step', ], },  // HTML in `description`  'dateFormat': { valueType: 'string', defaultValue: '', description: 'format of date (<a href="https://docs.amcharts.com/3/javascriptcharts/AmGraph#dateFormat">doc</a>) (e.g YYYY-MM-DD)', },  // JSON type, textarea widget  'yAxisGuides': { widget: 'textarea', valueType: 'JSON', defaultValue: '', description: 'guides of yAxis ', },Spec: transformField NameAvailable Values (type)Descriptionmethodobjectdesigned for rows requiring object manipulationmethodarraydesigned for rows requiring array manipulationmethodarray:2-keydesigned for xyz charts (e.g bubble chart)methoddrill-downdesigned for drill-d
 own chartsmethodrawwill return the original tableData.rowsWhatever you specified as transform.method, the transformer value will be always function for lazy computation. // advanced-transformation.util#getTransformerif (transformSpec.method === 'raw') {  transformer = () => { return rows; }} else if (transformSpec.method === 'array') {  transformer = () => {    ...    return { ... }  }}Here is actual usage.class AwesomeVisualization extends Visualization {  constructor(...) { /** setup your spec */ }  ...   // `render` will be called whenever `axis` or `parameter` are changed  render(data) {    const { chart, parameter, column, transformer, } = data    if (chart === 'line') {      const transformed = transformer()      // draw line chart     } else if (chart === 'no-group') {      const transformed = transformer()      // draw no-group chart     }  }  ...}",
-      "url": " /development/helium/writing_visualization_transformation.html",
-      "group": "development/helium",
+      "url": " /development/writingzeppelinvisualization_transformation.html",
+      "group": "development",
       "excerpt": "Description for Transformations"
     }
     ,
     
   
 
-    "/development/writing_zeppelin_interpreter.html": {
-      "title": "Writing a New Interpreter",
-      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Writing a New InterpreterWhat is Apache Zeppelin InterpreterApache Zeppelin Interpreter is a language backend. For example to use scala code in Zeppelin, you need a scala interpreter.Every Interpreters belongs to an InterpreterGroup.Interpreters in the same InterpreterGroup can reference each other. For example, SparkSqlInterpreter can reference SparkInterpreter to get SparkContext from it while they're in the same group.In
 terpreterSetting is configuration of a given InterpreterGroup and a unit of start/stop interpreter.All Interpreters in the same InterpreterSetting are launched in a single, separate JVM process. The Interpreter communicates with Zeppelin engine via Thrift.In 'Separate Interpreter(scoped / isolated) for each note' mode which you can see at the Interpreter Setting menu when you create a new interpreter, new interpreter instance will be created per note. But it still runs on the same JVM while they're in the same InterpreterSettings.Make your own InterpreterCreating a new interpreter is quite simple. Just extend org.apache.zeppelin.interpreter abstract class and implement some methods.You can include org.apache.zeppelin:zeppelin-interpreter:[VERSION] artifact in your build system. And you should put your jars under your interpreter directory with a specific directory name. Zeppelin server reads interpreter directories recursively and initializes interpreters inc
 luding your own interpreter.There are three locations where you can store your interpreter group, name and other information. Zeppelin server tries to find the location below. Next, Zeppelin tries to find interpreter-setting.json in your interpreter jar.{ZEPPELIN_INTERPRETER_DIR}/{YOUR_OWN_INTERPRETER_DIR}/interpreter-setting.jsonHere is an example of interpreter-setting.json on your own interpreter.[  {    "group": "your-group",    "name": "your-name",    "className": "your.own.interpreter.class",    "properties": {      "properties1": {        "envName": null,        "propertyName": "property.1.name",        "defaultValue": "propertyDefaultValue",        "description": "Property description"      },      "p
 roperties2": {        "envName": PROPERTIES_2,        "propertyName": null,        "defaultValue": "property2DefaultValue",        "description": "Property 2 description"      }, ...    },    "editor": {      "language": "your-syntax-highlight-language",      "editOnDblClick": false    }  },  {    ...  }]Finally, Zeppelin uses static initialization with the following:static {  Interpreter.register("MyInterpreterName", MyClassName.class.getName());}Static initialization is deprecated and will be supported until 0.6.0.The name will appear later in the interpreter name option box during the interpreter configuration process.The name of the interpreter is what you later write to identify a paragraph which should be interpreted using this interpreter.%MyInterpreterNamesome interpreter
  specific code...Editor setting for InterpreterYou can add editor object to interpreter-setting.json file to specify paragraph editor settings.LanguageIf the interpreter uses a specific programming language (like Scala, Python, SQL), it is generally recommended to add a syntax highlighting supported for that to the note paragraph editor.To check out the list of languages supported, see the mode-*.js files under zeppelin-web/bower_components/ace-builds/src-noconflict or from github.com/ajaxorg/ace-builds.If you want to add a new set of syntax highlighting,  Add the mode-*.js file to zeppelin-web/bower.json (when built, zeppelin-web/src/index.html will be changed automatically).Add language field to editor object. Note that if you don't specify language field, your interpreter will use plain text mode for syntax highlighting. Let's say you want to set your language to java, then add:"editor": {  "language": "java"}E
 dit on double clickIf your interpreter uses mark-up language such as markdown or HTML, set editOnDblClick to true so that text editor opens on pargraph double click and closes on paragraph run. Otherwise set it to false."editor": {  "editOnDblClick": false}Install your interpreter binaryOnce you have built your interpreter, you can place it under the interpreter directory with all its dependencies.[ZEPPELIN_HOME]/interpreter/[INTERPRETER_NAME]/Configure your interpreterTo configure your interpreter you need to follow these steps:Add your interpreter class name to the zeppelin.interpreters property in conf/zeppelin-site.xml.Property value is comma separated [INTERPRETER_CLASS_NAME].For example,<property><name>zeppelin.interpreters</name><value>org.apache.zeppelin.spark.SparkInterpreter,org.apache.zeppelin.spark.PySparkInterpreter,org.apache.zeppelin.spark.SparkSqlInterpreter,org.apache.zeppeli
 n.spark.DepInterpreter,org.apache.zeppelin.markdown.Markdown,org.apache.zeppelin.shell.ShellInterpreter,org.apache.zeppelin.hive.HiveInterpreter,com.me.MyNewInterpreter</value></property>Add your interpreter to the default configuration which is used when there is no zeppelin-site.xml.Start Zeppelin by running ./bin/zeppelin-daemon.sh start.In the interpreter page, click the +Create button and configure your interpreter properties.Now you are done and ready to use your interpreter.Note : Interpreters released with zeppelin have a default configuration which is used when there is no conf/zeppelin-site.xml.Use your interpreter0.5.0Inside of a note, %[INTERPRETER_NAME] directive will call your interpreter.Note that the first interpreter configuration in zeppelin.interpreters will be the default one.For example,%myintpval a = "My interpreter"println(a)0.6.0 and laterInside of a note, %[INTERPRETER_GROUP].[INTERPRETER_NAME] directive will cal
 l your interpreter.You can omit either [INTERPRETER_GROUP] or [INTERPRETER_NAME]. If you omit [INTERPRETER_NAME], then first available interpreter will be selected in the [INTERPRETER_GROUP].Likewise, if you skip [INTERPRETER_GROUP], then [INTERPRETER_NAME] will be chosen from default interpreter group.For example, if you have two interpreter myintp1 and myintp2 in group mygrp, you can call myintp1 like%mygrp.myintp1codes for myintp1and you can call myintp2 like%mygrp.myintp2codes for myintp2If you omit your interpreter name, it'll select first available interpreter in the group ( myintp1 ).%mygrpcodes for myintp1You can only omit your interpreter group when your interpreter group is selected as a default group.%myintp2codes for myintp2ExamplesCheckout some interpreters released with Zeppelin by default.sparkmarkdownshelljdbcContributing a new Interpreter to Zeppelin releasesWe welcome contribution to a new interpreter. Please follow these few steps:First, check out the gene
 ral contribution guide here.Follow the steps in Make your own Interpreter section and Editor setting for Interpreter above.Add your interpreter as in the Configure your interpreter section above; also add it to the example template zeppelin-site.xml.template.Add tests! They are run by Travis for all changes and it is important that they are self-contained.Include your interpreter as a module in pom.xml.Add documentation on how to use your interpreter under docs/interpreter/. Follow the Markdown style as this example. Make sure you list config settings and provide working examples on using your interpreter in code boxes in Markdown. Link to images as appropriate (images should go to docs/assets/themes/zeppelin/img/docs-img/). And add a link to your documentation in the navigation menu (docs/_includes/themes/zeppelin/_navigation.html).Most importantly, ensure licenses of the transitive closure of all dependencies are list in license file.Commit your changes and open a Pull Request on 
 the project Mirror on GitHub; check to make sure Travis CI build is passing.",
-      "url": " /development/writing_zeppelin_interpreter.html",
-      "group": "development",
-      "excerpt": "Apache Zeppelin Interpreter is a language backend. Every Interpreters belongs to an InterpreterGroup. Interpreters in the same InterpreterGroup can reference each other."
+    "/displaysystem/back-end-angular.html": {
+      "title": "Back-end Angular API in Apache Zeppelin",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Back-end Angular API in Apache ZeppelinOverviewAngular display system treats output as a view template for AngularJS.It compiles templates and displays them inside of Apache Zeppelin. Zeppelin provides a gateway between your interpreter and your compiled AngularJS view templates.Therefore, you can not only update scope variables from your interpreter but also watch them in the interpreter, which is JVM process.Basic UsagePrint Angu
 larJS viewTo use angular display system, you should start with %angular.Since name is not defined, Hello will display Hello.Please Note: Display system is backend independent.Bind / Unbind VariablesThrough ZeppelinContext, you can bind / unbind variables to AngularJS view. Currently, it only works in Spark Interpreter ( scala ).// bind my 'object' as angular scope variable 'name' in current notebook.z.angularBind(String name, Object object)// bind my 'object' as angular scope variable 'name' in all notebooks related to current interpreter.z.angularBindGlobal(String name, Object object)// unbind angular scope variable 'name' in current notebook.z.angularUnbind(String name)// unbind angular scope variable 'name' in all notebooks related to current interpreter.z.angularUnbindGlobal(String name)Using the above example, let's bind world variable to name. Then you can see AngularJs view
  is immediately updated.Watch / Unwatch VariablesThrough ZeppelinContext, you can watch / unwatch variables in AngularJs view. Currently, it only works in Spark Interpreter ( scala ).// register for angular scope variable 'name' (notebook)z.angularWatch(String name, (before, after) => { ... })// unregister watcher for angular variable 'name' (notebook)z.angularUnwatch(String name)// register for angular scope variable 'name' (global)z.angularWatchGlobal(String name, (before, after) => { ... })// unregister watcher for angular variable 'name' (global)z.angularUnwatchGlobal(String name)Let's make a button. When it is clicked, the value of run will be increased 1 by 1.z.angularBind("run", 0) will initialize run to zero. And then, it will be also applied to run in z.angularWatch().When the button is clicked, you'll see both run and numWatched are incremented by 1.Let's
  make it Simpler and more IntuitiveIn this section, we will introduce a simpler and more intuitive way of using Angular Display System in Zeppelin.Here are some usages.Import// In notebook scopeimport org.apache.zeppelin.display.angular.notebookscope._import AngularElem._// In paragraph scopeimport org.apache.zeppelin.display.angular.paragraphscope._import AngularElem._Display Element// automatically convert to string and print with %angular display system directive in front.<div></div>.displayEvent Handler// on click<div></div>.onClick(() => {   my callback routine}).display// on change<div></div>.onChange(() => {  my callback routine}).display// arbitrary event<div></div>.onEvent("ng-click", () => {  my callback routine}).displayBind Model// bind model<div></div>.model("myModel").display
 // bind model with initial value<div></div>.model("myModel", initialValue).displayInteract with Model// read modelAngularModel("myModel")()// update modelAngularModel("myModel", "newValue")Example: Basic UsageUsing the above basic usages, you can apply them like below examples.Display Elements<div style="color:blue">  <h4>Hello Angular Display System</h4></div>.displayOnClick Event<div class="btn btn-success">  Click me</div>.onClick{() =>  // callback for button click}.displayBind Model  <div>{{{{myModel}}}}</div>.model("myModel", "Initial Value").displayInteract With Model// read the valueAngularModel("myModel")()// update the valueAngularModel("myModel", &amp
 ;quot;New value")Example: String ConverterUsing below example, you can convert the lowercase string to uppercase.// clear previously created angular object.AngularElem.disassociateval button = <div class="btn btn-success btn-sm">Convert</div>.onClick{() =>  val inputString = AngularModel("input")().toString  AngularModel("title", inputString.toUpperCase)}<div>  { <h4> {{{{title}}}}</h4>.model("title", "Please type text to convert uppercase") }   Your text { <input type="text"></input>.model("input", "") }  {button}</div>.display",
+      "url": " /displaysystem/back-end-angular.html",
+      "group": "display",
+      "excerpt": "Apache Zeppelin provides a gateway between your interpreter and your compiled AngularJS view templates. You can not only update scope variables from your interpreter but also watch them in the interpreter, which is JVM process."
+    }
+    ,
+    
+  
+
+    "/displaysystem/basicdisplaysystem.html": {
+      "title": "Basic Display System in Apache Zeppelin",
+      "content"  : "<!--Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, softwaredistributed under the License is distributed on an "AS IS" BASIS,WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions andlimitations under the License.-->Basic Display System in Apache ZeppelinTextBy default, Apache Zeppelin prints interpreter response as a plain text using text display system.You can explicitly say you're using text display system.HtmlWith %html directive, Zeppelin treats your output as HTMLMathematical expressionsHTML display system automatically formats mathematical expression using MathJax. You can use( INLINE EXPRESSION ) and $$ EXPRESSION $$ to format.
  For exampleTableIf you have data that row separated by n (newline) and column separated by t (tab) with first row as header row, for exampleYou can simply use %table display system to leverage Zeppelin's built in visualization.If table contents start with %html, it is interpreted as an HTML.Note : Display system is backend independent.NetworkWith the %network directive, Zeppelin treats your output as a graph. Zeppelin can leverage the Property Graph Model.What is the Labelled Property Graph Model?A Property Graph is a graph that has these elements:a set of verticeseach vertex has a unique identifier.each vertex has a set of outgoing edges.each vertex has a set of incoming edges.each vertex has a collection of properties defined by a map from key to valuea set of edgeseach edge has a unique identifier.each edge has an outgoing tail vertex.each edge has an incoming head vertex.each edge has a label that denotes the type of relationship between its two vertices.each edge has a
  collection of properties defined by a map from key to value.A Labelled Property Graph is a Property Graph where the nodes can be tagged with labels representing their different roles in the graph modelWhat are the APIs?The new NETWORK visualization is based on json with the following params:"nodes" (mandatory): list of nodes of the graph every node can have the following params:"id" (mandatory): the id of the node (must be unique);"label": the main Label of the node;"labels": the list of the labels of the node;"data": the data attached to the node;"edges": list of the edges of the graph;"id" (mandatory): the id of the edge (must be unique);"source" (mandatory): the id of source node of the edge;"target" (mandatory): the id of target node of the edge;"label": the main type of the edge;"data&qu
 ot;: the data attached to the edge;"labels": a map (K, V) where K is the node label and V is the color of the node;"directed": (true/false, default false) wich tells if is directed graph or not;"types": a distinct list of the edge types of the graphIf you click on a node or edge on the bottom of the paragraph you find a list of entity propertiesThis kind of graph can be easily flatten in order to support other visualization formats provided by Zeppelin.How to use it?An example of a simple graph%sparkprint(s"""%network {    "nodes": [        {"id": 1},        {"id": 2},        {"id": 3}    ],    "edges": [        {"source": 1, "target": 2, "id" : 1},        {"source": 2, "target": 3, "id" : 2},        {&qu
 ot;source": 1, "target": 2, "id" : 3},        {"source": 1, "target": 2, "id" : 4},        {"source": 2, "target": 1, "id" : 5},        {"source": 2, "target": 1, "id" : 6}    ]}""")that will look like:A little more complex graph:%sparkprint(s"""%network {    "nodes": [{"id": 1, "label": "User", "data": {"fullName":"Andrea Santurbano"}},{"id": 2, "label": "User", "data": {"fullName":"Lee Moon Soo"}},{"id": 3, "label": "Project", "data&
 amp;quot;: {"name":"Zeppelin"}}],    "edges": [{"source": 2, "target": 1, "id" : 1, "label": "HELPS"},{"source": 2, "target": 3, "id" : 2, "label": "CREATE"},{"source": 1, "target": 3, "id" : 3, "label": "CONTRIBUTE_TO", "data": {"oldPR": "https://github.com/apache/zeppelin/pull/1582"}}],    "labels": {"User": "#8BC34A", "Project": "#3071A9"},    "directed": true,    "types": ["HELPS", "CREATE", "CONTRIBUTE_TO"]}""&am
 p;quot;)that will look like:",
+      "url": " /displaysystem/basicdisplaysystem.html",
+      "group": "display",
+      "excerpt": "There are 3 basic display systems in Apache Zeppelin. By default, Zeppelin prints interpreter responce as a plain text using text display system. With %html directive, Zeppelin treats your output as HTML. You can also simply use %table display system..."
+    }
+    ,
+    
+  
+
+    "/displaysystem/front-end-angular.html": {
+      "title": "Front-end Angular API in Apache Zeppelin",

[... 808 lines stripped ...]


Mime
View raw message