[{"_1":2,"_173":-5,"_174":-5},"loaderData",{"_3":4,"_17":18,"_25":26,"_148":149},"root",{"_5":-5,"_6":-7,"_7":8,"_9":-7,"_10":11,"_12":-7,"_13":14,"_15":16},"currentUser","primaryEmail","siteVerification","6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI","toast","enableDev",false,"incidentStatus","theme","system","contrast","normal","routes/_layout",{"_19":-5,"_20":21,"_22":21,"_23":11,"_24":21},"username","isAskGordonEnabled",true,"isUsingNewTemplate","showMinimalLanding","showHoneypotTrap","routes/_layout.r.$namespace.$reponame",{"_27":28,"_29":-5,"_30":11,"_31":11,"_32":33,"_34":35,"_36":-5,"_37":11,"_38":39,"_88":-5,"_89":90,"_139":-5,"_140":11,"_141":21,"_142":11,"_143":-5,"_144":11,"_145":-5,"_146":147},"canonicalUrl","https://hub.docker.com/r/parana/spark/tags","mcpServer","canSeeDockerfile","canSeeAutobuilds","namespace","parana","reponame","spark","cloudBuildSource","isAutobuildsAvailable","repo",{"_40":41,"_42":43,"_45":46,"_47":48,"_49":11,"_50":51,"_52":53,"_54":55,"_57":35,"_32":33,"_58":59,"_60":44,"_61":62,"_63":62,"_64":65,"_66":-5,"_67":68,"_69":70,"_71":11,"_72":33,"_73":74,"_79":21,"_80":81,"_85":33,"_86":87},"categories",[],"content_types",[44],"image","date_registered","2016-08-01T02:07:32.880375Z","description","Apache Spark 2.0 on CentOS 7 system using Oracle JDK 8 ","is_private","last_updated","2019-03-24T19:25:54.929052Z","last_modified","2024-10-16T13:48:34.145251Z","media_types",[56],"application/vnd.docker.container.image.v1+json","name","pull_count",44736,"repository_type","star_count",1,"status","status_description","active","source","collaborator_count",0,"full_description","# Spark\n\n**This repository depends on Git Large Files [https://git-lfs.github.com/](https://git-lfs.github.com/)** \n\nCreate the `parana/spark` Docker Image \n\nThis **Dockerfile** is a [Automated build](https://hub.docker.com/r/parana/spark/) of [Docker Registry](https://hub.docker.com/).\n\n## Spark Components\n\n![Spark Components](assets/img/spark-components.png)\n\n\n## Building on boot2docker & Docker Machine\n\nYou need to configure swap space in boot2docker / Docker Machine prior the build:\n\n1. Log into boot2docker / Docker Machine: `boot2docker ssh` or `docker-machine ssh default` (replace `default` if needed).\n2. Create a file named `bootlocal.sh` in `/var/lib/boot2docker/` with the following content:\n\n #!/bin/sh\n\n SWAPFILE=/mnt/sda1/swapfile\n\n dd if=/dev/zero of=$SWAPFILE bs=1024 count=2097152\n mkswap $SWAPFILE && chmod 600 $SWAPFILE && swapon $SWAPFILE\n\n3. Make this file executable: `chmod u+x /var/lib/boot2docker/bootlocal.sh`\n\nAfter restarting boot2docker / Docker Machine, it will have increased swap size.\n\n## How to use\n\n```\ndocker pull parana/spark\ndocker run -i -t -h my-spark \\\n -p 8080:8080 -p 7077:7077 -p 8888:8888 -p 6066:6066 \\\n --rm \\\n parana/spark bash\n```\n\n> You can add `-v $PWD/m2-repo:/usr/local/m2-repo` in case of use the **host directory** to persist the Maven Local Repository. In this case you need alter Dockerfile properly.\n\nThe Container Bash shell will open and you can type:\n\n```\ncd /usr/local/spark/sbin\n./start-master.sh # starting org.apache.spark.deploy.master.Master, logging to /usr/local/spark/logs/\nps -ef | grep java \nls -lAt /usr/local/spark/logs\ncat /usr/local/spark/logs/* | grep \"Starting Spark master at\"\n# Write the spark URL to remember (suppose: \"spark://my-spark:7077\")\ncat /usr/local/spark/logs/* | grep port\n# Use the URL of Master to start the Slave\n./start-slave.sh spark://my-spark:7077\n# Test the master’s web UI\nsleep 5\ncurl http://localhost:8080\n```\n\n### Using Spark\n\n> Most of this content is from Spark Documentation for 2.0.2 version avaiable in [http://spark.apache.org/docs/2.0.2/](http://spark.apache.org/docs/2.0.2/), but properly organized for Data Science professionals.\n\nOpen on WEB Browser in host computer\n\n```\nhttp://localhost:8080\n```\n\nYou will see something like this.\n\n![Spark master admin View](https://raw.githubusercontent.com/joao-parana/spark/master/docs/images/spark-master-admin.png)\n\n#### Interactive Analysis with the Spark Shell\n\nSpark’s shell provides a simple way to learn the API, as well as a powerful tool \nto analyze data interactively. It is available in Scala which runs on the Java VM \nand is thus a good way to use existing Java libraries. Start it by running the \nfollowing in the Spark directory:\n\n```bash\nspark-shell\n```\n\nSpark’s primary abstraction is a distributed collection of items called a \nResilient Distributed Dataset (RDD). RDDs can be created from Hadoop \nInputFormats (such as HDFS files) or by transforming other RDDs. Let’s make \na new RDD from the text of the README file in the Spark source directory:\n\n```scala\nval textFile = sc.textFile(\"../README.md\")\n```\n\n```\ntextFile: org.apache.spark.rdd.RDD[String] = README.md MapPartitionsRDD[1] at textFile at :25\n```\nRDDs have actions, which return values, and transformations, which return \npointers to new RDDs. Let’s start with a few actions:\n\n```scala\ntextFile.count() // Number of items in this RDD\nres0: Long = 126\n```\n\n```scala\ntextFile.first() // First item in this RDD\nres1: String = # Apache Spark\n```\n\nNow let’s use a transformation. We will use the filter transformation to return \na new RDD with a subset of the items in the file.\n\n```scala\nval linesWithSpark = textFile.filter(line => line.contains(\"Spark\"))\nlinesWithSpark: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at :27\n```\n\nWe can chain together transformations and actions:\n\n```scala\ntextFile.filter(line => line.contains(\"Spark\")).count() // How many lines contain \"Spark\"?\nres3: Long = 15\n```\n\n#### More on RDD Operations\n\nRDD actions and transformations can be used for more complex computations. \n\nLet’s say we want to find the line with the most words:\n\n```scala\ntextFile.map(line => line.split(\" \").size).reduce((a, b) => if (a > b) a else b)\n```\n\nThis first maps a line to an integer value, creating a new RDD. Method reduce is \ncalled on that RDD to find the largest line count. The arguments to map and \nreduce are Scala function literals (closures), and can use any language \nfeature or Scala/Java library. For example, we can easily call functions \ndeclared elsewhere. We’ll use Math.max() function to make this code easier \nto understand:\n\n\n```scala\nimport java.lang.Math\ntextFile.map(line => line.split(\" \").size).reduce((a, b) => Math.max(a, b))\nres5: Int = 15\n```\n\nOne common data flow pattern is MapReduce, as popularized by Hadoop. Spark \ncan implement MapReduce flows easily:\n\n```scala\nval wordCounts = textFile.flatMap(line => line.split(\" \")).map(word => (word, 1)).reduceByKey((a, b) => a + b)\nwordCounts: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[8] at reduceByKey at :28\n```\n\nHere, we combined the flatMap, map, and reduceByKey transformations to compute \nthe per-word counts in the file as an RDD of (String, Int) pairs. To collect \nthe word counts in our shell, we can use the collect action:\n\n```scala\nwordCounts.collect()\nres6: Array[(String, Int)] = Array((means,1), (under,2), (this,3), (Because,1), (Python,2), (agree,1), (cluster.,1), ...)\n```\n\n#### Caching\n\nSpark also supports pulling data sets into a cluster-wide in-memory cache. This \nis very useful when data is accessed repeatedly, such as when querying a \nsmall “hot” dataset or when running an iterative algorithm like PageRank. \n\nAs a simple example, let’s mark our `linesWithSpark` dataset to be cached:\n\n```scala\nlinesWithSpark.cache()\nres7: linesWithSpark.type = MapPartitionsRDD[2] at filter at :27\n```\n\n```scala\nlinesWithSpark.count()\nres8: Long = 19\n```\n\nIt may seem silly to use Spark to explore and cache a 100-line text file. The \ninteresting part is that these same functions can be used on very large data \nsets, even when they are striped across tens or hundreds of nodes. You can \nalso do this interactively by connecting `bin/spark-shell` to a cluster, as \ndescribed in the \n[programming guide](http://spark.apache.org/docs/latest/programming-guide.html).\n\n#### Self-Contained Java Applications\n\nSuppose we wish to write a self-contained application using the Spark API. We \nwill walk through a simple application in Java (with Maven).\n\nThis example will use Maven to compile an application JAR, but any similar \nbuild system will work.\n\nWe’ll create a very simple Spark application, `SimpleApp.java`:\n\n```java\n/* SimpleApp.java */\nimport org.apache.spark.api.java.*;\nimport org.apache.spark.SparkConf;\nimport org.apache.spark.api.java.function.Function;\n\npublic class SimpleApp {\n public static void main(String[] args) {\n // logFile Should be some file on your system\n String logFile = \"/usr/local/spark/README.md\"; \n SparkConf conf = new SparkConf().setAppName(\"Simple Application\");\n JavaSparkContext sc = new JavaSparkContext(conf);\n JavaRDD logData = sc.textFile(logFile).cache();\n\n long numAs = logData.filter(new Function() {\n public Boolean call(String s) { return s.contains(\"a\"); }\n }).count();\n\n long numBs = logData.filter(new Function() {\n public Boolean call(String s) { return s.contains(\"b\"); }\n }).count();\n\n System.out.println(\"Lines with a: \" + numAs + \", lines with b: \" + numBs);\n }\n}\n\n```\n\nThis program just counts the number of lines containing ‘a’ and the number \ncontaining ‘b’ in a text file. Note that you’ll need to replace \n/usr/local/spark with the location where Spark is installed (if you will\nrun this code in another environment). \n\nAs with the Scala example, we initialize a SparkContext, though we use the \nspecial JavaSparkContext class to get a Java-friendly one. \n\nWe also create **RDDs** (represented by JavaRDD) and run transformations on \nthem. Finally, we pass functions to Spark by creating classes that extend \nspark.api.java.function.Function. The Spark programming guide describes these \ndifferences in more detail.\n\nTo build the program, we also write a Maven pom.xml file that lists Spark as a \ndependency. \n\n```xml\n\n 4.0.0\n br.com.joao-parana\n myspark\n 1.0-SNAPSHOT\n jar\n myspark\n http://maven.apache.org\n \n UTF-8\n \n \n \n org.apache.spark\n spark-core_2.11\n 2.0.2\n \n \n junit\n junit\n 4.8.1\n test\n \n \n\n```\n\nThis project is already created at /desenv/java/myspark, so now you can run \nthis Java Program using :\n\n```bash\ncd /desenv/java/myspark\n/usr/local/spark/bin/spark-submit \\\n --class \"spark.SimpleApp\" \\\n --master local[4] \\\n target/myspark-1.0-SNAPSHOT.jar 2> /dev/null \n```\n\nSee `Dockerfile` for details about where this files are located in host \ncomputer. For example:\n\n```bash\nCOPY test /desenv/java/\n```\n\n\n#### Where to Go from Here\n\nCongratulations on running your first Spark application!\n\nFor an in-depth overview of the API, start with the \n[Spark programming guide](http://spark.apache.org/docs/latest/programming-guide.html), \nor see “Programming Guides” menu for other components like : **MLlib** \nfor _Machine Learning_ API.\n\nFor running applications on a cluster, head to the deployment overview.\n\nFinally, Spark includes several samples in the examples directory (Scala, \nJava, Python, R). You can run them as follows:\n\n\n```bash\n# For Scala and Java, use run-example:\n/usr/local/spark/bin/run-example SparkPi\n```\n\nThis shell `run-example` delegate the execution to \n`/usr/local/spark/bin/spark-class` which invoke the class\n`org.apache.spark.deploy.SparkSubmit` passing all parameters.\n\nIn the other hand this shell `spark-class` ensure the environment is set \nrunning load-spark-env.sh, find Spark jars, set the LAUNCH_CLASSPATH variable\nand build the command to be executed. Then start JVM to run the command.\n\nIn this case of running `SparkPi` the command build is something like this:\n\n```bash\n/opt/jdk1.8.0_91/bin/java \\\n -cp /usr/local/spark/conf/:/usr/local/spark/jars/* \\\n -Xmx1g \\\n org.apache.spark.deploy.SparkSubmit \\\n --jars /usr/local/spark/examples/jars/scopt_2.11-3.3.0.jar,/usr/local/spark/examples/jars/spark-examples_2.11-2.0.2.jar \\\n --class org.apache.spark.examples.SparkPi spark-internal\n\n```\n\nSo, you can use `/desenv/java/run-example.sh SparkPi` to run SparkPi example.\n\n\n#### Launching Spark jobs from Java or Scala\n\nThe org.apache.spark.launcher package provides classes for launching Spark \njobs as child processes using a simple Java API.\n\n#### Unit Testing\n\nSpark is friendly to unit testing with any popular unit test framework. \nSimply create a SparkContext in your test with the master URL set to local, \nrun your operations, and then call SparkContext.stop() to tear it down. \nMake sure you stop the context within a finally block or the test \nframework’s tearDown method, as Spark does not support two contexts \nrunning concurrently in the same program.\n\nSome examples:\n\n```java\npackage spark;\n\nimport static org.junit.Assert.*;\nimport java.io.IOException;\nimport java.util.*;\nimport org.apache.spark.SparkConf;\nimport org.apache.spark.api.java.*;\nimport org.junit.*;\n\npublic class SimpleTest {\n private JavaSparkContext sparkCtx;\n\n @Before\n public void init() throws IllegalArgumentException, IOException {\n // ctxtBuilder = new ContextBuilder(tempFolder);\n SparkConf conf = new SparkConf();\n conf.setMaster(\"local[2]\");\n conf.setAppName(\"junit\");\n this.sparkCtx = new JavaSparkContext(conf);\n }\n\n @Test\n public void testSimpleRdd() {\n final List nums = new ArrayList();\n nums.add(3);\n nums.add(4);\n nums.add(2);\n JavaRDD rdd = this.sparkCtx.parallelize(nums, 1);\n assertEquals(3, rdd.count());\n }\n}\n```\n\nUsing SparkSession (please, add `spark-sql_2.11` dependency in your pom)\n\n```java\npackage spark;\n\nimport static org.apache.spark.sql.functions.*;\nimport java.io.IOException;\nimport java.util.List;\nimport org.apache.spark.sql.*;\nimport org.junit.*;\n\npublic class CsvTest {\n private SparkSession sparkSession;\n\n @Before\n public void init() throws IllegalArgumentException, IOException {\n this.sparkSession = SparkSession.builder().master(\"local\").appName(\"spark session example\").getOrCreate();\n }\n\n @Test\n public void tesCsv() {\n Dataset dataset = this.sparkSession.read().format(\"csv\").option(\"header\", \"true\").option(\"\", \"\")\n .load(\"/tmp/data.csv\");\n \n List l = dataset.collectAsList();\n String columns[] = { \"Nome\", \"Idade\" };\n for (Row row : l) {\n int s = row.length();\n for (int i = 0; i < s; i++) {\n System.out.println(columns[i] + \" : \" + row.getString(i));\n }\n }\n dataset.printSchema();\n }\n}\n```\n\nIn this examples I'm using some Functions available for DataFrame. \nSee this link [https://spark.apache.org/docs/2.0.2/api/java/org/apache/spark/sql/functions.html](https://spark.apache.org/docs/2.0.2/api/java/org/apache/spark/sql/functions.html) \nfor details.\n\n\n```java\npackage spark;\n\nimport static org.apache.spark.sql.functions.*;\nimport java.io.IOException;\nimport java.util.List;\nimport org.apache.spark.sql.*;\nimport org.junit.*;\n\npublic class CsvTest2 {\n private SparkSession sparkSession;\n\n @Before\n public void init() throws IllegalArgumentException, IOException {\n this.sparkSession = SparkSession.builder().master(\"local\").appName(\"spark session example\").getOrCreate();\n }\n\n @Test\n public void tesCsv() {\n Dataset dataset = this.sparkSession.read().format(\"csv\").option(\"header\", \"true\").option(\"\", \"\")\n .load(\"/tmp/data2.csv\");\n \n List l = dataset.collectAsList();\n // String title[] = { \"Nome\", \"Nota\" };\n for (Row row : l) {\n int s = row.length();\n for (int i = 0; i < s; i++) {\n // System.out.println(columns[i] + \" : \" + row.getString(i));\n }\n }\n String title[] = { \"Nome\", \"stdDev(Nota)\" };\n dataset.printSchema();\n Dataset stddev = dataset.groupBy(\"Nome\").agg(stddev_pop(\"Nota\"));\n System.out.println(stddev);\n l = stddev.collectAsList();\n for (Row row : l) {\n int s = row.length();\n for (int i = 0; i < s; i++) {\n Object value;\n try {\n value = row.getDouble(i);\n } catch (Exception e) {\n value = row.getString(i);\n }\n System.out.println(title[i] + \" : \" + value);\n }\n }\n }\n}\n```\n\n#### Spark SQL \n\nSpark SQL is a Spark module for structured data processing. Unlike the basic \nSpark RDD API, the interfaces provided by Spark SQL provide Spark with more \ninformation about the structure of both the data and the computation being \nperformed. Internally, Spark SQL uses this extra information to perform \n**extra optimizations**. There are several ways to interact with Spark SQL \nincluding SQL and the Dataset API. When computing a result the same execution \nengine is used, independent of which API/language you are using to express \nthe computation. This unification means that developers can easily switch \nback and forth between different APIs based on which provides the most \nnatural way to express a given transformation.\n\nOne use of Spark SQL is to execute SQL queries. Spark SQL can also be used \nto read data from an existing Apache Hive installation (see section bellow). \nWhen running SQL from within another programming language, like Java, the \nresults will be returned as a Dataset/DataFrame. You can also interact with \nthe SQL interface using the command-line or over JDBC/ODBC.\n\n##### Running SQL Queries Programmatically\n\nThe sql function on a SparkSession enables applications to run SQL queries \nprogrammatically and returns the result as a Dataset.\n\n```java\nimport org.apache.spark.sql.Dataset;\nimport org.apache.spark.sql.Row;\n\n// Start with JSON Dataset\nDataset df = spark.read().json(\"examples/src/main/resources/people.json\");\n// Print the schema in a tree format\ndf.printSchema();\n// root\n// |-- age: long (nullable = true)\n// |-- name: string (nullable = true)\n\n// Now the same Schema on SQL Database.\n\n// Register the DataFrame as a SQL temporary view\ndf.createOrReplaceTempView(\"people\");\n\nDataset sqlDF = spark.sql(\"SELECT * FROM people\");\nsqlDF.show();\n\n// +----+-------+\n// | age| name|\n// +----+-------+\n// |null|Michael|\n// | 30| Andy|\n// | 19| Justin|\n// +----+-------+\n\n// Count people by age\nsqlDF.groupBy(\"age\").count().show();\n// +----+-----+\n// | age|count|\n// +----+-----+\n// | 19| 1|\n// |null| 1|\n// | 30| 1|\n// +----+-----+\n\n```\n\nFind full example code at \"examples/src/main/java/org/apache/spark/examples/sql/JavaSparkSQLExample.java\" in the Spark Github repo.\n\n\n#### Persistence with Apache Hive\n\nSpark use Apache Hive SQL Persistence layer. \n\nThe Apache Hive data warehouse software facilitates reading, writing, and \nmanaging large datasets residing in distributed storage using SQL. \nHive is built on top of Apache Hadoop.\n\nSee [distributed sql engine](http://spark.apache.org/docs/latest/sql-programming-guide.html#distributed-sql-engine)\nfor details.\n\n#### More on Spark 2.0\n\n[http://blog.madhukaraphatak.com/categories/spark-two](http://blog.madhukaraphatak.com/categories/spark-two/)\n\nTo convert the code from **Scala** to **Java** use this **pom.xml** dependencies :\n\n```xml\n \n \n org.apache.spark\n spark-core_2.11\n 2.0.2\n \n \n org.apache.spark\n spark-sql_2.11\n 2.0.2\n \n \n \n org.apache.hadoop\n hadoop-client\n 2.7.3\n \n . . . \n```\n\n## How to build\n\nIf you plan to change the Spark version on the pom.xml file you will need\nto re-create the `m2-repo` directory again. To do this use the command \nbelow to start the container.\n\n```bash\nmv m2-repo m2-repo-old\n\ndocker run -i -t -h my-spark --rm \\\n --name my-spark \\\n -v $PWD/m2-repo:/root/.m2/repository \\\n -p 8080:8080 \\\n -p 7077:7077 \\\n parana/spark bash\n\nrm -rf m2-repo-old\n```\n\nDoing this m2-repo will be updated on Host and a next build will be much\nfaster because it will use the artifacts in the **Local Maven Repository**\nand will not need to download again.\n\n## Using Jupyter Notebook\n\nRun this comand below on Container Bash prompt.\n\n```bash\njupyter notebook --no-browser --ip spark.local\n```\n\nand `open http://spark.local:8888` on host computer.\n\n\nThen, you can see on host computer something like this:\n\n![Jupyter na porta 8888](assets/img/jupyter-na-8888.png)\n\n\n","has_starred","hub_user","immutable_tags_settings",{"_75":11,"_76":77},"enabled","rules",[78],".*","is_automated","permissions",{"_82":21,"_83":11,"_84":11},"read","write","admin","user","storage_size",13938325995,"orgData","recentTags",[91,129],{"_92":44,"_93":94,"_95":96,"_97":98,"_99":100,"_50":118,"_119":94,"_120":33,"_121":56,"_57":122,"_123":124,"_125":109,"_126":118,"_127":65,"_128":21},"content_type","creator",153412,"full_size",1122018750,"id",4086375,"images",[101],{"_102":103,"_104":105,"_106":107,"_108":109,"_110":111,"_112":113,"_114":107,"_115":-5,"_116":96,"_63":65,"_117":-5},"architecture","amd64","digest","sha256:83a9feab024d26076cb03576f79c766e82653d0de3a7bb3715dfdaf20b2377c1","features","","last_pulled","2026-09-29T18:56:14.801678441Z","last_pushed","2016-12-02T11:10:08Z","os","linux","os_features","os_version","size","variant","2016-12-02T11:10:07.415731Z","last_updater","last_updater_username","media_type","latest","repository",829906,"tag_last_pulled","tag_last_pushed","tag_status","v2",{"_92":44,"_93":94,"_95":130,"_97":131,"_99":132,"_50":137,"_119":94,"_120":33,"_121":56,"_57":138,"_123":124,"_125":135,"_126":137,"_127":65,"_128":21},2565166366,50607422,[133],{"_102":103,"_104":134,"_106":107,"_108":135,"_110":136,"_112":113,"_114":107,"_115":-5,"_116":130,"_63":65,"_117":-5},"sha256:7c1193dc3ef171cd15db301514150e6fb326ccd485a64e5b830fedb49f99d5ae","2026-09-29T18:56:15.352411843Z","2019-03-24T19:25:55Z","2019-03-24T19:25:54.572278Z","2.4.0","sbxKitMetadata","isPotentialSpam","isHubSbxKitsEnabled","showSbxLogoOverride","sbxTrademarkText","displaySecurityMetadata","tagAttestations","tagsHaveAttestations",[],"routes/_layout.r.$namespace.$reponame.tags",{"_38":150,"_157":158,"_146":171,"_172":11},{"_40":151,"_42":152,"_45":46,"_47":48,"_49":11,"_50":51,"_52":53,"_54":153,"_57":35,"_32":33,"_58":59,"_60":44,"_61":62,"_63":62,"_64":65,"_66":-5,"_67":68,"_69":70,"_71":11,"_72":33,"_73":154,"_79":21,"_80":156,"_85":33,"_86":87},[],[44],[56],{"_75":11,"_76":155},[78],{"_82":21,"_83":11,"_84":11},"tags",{"_159":160,"_161":-5,"_162":-5,"_163":164},"count",2,"next","previous","results",[165,168],{"_92":44,"_93":94,"_95":130,"_97":131,"_99":166,"_50":137,"_119":94,"_120":33,"_121":56,"_57":138,"_123":124,"_125":135,"_126":137,"_127":65,"_128":21},[167],{"_102":103,"_104":134,"_106":107,"_108":135,"_110":136,"_112":113,"_114":107,"_115":-5,"_116":130,"_63":65,"_117":-5},{"_92":44,"_93":94,"_95":96,"_97":98,"_99":169,"_50":118,"_119":94,"_120":33,"_121":56,"_57":122,"_123":124,"_125":109,"_126":118,"_127":65,"_128":21},[170],{"_102":103,"_104":105,"_106":107,"_108":109,"_110":111,"_112":113,"_114":107,"_115":-5,"_116":96,"_63":65,"_117":-5},[],"canDeleteTags","actionData","errors"]

parana/spark

Tags for parana/spark