Getting live weather conditions for a location

Objectives: Retrieve weather conditions from the live weather catalog

Complexity: Beginner

Depends on: Get your credentials, Verify Your credentials

Time to complete: 30 min

Source code: Download

The following tutorial introduces Europe and North America catalogs and shows how to get live weather conditions data using these catalogs.

The tutorial covers the following topics:

HERE live weather catalogs overview

HERE Live WeatherEurope and North America catalogs consist of data layers with real-time Weather data. Weather attributes offered in the latest-data volatile layer are updated every 15 minutes. Weather information is generated with the HERE Tile Level-14 resolution and stored in Level-8 partitions to optimize the performance during data transfer.

Each Level-14 HERE Tile contains the following set of information:

  • Air temperature
  • Dew point temperature
  • Humidity
  • Air pressure
  • Visibility
  • Precipitation type (rain, snow, ice)
  • Intensity of precipitation
  • Wind speed and direction

The following picture shows a Tile on zoom level 8 with Tiles on zoom level 14 that contain live weather attributes.

Get catalog information

Run the following OLP CLI command to get the information about HERE Live Weather Europe catalog:

olp catalog show hrn:here:data:::live-weather-eu

The output should contain the following information:

Details of the hrn:here:data::olp-here:live-weather-eu catalog:

id                       live-weather-eu
name                     HERE Live Weather Europe
hrn                      hrn:here:data::olp-here:live-weather-eu
summary                  This catalog contains live weather data in Europe Weather attributes offered in a volatile catalog, updated every 15 minutes.
description              This catalog contains live weather data in Europe. Weather attributes offered in a volatile catalog, updated every 15 minutes. Enabling analytics use cases.

notifications enabled?   false
tags                     RoadWeather, Analytics, 11555WEATHER
billing tags             11555WEATHER
created                  2017-11-07T21:33:11.519Z
owner                    HERE-f12b517c-4f08-45e8-ae8a-a317a210efdb, olp-here
config version           30
metadata version         1
metadata minimum version 0
marketplace ready        false
layers
type         ID              name
volatile     latest-data     Live Weather Europe
replication
role                id
primary             eu-ireland

Based on the output, you can see that the HERE Live Weather Europe catalog contains only one layer called latest-data.

Run the following OLP CLI command to get the information about the latest-data layer of the HERE Live Weather Europe catalog:

olp catalog layer show hrn:here:data:::live-weather-eu latest-data

The output should contain the following information:

Details of the latest-data layer:

id                  latest-data
name                Live Weather Europe
summary             This layer contains the latest weather data in Europe. The weather data is refreshed every 15 minutes.
description         This layer contains the latest weather data in Europe. The weather data is refreshed every 15 minutes.

Available attributes include:
- Air temperature
- Dew point temperature
- Humidity
- Air Pressure
- Visibility
- Precipitation type (rain, snow, ice)
- Intensity Of Precipitation
- Wind speed and direction
layerType           volatile
partitioning        heretile, tile levels: 8
partitioningScheme  heretile
volume              volatile
contentType         application/x-protobuf
schema              hrn:here:schema::olp-here:com.here.platform.schema.weather:platform-weather-schema_v1:1.0.2
tags                LiveWeather, RealTimeWeather, EUWeather, 11555WEATHER
billingTags         11555WEATHER
coverage            BG, AT, GI, ME, ES, SI, AD, RO, LU, IE, BE, HU, FI, NO, EE, LT, PL, CH, LV, IS, SE, HR, RS, BA, GB, FR, MT, PT, MC, LI, CZ, SK, MK, DK, NL, AL, DE
created             2017-11-07T21:41:36.672Z
volatileProperties  {"dataRedundancy":"multi-instance","storageCapacityMb":2000}
ttl                 604800000

Apparently, the layer is of the volatile type which means whenever there is new data the old data is overwritten. It has the following properties:

For more information on the above properties, see Data User Guide.

Use data schema

The data stored in the latest-data layer is encoded using the platform-weather-schema_v1 Protobuf Schema.

The platform-weather-schema_v1 Protobuf Schema defines the Protocol Buffer messages and enumerations used by the various weather attributes in the HERE Weather catalogs. The message definitions are located in the corresponding .proto file that describes the structure of a partition in a catalog layer.

Weather conditions are provided in form of attributes (e.g. temperature or wind) for a fine-grained location grid. To describe the location HERE uses its well-defined HERE tiling at a level 14. Note, such tiling is normally used to describe partitions. Here, however, it is part of the message content itself and describes the location of a weather condition. The message itself is stored in a partition at level '8' to achieve a fair ratio of payload (i.e. the weather conditions) to overhead of metadata for storing the data.

Let's look more closely at how the data is structured. At the highest level, we have the WeatherConditionPartition message which we find in each level 8 partition. It contains the partition_name based on HERE Tile level 8 and the list of WeatherConditionTile objects, which hold up to 4096 locations at level 14 with weather conditions. In addition to the HERE tiling, the location is described in form of a center_point_geohash - a unique identifier located in the center of the level 14 Tile. The time information is described by the timestamp attribute which represents milliseconds elapsed since January 1, 1970, at 00:00:00 UTC.

Weather conditions are represented by attributes of the following types:

  • Attributes describing air_temperature, dew_point_temperature, humidity, air_pressure, visibility,iop (Intensity of precipitation), pavement_temperature, and wfd (Water film depth) use the NumericCondition message, that describes the estimated value of the parameter - value attribute, confidence of the estimate - confidence attribute, and confidence category of the estimate that can be Low,Med, High - confidence_category_type attribute .
  • Attribute describing wind_velocity uses the NumericVectorCondition message containing the same attributes as the NumericCondition, and having one additional direction attribute that describes the direction of the wind.
  • Attribute describing precipitation_type uses the PrecipitationTypeCondition message containing the above described attributes, and having one additional precipitation_type attribute that can be UNKNOWN by default, NONE, Rain or Snow.
  • Attribute describing pavement_type uses the PavementTypeCondition message containing the above described attributes, and having one additional pavement_condition_type attribute that can be UNKNOWN by default, DRY, DAMP, WET, UNDERCOOLED, SLIPPERY_FROST, PACKED_SNOW, BLACK_ICE.

The following is the proto schema definition that contains the following messages:

syntax = "proto3";

package com.here.platform.schema.weather.v1;


// Logical grouping of higher resolution Weather information into larger Partitions.
//
// Weather information is generated with HERE Tile level 14 resolution,
// which amounts to lot of tiles when we consider
// areas like North America or Europe. 
// So, for efficiency reasons the higher resolution data points are grouped into
// a larger partition and stored. 
// This implies when we read the data, we would have to read the partition data 
// and then from the list of higher resolution tiles 
// get the tile/s information the consumer is interested in.
message WeatherConditionPartition {
  // HERE tile partition id for the current partition.
  string partition_name = 1;

  // List of Weather conditions information.
  repeated WeatherConditionTile weather_condition_tile = 2;
}


// Weather attributes specification.
//
// A Set of Weather attributes which define the Weather conditions
// at the specified time and HERE tile.
message WeatherConditionTile {
  // HERE tile id.
  sint32 tile_id = 1;

  // HERE tile level.
  sint32 tile_level = 2;

  // The geohash of the centroid of the tile.
  string center_point_geohash = 3;

  // Timestamp, which represents milliseconds elapsed
  // since January 1, 1970 at 00:00:00 UTC.
  sint64 timestamp = 4;

  // Air Temperature in Celsius.
  NumericCondition air_temperature = 5;

  // Dew Point Temperature in Celsius.
  NumericCondition dew_point_temperature = 6;

  // Relative Humidity in %.
  NumericCondition humidity = 7;

  // Air pressure in Millibars.
  NumericCondition air_pressure = 8;

  // Visibility in Kilometers.
  NumericCondition visibility = 9;

  // Intensity of precipitation normally referred to as IOP in cm/hr.
  NumericCondition iop = 10;

  // Pavement Temperature in Celsius.
  NumericCondition pavement_temperature = 11;

  // Water film depth in mm.
  // No confidence value is assigned to this parameter.
  NumericCondition wfd = 12;

  // Wind velocity in Km/hr and direction in Degrees, 
  // 2-minute average and 10 degree increments.
  NumericVectorCondition wind_velocity = 13;

  // Precipitation type.
  PrecipitationTypeCondition precipitation_type = 14;

  // Pavement Condition like dry, slippery frost, packed snow, black ice etc.
  // No confidence value is assigned to this parameter.
  PavementTypeCondition pavement_type = 15;

  // Obscuration Type, coming soon...
  // Dense Fogs and Smoke

  // Soalar Radiation, coming soon...

  // Generic type for Scalar parameters.
  message NumericCondition {
    // Estimated value of the parameter.
    double value = 1;

    // Confidence of the estimate.
    double confidence = 2;

    // Confidence Category of the estimate, Low, Med, High.
    ConfidenceCategoryType confidence_category_type = 3;
  }

  // Generic type for Vector parameters.
  message NumericVectorCondition {
    // Estimated value of the parameter.
    double value = 1;

    // Estimated direction of the parameter.
    double direction = 2;

    // Confidence of the estimate.
    double confidence = 3;

    // Confidence Category of the estimate, Low, Med, High.
    ConfidenceCategoryType confidence_category_type = 4;
  }

  // Precipitation Type.
  message PrecipitationTypeCondition {
    // Type of precipitation.
    PrecipitationType precipitation_type = 1;

    // Confidence of the estimate.
    double confidence = 2;

    // Confidence Category of the estimate, Low, Med, High.
    ConfidenceCategoryType confidence_category_type = 3;

    // Precipitation Types that are estimated.
    // UNKNOWN is used as the default value.
    enum PrecipitationType {
      PRECIPITATION_TYPE_UNKNOWN = 0;
      NONE = 1;
      RAIN = 2;
      SNOW = 3;
    }
  }

  // Pavement Condition Type.
  message PavementTypeCondition {
    // This is an estimation of the condition of the pavement, dry, damp, wet...
    PavementConditionType pavement_condition_type = 1;

    // This is optional for now.
    double confidence = 2;

    // This is optional for now.
    ConfidenceCategoryType confidence_category_type = 3;

    // Pavement condition Types that are estimated.
    enum PavementConditionType {
      PAVEMENT_CONDITION_TYPE_UNKNOWN = 0;
      DRY = 1;
      DAMP = 2;
      WET = 3;
      UNDERCOOLED = 4;
      SLIPPERY_FROST = 5;
      PACKED_SNOW = 6;
      BLACK_ICE = 7;
    }
  }

  // Confidence Categories.
  enum ConfidenceCategoryType {
    CONFIDENCE_CATEGORY_TYPE_UNKNOWN = 0;
    HIGH = 1;
    MEDIUM = 2;
    LOW = 3;
  }
}

For more information on message definitions, see the Weather Layer documentation.

Set up the Maven project

In order to get live weather conditions you may download the source code at the beginning of the tutorial and put them in a folder of your choice, or create a folder structure from scratch for your project:

live-weather
└── src
    └── main
        ├── java
        └── resources
        └── scala

You can do this with a single bash command:

mkdir -p live-weather/src/main/{java,resources,scala}

The Maven POM file is similar to the one in the Verify Maven Settings example, with the parent POM and dependencies sections updated:

Parent POM:

<parent>
    <groupId>com.here.platform</groupId>
    <artifactId>sdk-standalone-bom_2.12</artifactId>
    <version>2.39.6</version>
    <relativePath/>
</parent>

The following dependencies are used:

  • location-core_${scala.compat.version} and location-integration-here-commons_${scala.compat.version} to calculate Tile IDs
  • platform-weather-schema_v1_java to decode Partitions data
  • hrn_${scala.compat.version} to get live weather catalog hrn
  • data-client_${scala.compat.version} and data-engine_${scala.compat.version} to download partition data.
<dependencies>

    <dependency>
        <groupId>com.here.platform.location</groupId>
        <artifactId>location-core_${scala.compat.version}</artifactId>
        <version>${location-core.version}</version>
    </dependency>
    <dependency>
        <groupId>com.here.platform.location</groupId>
        <artifactId>location-integration-here-commons_${scala.compat.version}</artifactId>
        <version>${location-integration-here-commons.version}</version>
    </dependency>

    <dependency>
        <groupId>com.here.platform.schema.weather</groupId>
        <artifactId>platform-weather-schema_v1_java</artifactId>
        <version>1.0.0</version>
    </dependency>

    <dependency>
        <groupId>com.here.hrn</groupId>
        <artifactId>hrn_${scala.compat.version}</artifactId>
    </dependency>

    <dependency>
        <groupId>com.here.platform.data.client</groupId>
        <artifactId>data-client_${scala.compat.version}</artifactId>
        <version>${data-client.version}</version>
    </dependency>

    <dependency>
        <groupId>com.here.platform.data.client</groupId>
        <artifactId>data-engine_${scala.compat.version}</artifactId>
        <version>${data-engine.version}</version>
    </dependency>

</dependencies>

Get weather conditions for a specific location

The following demonstrates how to fetch the current weather condition from the Here Live Weather Europe catalog at a given location described with latitude and longitude - in this case the city center of Berlin.

The code snippet below does the following:

Step 1:

Calculate the Tile ID for the Berlin City Center coordinates on zoom level 8 using HereTileResolver [ Java API | Scala API ] class from the Location Library. Weather information is generated with the HERE Tile on zoom level 14 resolution and stored in partitions on zoom level 8 to optimize the performance during data transfer.

Step 2:

Retrieve Partition metadata for the obtained Tile ID on zoom level 8 using the getVolatilePartitionsAsIterator() method from the Data Client Library.

Step 3:

Download partition for the given Berlin City Centre Tile ID on zoom level 8 using the getDataAsBytes() method from the Data Client library.

Step 4:

Using the downloaded partition in Step 3, parse data with the platform-weather-schema_v1 Protobuf Schema.

Step 5:

Calculate the Tile ID for the Berlin City Center coordinates on zoom level 14, where all weather conditions that we want to get are stored, using the HereTileResolver [ Java API | Scala API ] class from the Location Library.

Step 6:

Find the weather data for Tile ID on zoom level 14 from 4096 Tiles.

Scala
Java
/*
 * Copyright (c) 2018-2022 HERE Europe B.V.
 *
 * 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 at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed 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 and
 * limitations under the License.
 */

import akka.actor.{ActorSystem, CoordinatedShutdown}
import com.here.hrn.HRN
import com.here.platform.data.client.common.VolatilePartitionsFilter.byIds
import com.here.platform.data.client.engine.scaladsl.{DataEngine, ReadEngine}
import com.here.platform.data.client.scaladsl.{DataClient, QueryApi}
import com.here.platform.location.core.geospatial.GeoCoordinate
import com.here.platform.location.integration.herecommons.geospatial.HereTileLevel
import com.here.platform.location.integration.herecommons.geospatial.javadsl.HereTileResolver
import com.here.platform.schema.weather.v1.PlatformWeatherSchema.WeatherConditionPartition

import scala.collection.convert.ImplicitConversions.`collection AsScalaIterable`
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Try}

object LiveWeatherExplorerSinglePointScala {

  val WEATHER_TILE_LEVEL = new HereTileLevel(8)
  val WEATHER_CONDITION_LEVEL = new HereTileLevel(14)
  val LIVE_WEATHER_CATALOG: HRN = HRN.fromString("hrn:here:data::olp-here:live-weather-eu")
  val LAYER_NAME = "latest-data"

  def main(args: Array[String]): Unit = {

    val actorSystem: ActorSystem = ActorSystem.create("weatherLoaderTutorial")
    val queryApi: QueryApi = DataClient.get(actorSystem).queryApi(LIVE_WEATHER_CATALOG)
    val readEngine: ReadEngine = DataEngine.get(actorSystem).readEngine(LIVE_WEATHER_CATALOG)
    val berlinCityCentre: GeoCoordinate = new GeoCoordinate(48.15, 11.6)

    // Step 1: Calculate Tile ID from the Berlin City Center coordinates on the 8 zoom level
    val berlinTileIdOnLevelEight: Long =
      new HereTileResolver(WEATHER_TILE_LEVEL).fromCoordinate(berlinCityCentre)

    println(
      s"Tile Id from coordinate $berlinCityCentre on Zoom Level $WEATHER_TILE_LEVEL is: $berlinTileIdOnLevelEight")

    // Step 2: Retrieve Partition metadata for the given Berlin City Centre Tile ID on zoom level 8
    queryApi
      .getVolatilePartitionsAsIterator(LAYER_NAME, byIds(Set(berlinTileIdOnLevelEight.toString)))
      .onComplete({
        case Success(partitionsIterator) =>
          val partition = partitionsIterator.toSeq.head

          // Step 3: Download partition for the given Berlin City Centre Tile ID on zoom level 8
          readEngine
            .getDataAsBytes(partition)
            .onComplete({
              case Success(partitionAsBytes) =>
                val berlinTileIdOnLevelFourteen: Long =
                  new HereTileResolver(WEATHER_CONDITION_LEVEL).fromCoordinate(berlinCityCentre)

                val tileConditions = for {

                  // Step 4: Get all weather conditions for all tiles on zoom level 14
                  berlinWeatherConditions <- Try(
                    WeatherConditionPartition.parseFrom(partitionAsBytes)).toOption

                  // Step 5: Calculate Tile ID from the Berlin City Center coordinates on the 14 zoom level
                  berlinTileIdOnLevelFourteen: Long = new HereTileResolver(WEATHER_CONDITION_LEVEL)
                    .fromCoordinate(berlinCityCentre)

                  // Step 6: Find the Tile and get the weather conditions
                  weatherData <- berlinWeatherConditions.getWeatherConditionTileList.find(
                    _.getTileId == berlinTileIdOnLevelFourteen)
                } yield weatherData

                println(
                  s"Tile Id from coordinate $berlinCityCentre using Zoom Level $WEATHER_CONDITION_LEVEL is: $berlinTileIdOnLevelFourteen")

                println(s"Live weather around $berlinCityCentre, is $tileConditions")

                CoordinatedShutdown
                  .get(actorSystem)
                  .run(CoordinatedShutdown.unknownReason)
                  .onComplete(print)
            })
      })
  }
}

/*
 * Copyright (c) 2018-2022 HERE Europe B.V.
 *
 * 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 at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed 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 and
 * limitations under the License.
 */

import akka.actor.ActorSystem;
import akka.actor.CoordinatedShutdown;
import com.google.common.collect.Iterators;
import com.google.protobuf.InvalidProtocolBufferException;
import com.here.hrn.HRN;
import com.here.platform.data.client.common.VolatilePartitionsFilter;
import com.here.platform.data.client.engine.javadsl.DataEngine;
import com.here.platform.data.client.engine.javadsl.ReadEngine;
import com.here.platform.data.client.javadsl.DataClient;
import com.here.platform.data.client.javadsl.Partition;
import com.here.platform.data.client.javadsl.QueryApi;
import com.here.platform.data.client.model.AdditionalFields;
import com.here.platform.location.core.geospatial.GeoCoordinate;
import com.here.platform.location.integration.herecommons.geospatial.HereTileLevel;
import com.here.platform.location.integration.herecommons.geospatial.javadsl.HereTileResolver;
import com.here.platform.schema.weather.v1.PlatformWeatherSchema.WeatherConditionPartition;
import com.here.platform.schema.weather.v1.PlatformWeatherSchema.WeatherConditionTile;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class LiveWeatherExplorerSinglePoint {

  public static final HereTileLevel WEATHER_TILE_LEVEL = new HereTileLevel(8);
  public static final HereTileLevel WEATHER_CONDITION_LEVEL = new HereTileLevel(14);
  public static final HRN LIVE_WEATHER_CATALOG =
      HRN.fromString("hrn:here:data::olp-here:live-weather-eu");
  public static final String LAYER_NAME = "latest-data";

  public static void main(String[] args) {

    ActorSystem actorSystem = ActorSystem.create("weatherLoaderTutorial");
    QueryApi queryApi = DataClient.get(actorSystem).queryApi(LIVE_WEATHER_CATALOG);
    ReadEngine readEngine = DataEngine.get(actorSystem).readEngine(LIVE_WEATHER_CATALOG);
    GeoCoordinate berlinCityCentre = new GeoCoordinate(48.15, 11.6);

    // Step 1: Calculate Tile ID from the Berlin City Center coordinates on the 8 zoom level
    long berlinTileIdOnLevelEight =
        new HereTileResolver(WEATHER_TILE_LEVEL).fromCoordinate(berlinCityCentre);

    System.out.printf(
        "Tile ID from coordinate %s on Zoom Level %s is: %s%n",
        berlinCityCentre, WEATHER_TILE_LEVEL, berlinTileIdOnLevelEight);

    try {

      // Step 2: Retrieve Partition metadata for the given Berlin City Centre Tile ID on zoom level
      // 8
      Partition partition =
          Iterators.get(
              queryApi
                  .getVolatilePartitionsAsIterator(
                      LAYER_NAME,
                      new VolatilePartitionsFilter.Builder()
                          .withIds(Collections.singleton(String.valueOf(berlinTileIdOnLevelEight)))
                          .build(),
                      AdditionalFields.AllFields())
                  .toCompletableFuture()
                  .join(),
              0);

      // Step 3: Download partition for the given Berlin City Centre Tile ID on zoom level 8
      byte[] downloadedPartition =
          readEngine.getDataAsBytes(partition).toCompletableFuture().join();

      // Step 4: Get all weather conditions for all tiles on zoom level 14
      WeatherConditionPartition berlinWeatherConditions =
          WeatherConditionPartition.parseFrom(downloadedPartition);

      // Step 5: Calculate Tile ID from the Berlin City Center coordinates on the 14 zoom level
      long berlinTileIdOnLevelFourteen =
          new HereTileResolver(WEATHER_CONDITION_LEVEL).fromCoordinate(berlinCityCentre);
      System.out.printf(
          "Tile ID from coordinate %s using Zoom Level %s is: %s%n",
          berlinCityCentre, WEATHER_CONDITION_LEVEL, berlinTileIdOnLevelFourteen);

      // Step 6: Find the Tile and get the weather conditions
      List<WeatherConditionTile> tileConditions =
          berlinWeatherConditions
              .getWeatherConditionTileList()
              .stream()
              .filter(data -> data.getTileId() == berlinTileIdOnLevelFourteen)
              .collect(Collectors.toList());
      System.out.printf("%nLive weather around %s, is %s%n", berlinCityCentre, tileConditions);

    } catch (InvalidProtocolBufferException e) {
      throw new IllegalArgumentException("Unable to parse weather data.");
    } finally {

      CoordinatedShutdown.get(actorSystem)
          .run(CoordinatedShutdown.unknownReason(), Optional.empty())
          .toCompletableFuture()
          .join();
    }
  }
}

To execute the application, run the following command:

Scala
Java

mvn compile exec:java -D"exec.mainClass"="LiveWeatherExplorerSinglePointScala"


mvn compile exec:java -D"exec.mainClass"="LiveWeatherExplorerSinglePoint"

According to the results of the program on Fri 22 October 2021 14:18:12 the air temperature in Berlin is 9.27°C. Humidity reaches 59.02%. There is no precipitation information as indicated by precipitation_type:None. The confidence of the result is 0.44 - 0.5 out of 1, which is MEDIUM (confidence_category_type in the result output).

Tile ID from coordinate GeoCoordinate(48.15,11.6) on Zoom Level HereTileLevel(8) is: 92232
Tile ID from coordinate GeoCoordinate(48.15,11.6) using Zoom Level HereTileLevel(14) is: 377782527

Live weather around GeoCoordinate(48.15,11.6), is
tile_id: 377782527
tile_level: 14
center_point_geohash: "u281zy00"
timestamp: 1634912292852
air_temperature {
  value: 9.27
  confidence: 0.44
  confidence_category_type: MEDIUM
}

humidity {
  value: 59.02
  confidence: 0.44
  confidence_category_type: MEDIUM
}

precipitation_type {
  precipitation_type: NONE
  confidence: 0.5
  confidence_category_type: MEDIUM
}

For better learning, you can try updating the source code to get information about the live weather conditions of your location using Europe or North America catalogs and your coordinates.

Further information

For more details on the topics covered in this tutorial, see the following sources:

results matching ""

    No results matching ""