Skip to content

Commit

Permalink
Bump dependencies up
Browse files Browse the repository at this point in the history
  • Loading branch information
@pomadchin
pomadchin committed Dec 13, 2021
1 parent 01b0122 commit a78cced
Show file tree
Hide file tree
Showing 128 changed files with 1,899 additions and 1,907 deletions.
4 changes: 2 additions & 2 deletions .circleci/config.yml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,7 +61,7 @@ workflows:
- openjdk8-build:
matrix:
parameters:
scala-version: ["2.12.14"]
scala-version: ["2.12.15"]
# required since openjdk8-deploy has tag filters AND requires
# openjdk8
# https://circleci.com/docs/2.0/workflows/#executing-workflows-for-a-git-tag
Expand All @@ -72,7 +72,7 @@ workflows:
- openjdk8-deploy:
matrix:
parameters:
scala-version: ["2.12.14"]
scala-version: ["2.12.15"]
requires:
- openjdk8-build
filters:
Expand Down
21 changes: 11 additions & 10 deletions .scalafmt.conf
View file
Original file line number Diff line number Diff line change
@@ -1,11 +1,12 @@
version = "2.7.5"
align = most
continuationIndent.callSite = 2
continuationIndent.defnSite = 2
danglingParentheses = true
indentOperator = spray
version = 3.1.1
runner.dialect = scala212
indent.main = 2
indent.significant = 2
maxColumn = 150
newlines.alwaysBeforeTopLevelStatements = false
rewrite.rules = [RedundantParens, SortImports]
spaces.inImportCurlyBraces = false
unindentTopLevelOperators = true
continuationIndent.defnSite = 2
continuationIndent.callSite = 2
assumeStandardLibraryStripMargin = true
danglingParentheses.preset = true
rewrite.rules = [SortImports, RedundantBraces, RedundantParens, SortModifiers]
docstrings.style = Asterisk
align.preset = more
2 changes: 2 additions & 0 deletions build.sbt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -394,6 +394,8 @@ lazy val `stac-example` = project
logback,
pureConfig,
pureConfigCatsEffect,
pureConfigGeneric,
pureConfigMacros,
scaffeine,
scalatest,
decline,
Expand Down
69 changes: 34 additions & 35 deletions core/src/main/scala/geotrellis/server/LayerExtent.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,49 +32,48 @@ import io.chrisdavenport.log4cats.Logger

object LayerExtent {
def apply[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]](
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
cellType: Option[CellType]
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
cellType: Option[CellType]
): (Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] = {
val logger = Logger[F]
(extent: Extent, cellSize: Option[CellSize]) => {
(extent: Extent, cellSize: Option[CellSize]) =>
for {
expr <- getExpression
_ <- logger.trace(
s"[LayerExtent] Retrieved MAML AST for extent ($extent) and cellsize ($cellSize): ${expr.toString}"
)
expr <- getExpression
_ <- logger.trace(
s"[LayerExtent] Retrieved MAML AST for extent ($extent) and cellsize ($cellSize): ${expr.toString}"
)
paramMap <- getParams
_ <- logger.trace(
s"[LayerExtent] Retrieved Teters for extent ($extent) and cellsize ($cellSize): ${paramMap.toString}"
)
vars = Vars.varsWithBuffer(expr)
params <- vars.toList.parTraverse { case (varName, (_, buffer)) =>
val thingify = implicitly[ExtentReification[F, T]].extentReification(paramMap(varName))
thingify(extent, cellSize).map(varName -> _)
} map { _.toMap }
reified <- Expression.bindParams(expr, params.mapValues(RasterLit(_))) match {
case Valid(expression) => interpreter(expression)
case Invalid(errors) => throw new Exception(errors.map(_.repr).reduce)
}
_ <- logger.trace(
s"[LayerExtent] Retrieved Teters for extent ($extent) and cellsize ($cellSize): ${paramMap.toString}"
)
vars = Vars.varsWithBuffer(expr)
params <- vars.toList.parTraverse { case (varName, (_, buffer)) =>
val thingify = implicitly[ExtentReification[F, T]].extentReification(paramMap(varName))
thingify(extent, cellSize).map(varName -> _)
} map { _.toMap }
reified <- Expression.bindParams(expr, params.mapValues(RasterLit(_))) match {
case Valid(expression) => interpreter(expression)
case Invalid(errors) => throw new Exception(errors.map(_.repr).reduce)
}
} yield reified
.andThen(_.as[MultibandTile])
.andThen(res => Valid(cellType.fold(res)(res.interpretAs)))
.map { tile => cellSize.fold(tile) { cs => tile.crop(RasterExtent(extent, cs).gridBoundsFor(extent)) } }
}
.map(tile => cellSize.fold(tile)(cs => tile.crop(RasterExtent(extent, cs).gridBoundsFor(extent))))
}

def generateExpression[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]](
mkExpr: Map[String, T] => Expression,
getParams: F[Map[String, T]],
interpreter: Interpreter[F]
mkExpr: Map[String, T] => Expression,
getParams: F[Map[String, T]],
interpreter: Interpreter[F]
): (Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] = apply[F, T](getParams.map(mkExpr(_)), getParams, interpreter, None)

/** Provide an expression and expect arguments to fulfill its needs */
def curried[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]](
expr: Expression,
interpreter: Interpreter[F],
cellType: Option[CellType]
expr: Expression,
interpreter: Interpreter[F],
cellType: Option[CellType]
): (Map[String, T], Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] =
(paramMap: Map[String, T], extent: Extent, cellsize: Option[CellSize]) => {
val eval =
Expand All @@ -83,24 +82,24 @@ object LayerExtent {
}

def concurrent[F[_]: Logger: Parallel: Monad: Concurrent, T: ExtentReification[F, *]](
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F]
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F]
): (Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] =
apply(getExpression, getParams, interpreter, None)

/** The identity endpoint (for simple display of raster) */
def withCellType[F[_]: Logger: Parallel: Monad: Concurrent, T: ExtentReification[F, *]](
param: T,
cellType: CellType
param: T,
cellType: CellType
): (Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] =
(extent: Extent, cellsize: Option[CellSize]) => {
val eval = curried(RasterVar("identity"), ConcurrentInterpreter.DEFAULT, cellType.some)
eval(Map("identity" -> param), extent, cellsize)
}

def identity[F[_]: Logger: Parallel: Monad: Concurrent, T: ExtentReification[F, *]](
param: T
param: T
): (Extent, Option[CellSize]) => F[Interpreted[MultibandTile]] =
(extent: Extent, cellsize: Option[CellSize]) => {
val eval = curried(RasterVar("identity"), ConcurrentInterpreter.DEFAULT, None)
Expand Down
105 changes: 51 additions & 54 deletions core/src/main/scala/geotrellis/server/LayerHistogram.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -44,82 +44,79 @@ object LayerHistogram {

// Provide IOs for both expression and params, get back a tile
def apply[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]: HasRasterExtents[F, *]](
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
maxCells: Int
getExpression: F[Expression],
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
maxCells: Int
): F[Interpreted[List[Histogram[Double]]]] = {
val logger = Logger[F]
for {
params <- getParams
rasterExtents <- NEL
.fromListUnsafe(params.values.toList)
.traverse(HasRasterExtents[F, T].rasterExtents(_))
.map(_.flatten)
extents <- NEL
.fromListUnsafe(params.values.toList)
.traverse(
HasRasterExtents[F, T]
.rasterExtents(_)
.map(z => z.map(_.extent).reduce)
)
intersectionO = SampleUtils.intersectExtents(extents)
_ <- intersectionO traverse { intersection =>
logger.trace(
s"[LayerHistogram] Intersection of provided layer extents calculated: $intersection"
)
}
cellSize = SampleUtils.chooseLargestCellSize(rasterExtents, maxCells)
_ <- logger.trace(
s"[LayerHistogram] Largest cell size of provided layers calculated: $cellSize"
)
mbtileForExtent = LayerExtent(getExpression, getParams, interpreter, None)
_ <- intersectionO traverse { intersection =>
logger.trace(
s"[LayerHistogram] calculating histogram from (approximately) ${intersection.area / (cellSize.width * cellSize.height)} cells"
)
}
params <- getParams
rasterExtents <- NEL
.fromListUnsafe(params.values.toList)
.traverse(HasRasterExtents[F, T].rasterExtents(_))
.map(_.flatten)
extents <- NEL
.fromListUnsafe(params.values.toList)
.traverse(
HasRasterExtents[F, T]
.rasterExtents(_)
.map(z => z.map(_.extent).reduce)
)
intersectionO = SampleUtils.intersectExtents(extents)
_ <- intersectionO traverse { intersection =>
logger.trace(
s"[LayerHistogram] Intersection of provided layer extents calculated: $intersection"
)
}
cellSize = SampleUtils.chooseLargestCellSize(rasterExtents, maxCells)
_ <- logger.trace(
s"[LayerHistogram] Largest cell size of provided layers calculated: $cellSize"
)
mbtileForExtent = LayerExtent(getExpression, getParams, interpreter, None)
_ <- intersectionO traverse { intersection =>
logger.trace(
s"[LayerHistogram] calculating histogram from (approximately) ${intersection.area / (cellSize.width * cellSize.height)} cells"
)
}
interpretedTile <- intersectionO traverse { intersection =>
mbtileForExtent(intersection, cellSize.some)
}
} yield {
interpretedTile.map { mbtileValidated =>
mbtileValidated.map { mbTile =>
mbTile.bands.map { band =>
StreamingHistogram.fromTile(band)
}.toList
}
} getOrElse { ??? }
}
mbtileForExtent(intersection, cellSize.some)
}
} yield interpretedTile.map { mbtileValidated =>
mbtileValidated.map { mbTile =>
mbTile.bands.map { band =>
StreamingHistogram.fromTile(band)
}.toList
}
} getOrElse ???
}

def generateExpression[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]: HasRasterExtents[F, *]](
mkExpr: Map[String, T] => Expression,
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
maxCells: Int
mkExpr: Map[String, T] => Expression,
getParams: F[Map[String, T]],
interpreter: Interpreter[F],
maxCells: Int
): F[Interpreted[List[Histogram[Double]]]] =
apply[F, T](getParams.map(mkExpr(_)), getParams, interpreter, maxCells)

/** Provide an expression and expect arguments to fulfill its needs */
def curried[F[_]: Logger: Parallel: Monad, T: ExtentReification[F, *]: HasRasterExtents[F, *]](
expr: Expression,
interpreter: Interpreter[F],
maxCells: Int
expr: Expression,
interpreter: Interpreter[F],
maxCells: Int
): Map[String, T] => F[Interpreted[List[Histogram[Double]]]] =
(paramMap: Map[String, T]) => {
(paramMap: Map[String, T]) =>
apply[F, T](
expr.pure[F],
paramMap.pure[F],
interpreter,
maxCells
)
}

/** The identity endpoint (for simple display of raster) */
def concurrent[F[_]: Logger: Parallel: Monad: Concurrent, T: ExtentReification[F, *]: HasRasterExtents[F, *]](
param: T,
maxCells: Int
param: T,
maxCells: Int
): F[Interpreted[List[Histogram[Double]]]] = {
val eval =
curried[F, T](
Expand Down
Loading

0 comments on commit a78cced

Please sign in to comment.