scala.language.postfixOps Scala Examples

package scorch.sandbox.rnn

import botkop.numsca.Tensor
import botkop.{numsca => ns}
import scorch.autograd._
import scorch.nn.Module

import scala.language.postfixOps

case class WordEmbedding(w: Variable) extends Module(Seq(w)) {
  override def forward(x: Variable): Variable =
    WordEmbeddingFunction(x, w).forward()
}

object WordEmbedding {

  
  def apply(v: Int, d: Int): WordEmbedding = {
    val w = ns.randn(v, d)
    WordEmbedding(Variable(w))
  }
}

case class WordEmbeddingFunction(x: Variable, w: Variable) extends Function {

  val List(n, t) = x.shape
  val List(v, d) = w.shape

  override def forward(): Variable = {
    // todo: write idiomatic implementation in numsca
    val out = for {
      i <- 0 until n
      j <- 0 until t
    } yield {
      val wix = x.data(i, j).squeeze().toInt
      w.data(wix).data
    }

    val td = Tensor(out.toArray.flatten).reshape(n, t, d)

    Variable(td, Some(this))
  }

  override def backward(gradOutput: Variable): Unit = {

    // x = n * t
    // w = v * d
    // g = n * t * d

    val dW = ns.zerosLike(w.data)

    for {
      i <- 0 until n
      j <- 0 until t
    } {
      val gWord = gradOutput.data(i, j).reshape(1, d)
      val wordIx = x.data(i, j).squeeze().toInt
      dW(wordIx) += gWord
    }

    w.backward(Variable(dW))
    x.backward()
  }

} 

package io.coral.actors.transform

import akka.actor.{ActorSystem, Props}
import akka.testkit.{ImplicitSender, TestActorRef, TestKit, TestProbe}
import akka.util.Timeout
import io.coral.lib.{NotSoRandom, Random}
import org.json4s._
import org.json4s.jackson.JsonMethods._
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

import scala.concurrent.duration._
import scala.language.postfixOps

class SampleActorSpec(_system: ActorSystem)
	extends TestKit(_system)
	with ImplicitSender
	with WordSpecLike
	with Matchers
	with BeforeAndAfterAll
	with ScalaFutures {
	def this() = this(ActorSystem("SampleActorSpec"))

	override def afterAll() {
		TestKit.shutdownActorSystem(system)
	}

	def arbitrarySampleActor(): SampleActor = {
		val json = parse(
			"""{ "type": "sample",
			  | "params": { "fraction": 0.707 } }
			""".stripMargin)
		val props = SampleActor(json).get
		TestActorRef[SampleActor](props).underlyingActor
	}

	def notSoRandomSampleActor(fraction: Double, randoms: Double*): SampleActor = {
		val json = parse(
			s"""{ "type": "sample", "params": { "fraction": ${fraction} } }
     		 """.stripMargin)
		val source = NotSoRandom(randoms: _*)
		val props = Props(classOf[SampleActor], json, Random(source))
		TestActorRef[SampleActor](props).underlyingActor
	}

	implicit val timeout = Timeout(100 millis)

	"A SampleActor" should {

		"Be instantiated with sample fraction" in {
			val json = parse("""{ "type": "sample", "params": { "fraction": 0.5 }}""".stripMargin)
			val props = SampleActor(json).get
			props.actorClass() should be(classOf[SampleActor])
			val actor = TestActorRef[SampleActor](props).underlyingActor
			actor.fraction should be(0.5)
		}

		"Not be instantiated without fraction or percentage" in {
			val json = parse("""{ "type": "sample", "params": { "bla": "blabla" }}""".stripMargin)
			SampleActor(json) should be(None)
		}

		"Be constructible with a io.coral.lib.Random for random boolean stream" in {
			val actor = notSoRandomSampleActor(fraction = 0.5, randoms = 0.1, 0.49, 0.50, 0.51, 0.8, 0.4)
			actor.next() should be(true)
			actor.next() should be(true)
			actor.next() should be(false)
			actor.next() should be(false)
			actor.next() should be(false)
			actor.next() should be(true)
		}

		"Should trigger true or false according to random binomial sequence" in {
			val actor = notSoRandomSampleActor(fraction = 0.7, randoms = 0.8, 0.6)
			val json = parse( """{ "something": "whatever" }""").asInstanceOf[JObject]

			val result1 = actor.simpleEmitTrigger(json)
			result1 should be(Some(JNothing))

			val result2 = actor.simpleEmitTrigger(json)
			result2 should be(Some(json))
		}

		"Should have trigger and emit cooperate" in {
			val actor = notSoRandomSampleActor(fraction = 0.7, randoms = 0.6, 0.8)
			val ref = actor.self
			val json = parse( """{ "something": "whatever" }""").asInstanceOf[JObject]
			val probe = TestProbe()
			actor.emitTargets += probe.ref
			ref ! json
			probe.expectMsg(json)
			ref ! json
			probe.expectNoMsg(100 millis)
		}
	}
} 

package com.github.dnvriend.spark.dataset

import com.github.dnvriend.TestSpec
import com.github.dnvriend.spark._

import scala.language.postfixOps

// note: in dutch, a tree is called 'boom'
class ReadTreesTest extends TestSpec {
  val oldestTree =
    Tree("BOMEN.fid-42c8dacd_14bfe306016_aff", "950572", "boom in verharding", "Onbekend", Some("overig"), Some(8586), "Verharding", "POINT (147106.879 483519.092)")

  it should "get the oldest tree using sql" in withTrees { spark => trees =>
    import spark.implicits._
    trees.createOrReplaceTempView("trees")
    trees.show(10, truncate = false)

    // number of trees in the dataset
    trees.count shouldBe 148648 // 148k trees in the city

    trees.sqlContext.sql("FROM trees ORDER BY jaar DESC LIMIT 1").as[Tree].head shouldBe oldestTree
  }

  it should "get the oldest tree using dsl" in withTrees { spark => trees =>
    import spark.implicits._
    trees
      .orderBy('jaar.desc)
      .limit(1)
      .head shouldBe oldestTree
  }

  it should "get the tree family there is most of" in withTrees { spark => trees =>
    import spark.implicits._
    import org.apache.spark.sql.functions._
    trees
      .filter('soort isNotNull)
      .filter('soort notEqual "overig")
      .groupBy('soort)
      .agg(count('soort).as("count"))
      .orderBy('count.desc)
      .select('soort)
      .limit(1)
      .as[String].head shouldBe "Populier"
  }
} 

package com.eharmony.aloha.dataset.vw.labeled

import com.eharmony.aloha.dataset.SparseFeatureExtractorFunction
import com.eharmony.aloha.semantics.func.GenFunc.f0
import org.junit.Assert._
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.BlockJUnit4ClassRunner

import scala.language.{postfixOps, implicitConversions}

@RunWith(classOf[BlockJUnit4ClassRunner])
final class VwLabelRowCreatorTest {

    private[this] val lab = 3d
    private[this] val imp0 = 0d
    private[this] val imp1 = 1d
    private[this] val imp2 = 2d
    private[this] val emptyTag = ""
    private[this] val tag = "t"

    private[this] implicit def liftToOption[A](a: A): Option[A] = Option(a)

    private[this] def spec(lab: Option[Double] = None, imp: Option[Double] = None, tag: Option[String] = None): VwLabelRowCreator[Any] = {
        val fef = new SparseFeatureExtractorFunction[Any](Vector("f1" -> f0("Empty", _ => Nil)))
        VwLabelRowCreator(fef, 0 to 0 toList, Nil, None, f0("", _ => lab), f0("", _ => imp), f0("", _ => tag))
    }

    private[this] def testLabelRemoval(spec: VwLabelRowCreator[Any], exp: String = ""): Unit = assertEquals(exp, spec(())._2.toString)

    // All of these should return empty label because the Label function returns a missing label.
    @Test def testS___() = testLabelRemoval(spec())
    @Test def testS__e() = testLabelRemoval(spec(tag = emptyTag))
    @Test def testS__t() = testLabelRemoval(spec(tag = tag))
    @Test def testS_0_() = testLabelRemoval(spec(imp = imp0))
    @Test def testS_0e() = testLabelRemoval(spec(imp = imp0, tag = emptyTag))
    @Test def testS_0t() = testLabelRemoval(spec(imp = imp0, tag = tag))
    @Test def testS_1_() = testLabelRemoval(spec(imp = imp1))
    @Test def testS_1e() = testLabelRemoval(spec(imp = imp1, tag = emptyTag))
    @Test def testS_1t() = testLabelRemoval(spec(imp = imp1, tag = tag))
    @Test def testS_2_() = testLabelRemoval(spec(imp = imp2))
    @Test def testS_2e() = testLabelRemoval(spec(imp = imp2, tag = emptyTag))
    @Test def testS_2t() = testLabelRemoval(spec(imp = imp2, tag = tag))

    // Importance not provided makes entire label vanish
    @Test def testS1_e() = testLabelRemoval(spec(lab = lab, tag = emptyTag))
    @Test def testS1_t() = testLabelRemoval(spec(lab = lab, tag = tag))

    // Importance of zero is given explicitly.
    @Test def testS10_() = testLabelRemoval(spec(lab = lab, imp = imp0), "3 0 |")
    @Test def testS10e() = testLabelRemoval(spec(lab = lab, imp = imp0, tag = emptyTag), "3 0 |")
    @Test def testS10t() = testLabelRemoval(spec(lab = lab, imp = imp0, tag = tag), "3 0 t|")

    // Importance of 1 is omitted.
    @Test def testS11_() = testLabelRemoval(spec(lab = lab, imp = imp1), "3 |")
    @Test def testS11e() = testLabelRemoval(spec(lab = lab, imp = imp1, tag = emptyTag), "3 |")
    @Test def testS11t() = testLabelRemoval(spec(lab = lab, imp = imp1, tag = tag), "3 t|")

    @Test def testS12_() = testLabelRemoval(spec(lab = lab, imp = imp2), "3 2 |")
    @Test def testS12e() = testLabelRemoval(spec(lab = lab, imp = imp2, tag = emptyTag), "3 2 |")
    @Test def testS12t() = testLabelRemoval(spec(lab = lab, imp = imp2, tag = tag), "3 2 t|")


    @Test def testStringLabel() {
        val spec = new VwLabelRowCreator(
            new SparseFeatureExtractorFunction(Vector("f1" -> f0("Empty", (_: Double) => Nil))),
            0 to 0 toList,
            Nil,
            None,
            f0("", (s: Double) => Option(s)),  // Label
            f0("", (_: Double) => Option(1d)), // Importance
            f0("", (_: Double) => None))       // Tag

        val values = Seq(
            -1.0                 -> "-1",
            -0.99999999999999999 -> "-1",
            -0.9999999999999999  -> "-0.9999999999999999",
            -1.0E-16             -> "-0.0000000000000001",
            -1.0E-17             -> "-0.00000000000000001",
            -1.0E-18             -> "-0",
             0.0                 ->  "0",
             1.0E-18             ->  "0",
             1.0E-17             ->  "0.00000000000000001",
             1.0E-16             ->  "0.0000000000000001",
             0.9999999999999999  ->  "0.9999999999999999",
             0.99999999999999999 ->  "1",
             1.0                 ->  "1"
        )

        values foreach { case(v, ex) => assertEquals(s"for line: $v", Option(ex), spec.stringLabel(v)) }
    }
} 

package de.gccc.jib

import java.io.File

import sbt._
import sbt.io.{ IO, PathFinder }

import scala.language.postfixOps


  def fromClasspath(entries: Seq[Attributed[File]],
                    target: String,
                    includeArtifact: Artifact => Boolean,
                    includeOnNoArtifact: Boolean = false): Seq[(File, String)] =
    entries.filter(attr => attr.get(sbt.Keys.artifact.key) map includeArtifact getOrElse includeOnNoArtifact).map {
      attribute =>
        val file = attribute.data
        file -> s"$target/${file.getName}"
    }

} 

package im.tox.tox4j.core

import im.tox.core.network.Port
import im.tox.tox4j.DhtNodeSelector.node
import im.tox.tox4j.TestConstants.Timeout
import im.tox.tox4j._
import im.tox.tox4j.core.NetworkTest.logger
import im.tox.tox4j.core.data.ToxPublicKey
import im.tox.tox4j.impl.jni.ToxCoreImplFactory.{ withToxUnit, withToxes }
import org.scalatest.FlatSpec
import org.scalatest.concurrent.Timeouts
import org.slf4j.LoggerFactory

import scala.language.postfixOps

object NetworkTest {
  private val logger = LoggerFactory.getLogger(classOf[NetworkTest])
  private val ToxCount = 10
}

@SuppressWarnings(Array("org.wartremover.warts.While"))
final class NetworkTest extends FlatSpec with Timeouts {

  // TODO(iphydf): Figure out why the bootstrap tests all fail on Travis.
  

  "LAN discovery" should "connect all nodes" in {
    failAfter(Timeout) {
      withToxes(NetworkTest.ToxCount) { toxes =>
        val action = s"Connecting all of ${toxes.size} toxes with LAN discovery"
        logger.info(action)

        val start = System.currentTimeMillis

        while (!toxes.isAllConnected) {
          toxes.iterate()
          Thread.sleep(toxes.iterationInterval)
        }

        val end = System.currentTimeMillis

        logger.info(s"$action took ${end - start} ms")
      }
    }
  }

  it should "connect at least one instance" in {
    failAfter(Timeout) {
      withToxes(NetworkTest.ToxCount) { toxes =>
        val action = s"Connecting one of ${toxes.size} toxes with LAN discovery"
        logger.info(action)

        val start = System.currentTimeMillis

        while (!toxes.isAnyConnected) {
          toxes.iterate()
          try {
            Thread.sleep(toxes.iterationInterval)
          } catch {
            case e: InterruptedException =>
          }
        }

        val end = System.currentTimeMillis

        logger.info(s"$action took ${end - start} ms")
      }
    }
  }

} 

package caliban

import scala.language.postfixOps
import caliban.ExampleData._
import caliban.ExampleService.ExampleService
import caliban.GraphQL.graphQL
import caliban.schema.Annotations.{ GQLDeprecated, GQLDescription }
import caliban.schema.GenericSchema
import caliban.wrappers.ApolloTracing.apolloTracing
import caliban.wrappers.Wrappers.{ maxDepth, maxFields, printSlowQueries, timeout }
import zio.URIO
import zio.clock.Clock
import zio.console.Console
import zio.duration._
import zio.stream.ZStream

object ExampleApi extends GenericSchema[ExampleService] {

  case class Queries(
    @GQLDescription("Return all characters from a given origin")
    characters: CharactersArgs => URIO[ExampleService, List[Character]],
    @GQLDeprecated("Use `characters`")
    character: CharacterArgs => URIO[ExampleService, Option[Character]]
  )
  case class Mutations(deleteCharacter: CharacterArgs => URIO[ExampleService, Boolean])
  case class Subscriptions(characterDeleted: ZStream[ExampleService, Nothing, String])

  implicit val roleSchema           = gen[Role]
  implicit val characterSchema      = gen[Character]
  implicit val characterArgsSchema  = gen[CharacterArgs]
  implicit val charactersArgsSchema = gen[CharactersArgs]

  val api: GraphQL[Console with Clock with ExampleService] =
    graphQL(
      RootResolver(
        Queries(
          args => ExampleService.getCharacters(args.origin),
          args => ExampleService.findCharacter(args.name)
        ),
        Mutations(args => ExampleService.deleteCharacter(args.name)),
        Subscriptions(ExampleService.deletedEvents)
      )
    ) @@
      maxFields(200) @@               // query analyzer that limit query fields
      maxDepth(30) @@                 // query analyzer that limit query depth
      timeout(3 seconds) @@           // wrapper that fails slow queries
      printSlowQueries(500 millis) @@ // wrapper that logs slow queries
      apolloTracing // wrapper for https://github.com/apollographql/apollo-tracing

} 

package scorch.nn

import botkop.{numsca => ns}
import org.nd4j.linalg.api.buffer.DataBuffer
import org.nd4j.linalg.factory.Nd4j
import org.scalatest.{FlatSpec, Matchers}
import scorch.autograd.Variable
import scorch._
import scorch.autograd.Variable._
import scorch.TestUtil._
import scorch.nn.ParallelModule.ParallelizeFunction

import scala.concurrent.duration._
import scala.language.postfixOps
import scala.util.Random

class ParallelModuleSpec extends FlatSpec with Matchers {

  Nd4j.setDataType(DataBuffer.Type.DOUBLE)
  ns.rand.setSeed(231)
  Random.setSeed(231)

  "A Parallelization module" should "correctly reconstitute output in forward pass" in {
    val batchSize = 32
    val numFeatures = 20

    case class Net() extends Module {
      override def forward(x: Variable): Variable = Variable(x.data.copy())
    }

    val net = Net()
    val p = ParallelModule(net, parallelism = 4)
    val input = Variable(ns.randn(batchSize, numFeatures))
    val yHat = p(input)

    assert(yHat.data.sameElements(input.data))
    assert(yHat.data.sameShape(input.data))
  }

  it should "update the gradients of the module" in {
    val batchSize = 32
    val numFeatures = 20
    val numClasses = 10

    case class Net() extends Module {
      val fc = Linear(numFeatures, numClasses)
      override def forward(x: Variable): Variable = x ~> fc ~> relu
    }
    val net = Net()

    val parCopies = net.parameters.map { p =>
      Variable(p.data.copy())
    }

    val p = ParallelModule(net, parallelism = 4)

    val input = Variable(ns.randn(batchSize, numFeatures))

    val yHat = p(input)

    val target = Variable(ns.randint(numClasses, Array(batchSize, 1)))
    val loss = softmaxLoss(yHat, target)

    loss.backward()

    net.parameters.map(_.grad).foreach(println)

    net.parameters.foreach { p =>
      assert(p.grad.data.sameShape(p.data))
      assert(ns.sum(p.grad.data) != 0.0)
    }

  }

  "The parallelization function" should "calulate the correct gradients" in {
    val batchSize = 90
    val numFeatures = 20
    val numClasses = 10
    case class Net() extends Module {
      val fc = Linear(numFeatures, numClasses)
      override def forward(x: Variable): Variable = x ~> fc ~> relu
    }
    val net = Net()

    def f(a: Variable) =
      ParallelizeFunction(a,
                          module = net,
                          parallelism = 4)
        .forward()

    val input = Variable(ns.randn(batchSize, numFeatures))
    oneOpGradientCheck(f, input, 1e-7)
  }

} 

package scorch.data.loader

import botkop.numsca.Tensor
import botkop.{numsca => ns}
import org.nd4j.linalg.api.buffer.DataBuffer
import org.nd4j.linalg.factory.Nd4j
import org.scalatest.{FlatSpec, Matchers}
import scorch._
import scorch.autograd.Variable
import scorch.nn.cnn.{Conv2d, MaxPool2d}
import scorch.nn.{Linear, Module}
import scorch.optim.Adam

import scala.concurrent.duration._
import scala.language.postfixOps
import scala.util.Random

class DataLoaderSpec extends FlatSpec with Matchers {

  Nd4j.setDataType(DataBuffer.Type.DOUBLE)
  ns.rand.setSeed(231)
  Random.setSeed(231)

  "A cifar-10 loader" should "load data" in {

    val miniBatchSize = 8
    val take = 10

    val loader =
      new Cifar10DataLoader(miniBatchSize = miniBatchSize,
                            mode = "train",
                            take = Some(take * miniBatchSize)).toSeq

    assert(loader.size == take)

    loader.foreach {
      case (x, y) =>
        assert(x.shape.head == miniBatchSize)
        // assert(x.shape(1) == 3 * 32 * 32)
        assert(y.shape.head == miniBatchSize)
        assert(y.shape(1) == 1)
    }
  }

  it should "feed a network" in {

    val batchSize = 16
    val numBatches = 2
    val numEpochs = 5
    val parallelism = 8

    val (numChannels, imageSize) = (3, 32)
    val inputShape = List(batchSize, numChannels, imageSize, imageSize)
    val numClasses = 10

    case class Net() extends Module {
      val conv = Conv2d(numChannels = 3,
                        numFilters = 4,
                        filterSize = 5,
                        weightScale = 1e-3,
                        stride = 1,
                        pad = 1)
      val pool = MaxPool2d(poolSize = 2, stride = 2)
      val numFlatFeatures: Int =
        pool.outputShape(conv.outputShape(inputShape)).tail.product
      def flatten(v: Variable): Variable = v.reshape(-1, numFlatFeatures)
      val fc = Linear(numFlatFeatures, numClasses)

      override def forward(x: Variable): Variable =
        x ~> conv ~> relu ~> pool ~> flatten ~> fc ~> relu
    }

    val net = Net().par(parallelism)

    val optimizer = Adam(net.parameters, lr = 0.01)
    val loader = new Cifar10DataLoader(miniBatchSize = batchSize,
                                       mode = "train",
                                       take = Some(numBatches * batchSize))

    val seq = loader.toSeq

    for (epoch <- 1 to numEpochs) {
      seq.zipWithIndex
        .foreach {
          case ((x, y), i) =>
            optimizer.zeroGrad()
            val yHat = net(x)
            val loss = softmaxLoss(yHat, y)

            val guessed = ns.argmax(yHat.data, axis = 1)
            val accuracy = ns.sum(y.data == guessed) / batchSize
            println(
              s"$epoch:$i: loss: ${loss.data.squeeze()} accuracy: $accuracy")

            loss.backward()
            optimizer.step()
        }
    }
  }
} 

package recfun

import stainless.lang._
import stainless.collection._
import scala.language.postfixOps

object Main {
  // Exercise 1
  def pascal(c: BigInt, r: BigInt): BigInt = {
    require(c>=0 && r>=0 && c<=r)
    decreases(r)
    if(c==0) 1
    else if(r==c) 1
    else pascal(c-1, r-1) + pascal(c, r-1)
  }

  def checkPascal(c: BigInt): Boolean = {
    c<0 || pascal(c, c) == 1
  }.holds

  def checkPascal2(c: BigInt, r: BigInt): Boolean = {
    require(c>=0 && r>=0 && c<=r)
    pascal(c,r)==1 || pascal(c,r) == pascal(c-1,r-1) + pascal(c,r-1)
  }.holds

  // Exercise 2
  def balance(chars: List[Char]): Boolean = {
     def recbalance(chars: List[Char], n: BigInt) : Boolean = {
       decreases(chars)
       if (n < 0) false
       else if (chars.isEmpty) {
        if (n == 0) true
        else false
       }
       else if (chars.head == '(') recbalance(chars.tail, n+1)
       else if (chars.head == ')') recbalance(chars.tail, n-1)
       else recbalance(chars.tail, n)
     }
     recbalance(chars, 0)
  }

  def checkBalance(chars: List[Char]) : Boolean = {
    !balance(')' :: chars)
  }.holds

  // Exercise 3
  def distinct[T](l: List[T]): Boolean = {
    decreases(l)
    l match {
      case Nil() => true
      case Cons(x,xs) => !xs.contains(x) && distinct(xs)
    }
  }

  def max(x: BigInt, y: BigInt) = if (x > y) x else y

  def countChange(money: BigInt, coins: List[BigInt]): BigInt = {
    require(coins.forall(_ > 0) && distinct(coins))
    decreases(max(0, money), coins)

    if (money == 0) BigInt(1)
    else if (money < 0 || coins.isEmpty) BigInt(0)
    else countChange(money-coins.head, coins) + countChange(money, coins.tail)
  } ensuring(_ >= 0)
} 

package scorch.data.loader

import botkop.numsca.Tensor
import com.typesafe.scalalogging.LazyLogging
import scorch.autograd.Variable

import scala.io.Source
import scala.language.postfixOps
import scala.util.Random

class MnistDataLoader(val mode: String,
                      miniBatchSize: Int,
                      take: Option[Int] = None,
                      seed: Long = 231)
    extends DataLoader
    with LazyLogging {

  val file: String = mode match {
    case "train"    => "data/mnist/mnist_train.csv"
    case "validate" => "data/mnist/mnist_test.csv"
  }

  val numEntries: Int =
    Source.fromFile(file).getLines().length

  override val numSamples: Int = take match {
    case Some(n) => math.min(n, numEntries)
    case None    => numEntries
  }

  override val numBatches: Int =
    (numSamples / miniBatchSize) +
      (if (numSamples % miniBatchSize == 0) 0 else 1)

  // this should fit in memory
  val data: Seq[(Variable, Variable)] = Random
    .shuffle(
      Source
        .fromFile(file)
        .getLines()
    )
    .take(take.getOrElse(numSamples))
    .sliding(miniBatchSize, miniBatchSize)
    .map { lines =>
      val (xData, yData) = lines
        .foldLeft(List.empty[Float], List.empty[Float]) {
          case ((xs, ys), line) =>
            val tokens = line.split(",")
            val (y, x) =
              (tokens.head.toFloat, tokens.tail.map(_.toFloat / 255).toList)
            (x ::: xs, y :: ys)
        }

      val x = Variable(Tensor(xData.toArray).reshape(yData.length, 784))
      val y = Variable(Tensor(yData.toArray).reshape(yData.length, 1))

    (x, y)
  } toSeq

  override def iterator: Iterator[(Variable, Variable)] = data.toIterator

} 

package com.karasiq.bootstrap.carousel

import scala.language.postfixOps
import scala.scalajs.js

import rx.Rx

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.JSRenderingContext
import com.karasiq.bootstrap.icons.Icons
import com.karasiq.bootstrap.jquery.BootstrapJQueryContext
import com.karasiq.bootstrap.utils.Utils

trait JSCarousels extends UniversalCarousels { self: JSRenderingContext with Carousels with Utils with Icons with BootstrapComponents with BootstrapJQueryContext ⇒
  import scalaTags.all._

  type Carousel = JSCarousel
  object Carousel extends CarouselFactory {
    def apply(data: Rx[Seq[Modifier]], id: String = Bootstrap.newId): JSCarousel = {
      new JSCarousel(id, data)
    }

    def slide(image: String, content: Modifier*): Modifier = {
      UniversalCarousel.slide(image, content)
    }
  }

  class JSCarousel(carouselId: String, content: Rx[Seq[Modifier]]) extends UniversalCarousel(carouselId, content) {
    def create(interval: Int = 5000, pause: String = "hover",
               wrap: Boolean = true, keyboard: Boolean = true,
               modifiers: Modifier = Bootstrap.noModifier): Element = {
      val element = carousel(modifiers).render
      val options = js.Object().asInstanceOf[JSCarouselOptions]
      options.interval = interval
      options.pause = pause
      options.wrap = wrap
      options.keyboard = keyboard
      jQuery(element).carousel(options)
      element
    }

    override def render(md: Modifier*): Modifier = {
      create(modifiers = md)
    }
  }
} 

package com.karasiq.bootstrap.modal

import scala.language.postfixOps
import scala.scalajs.js
import scala.scalajs.js.|

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.JSRenderingContext
import com.karasiq.bootstrap.jquery.BootstrapJQueryContext

trait JSModals { self: JSRenderingContext with Modals with BootstrapComponents with BootstrapJQueryContext ⇒
  implicit class JSModalOps(modal: Modal) {
    def show(backdrop: Boolean | String = true, keyboard: Boolean = true,
             show: Boolean = true, events: Map[String, js.Any] = Map.empty): Unit = {

      val dialog = jQuery(modal.renderTag().render)
      val options = js.Object().asInstanceOf[JSModalOptions]
      options.backdrop = backdrop
      options.keyboard = keyboard
      options.show = show
      dialog.modal(options)

      dialog.on("hidden.bs.modal", () ⇒ {
        // Remove from DOM
        dialog.remove()
      })

      events.foreach { case (event, handler) ⇒
        dialog.on(event, handler)
      }

      dialog.modal("show")
    }
  }
} 

package com.karasiq.bootstrap.popover

import scala.language.postfixOps

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.JSRenderingContext
import com.karasiq.bootstrap.jquery.BootstrapJQueryContext
import com.karasiq.bootstrap.tooltip.Tooltips

trait JSPopovers { self: JSRenderingContext with BootstrapComponents with Popovers with Tooltips with BootstrapJQueryContext ⇒
  import scalaTags.all._

  class JSPopover(val options: PopoverOptions) extends Popover {
    def toggle: Modifier = new Modifier {
      def applyTo(t: Element): Unit = {
        val jsOptions = scalajs.js.Object().asInstanceOf[JSPopoverOptions]
        def set(value: String, f: String ⇒ Unit) = if (value.nonEmpty) f(value)
        jsOptions.animation = options.animation
        jsOptions.content = options.content.render
        jsOptions.title = options.title.render
        jsOptions.html = options.html
        jsOptions.placement = options.placement.toString
        set(options.container, jsOptions.container = _)
        set(options.delay, jsOptions.delay = _)
        set(options.selector, jsOptions.selector = _)
        set(options.template, jsOptions.template = _)
        set(options.trigger, jsOptions.trigger = _)
        set(options.viewport, jsOptions.viewport = _)
        jQuery(t).popover(jsOptions)
      }
    }

    override def render(md: Modifier*): Modifier = {
      toggle +: md
    }
  }

  
  object Popover extends PopoverFactory {
    def apply(title: Frag, content: Frag, placement: TooltipPlacement = TooltipPlacement.auto): JSPopover = {
      new JSPopover(PopoverOptions(html = true, title = title, content = content, placement = placement))
    }
  }
} 

package com.karasiq.bootstrap

import scala.language.postfixOps

import rx.Ctx

import com.karasiq.bootstrap.carousel.JSCarousels
import com.karasiq.bootstrap.context.JSRenderingContext
import com.karasiq.bootstrap.jquery.BootstrapJQueryContext
import com.karasiq.bootstrap.modal.JSModals
import com.karasiq.bootstrap.navbar.JSNavigationBars
import com.karasiq.bootstrap.popover.JSPopovers
import com.karasiq.bootstrap.tooltip.JSTooltips

// JS components implementation
trait JSBootstrapBundle extends UniversalBootstrapBundle with JSRenderingContext with JSModals with JSTooltips
  with JSPopovers with JSNavigationBars with JSCarousels with BootstrapJQueryContext

object JSBootstrapBundle {
  def apply()(implicit rx: Ctx.Owner): JSBootstrapBundle = {
    new JSBootstrapBundle {
      implicit val scalaRxContext = rx
    }
  }
} 

package com.karasiq.bootstrap.buttons

import scala.language.postfixOps

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.{ClassModifiers, RenderingContext}
import com.karasiq.bootstrap.utils.Utils

trait Buttons extends ButtonStyles with ButtonGroups with ButtonStates { self: RenderingContext with BootstrapComponents with ClassModifiers with Utils ⇒
  import scalaTags.all._

  type Button <: AbstractButton
  val Button: ButtonFactory

  trait AbstractButton extends BootstrapHtmlComponent {
    def style: ButtonStyle
    def size: ButtonSize
    def block: Boolean
    def active: Boolean
    def disabled: Boolean
  }

  trait ButtonFactory {
    
    def apply(style: ButtonStyle = ButtonStyle.default, size: ButtonSize = ButtonSize.default,
              block: Boolean = false, active: Boolean = false, disabled: Boolean = false): Button
  }
} 

package com.karasiq.bootstrap.buttons

import scala.language.postfixOps

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.{ClassModifiers, RenderingContext}

trait UniversalButtons extends UniversalButtonStates with UniversalButtonGroups { self: RenderingContext with BootstrapComponents with ClassModifiers with Buttons ⇒
  import scalaTags.all._

  type Button = ButtonBuilder
  object Button extends ButtonFactory {
    
  case class ButtonBuilder(style: ButtonStyle = ButtonStyle.default, size: ButtonSize = ButtonSize.default,
                           block: Boolean = false, active: Boolean = false, disabled: Boolean = false)
    extends UniversalButton {

    def withStyle(style: ButtonStyle): ButtonBuilder = copy(style = style)
    def withSize(size: ButtonSize): ButtonBuilder = copy(size = size)
  }
} 

package com.karasiq.bootstrap.table

import scala.language.postfixOps

import rx._

import com.karasiq.bootstrap.components.BootstrapComponents
import com.karasiq.bootstrap.context.{ClassModifiers, RenderingContext}
import com.karasiq.bootstrap.pagination.PageSelectors

trait PagedTables { self: RenderingContext with BootstrapComponents with Tables with PageSelectors with ClassModifiers ⇒
  import scalaTags.all._

  type PagedTable <: AbstractPagedTable with BootstrapHtmlComponent
  val PagedTable: PagedTableFactory

  
  trait AbstractPagedTable {
    def table: Table
    def pageSelector: PageSelector
  }

  trait PagedTableFactory {
    def apply(heading: Rx[Seq[Modifier]], content: Rx[Seq[TableRow]], perPage: Int = 20): PagedTable

    def static(heading: Seq[Modifier], content: Seq[TableRow], perPage: Int = 20): PagedTable = {
      this.apply(Var(heading), Var(content), perPage)
    }

    private[table] def pagesRx(allContent: Rx[Seq[TableRow]], rowsPerPage: Int): Rx[Int] = {
      Rx {
        val data = allContent()
        val result = if (data.isEmpty) {
          1
        } else if (data.length % rowsPerPage == 0) {
          data.length / rowsPerPage
        } else {
          data.length / rowsPerPage + 1
        }
        result
      }
    }

    private[table] def pagedDataRx(allContent: Rx[Seq[TableRow]], currentPage: Rx[Int], rowsPerPage: Int): Rx[Seq[TableRow]] = {
      Rx {
        val data = allContent()
        val page = currentPage()
        data.slice(rowsPerPage * (page - 1), rowsPerPage * (page - 1) + rowsPerPage)
      }
    }
  }

  trait AbstractStaticPagedTable extends AbstractPagedTable {
    def allContent: Rx[Seq[TableRow]]
    def rowsPerPage: Int
  }
} 

package io.github.mkotsur.aws.codecs

import java.io.ByteArrayInputStream
import cats.syntax.either.catsSyntaxEither
import io.circe.generic.auto._
import io.github.mkotsur.aws.handler.CanDecode
import io.github.mkotsur.aws.proxy.ProxyRequest
import shapeless.Generic

import scala.language.{higherKinds, postfixOps}

private[aws] trait ProxyRequestCodec extends AllCodec with FutureCodec {

  
  def GenericProxyRequestOf[T] = shapeless.Generic[ProxyRequest[T]]

  implicit def canDecodeProxyRequest[T](implicit canDecode: CanDecode[T]) = CanDecode.instance[ProxyRequest[T]] { is =>
    {
      def extractBody(s: ProxyRequest[String]) = s.body match {
        case Some(bodyString) => canDecode.readStream(new ByteArrayInputStream(bodyString.getBytes)).map(Option.apply)
        case None             => Right(None)
      }

      def produceProxyResponse(decodedRequestString: ProxyRequest[String], bodyOption: Option[T]) = {
        val reqList = Generic[ProxyRequest[String]].to(decodedRequestString)
        Generic[ProxyRequest[T]].from((bodyOption :: reqList.reverse.tail).reverse)
      }

      for (decodedRequest$String <- CanDecode[ProxyRequest[String]].readStream(is);
           decodedBodyOption     <- extractBody(decodedRequest$String))
        yield produceProxyResponse(decodedRequest$String, decodedBodyOption)
    }
  }

}