meteostat 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

meteostat/__init__.py

@@ -12,7 +12,7 @@ The code is licensed under the MIT license.
 """
 
 __appname__ = "meteostat"
-__version__ = "2.0.1"
+__version__ = "2.1.0"
 
 from meteostat.api.daily import daily
 from meteostat.api.hourly import hourly

meteostat/api/config.py

@@ -154,5 +154,8 @@ class Config(ConfigService):
     )
     metno_user_agent: Optional[str] = None
 
+    # [Provider] GSA settings
+    gsa_api_base_url: str = "https://dataset.api.hub.geosphere.at/v1"
+
 
 config = Config("MS")

meteostat/enumerations.py

@@ -102,6 +102,10 @@ class Provider(StrEnum):
     ECCC_DAILY = "eccc_daily"
     ECCC_MONTHLY = "eccc_monthly"
     METNO_FORECAST = "metno_forecast"
+    GSA_HOURLY = "gsa_hourly"
+    GSA_SYNOP = "gsa_synop"
+    GSA_DAILY = "gsa_daily"
+    GSA_MONTHLY = "gsa_monthly"
 
     HOURLY = "hourly"
     DAILY = "daily"

meteostat/providers/dwd/climat.py

@@ -102,7 +102,7 @@ def get_df(parameter: str, mode: str, station_code: str) -> Optional[pd.DataFram
 
     buffer.seek(0)
     df = pd.read_csv(buffer, sep=";").rename(columns=lambda col: col.strip().lower())
-    df.rename(columns=param_config["stubnames"], inplace=True)
+    df = df.rename(columns=param_config["stubnames"])
 
     # Convert wide to long format
     df = pd.wide_to_long(

meteostat/providers/dwd/monthly.py

@@ -23,7 +23,6 @@ from meteostat.providers.dwd.shared import get_ftp_connection
 
 BASE_DIR = "/climate_environment/CDC/observations_germany/climate/monthly/kl/"
 USECOLS = [1, 4, 5, 6, 7, 9, 10, 11, 12, 14]  # CSV cols which should be read
-PARSE_DATES = {"time": [0]}  # Which columns should be parsed as dates?
 NAMES = {
     "MO_N": Parameter.CLDC,
     "MO_TT": Parameter.TEMP,
@@ -83,15 +82,19 @@ def get_df(station: str, mode: str) -> Optional[pd.DataFrame]:
     df: pd.DataFrame = pd.read_csv(  # type: ignore
         raw,
         sep=r"\s*;\s*",
-        date_format="%Y%m%d",
         na_values=["-999", -999],
         usecols=USECOLS,
-        parse_dates=PARSE_DATES,
         engine="python",
     )
 
     # Rename columns
     df = df.rename(columns=lambda x: x.strip())
+
+    # Parse date column
+    df["MESS_DATUM_BEGINN"] = pd.to_datetime(
+        df["MESS_DATUM_BEGINN"].astype(str), format="%Y%m%d"
+    )
+    df = df.rename(columns={"MESS_DATUM_BEGINN": "time"})
     df = df.rename(columns=NAMES)
 
     # Convert data

meteostat/providers/gsa/__init__.py

@@ -0,0 +1,3 @@
+"""
+GeoSphere Austria Data Hub Provider
+"""

meteostat/providers/gsa/daily.py

@@ -0,0 +1,194 @@
+"""
+GeoSphere Austria Data Hub daily data import routine
+
+Get daily climate data for weather stations in Austria.
+
+License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
+"""
+
+from datetime import datetime
+from typing import Dict, Optional
+
+import pandas as pd
+
+from meteostat.enumerations import TTL, Parameter
+from meteostat.core.logger import logger
+from meteostat.typing import ProviderRequest
+from meteostat.core.cache import cache_service
+from meteostat.api.config import config
+from meteostat.core.network import network_service
+from meteostat.utils.conversions import (
+    hours_to_minutes,
+    ms_to_kmh,
+    percentage_to_okta,
+    pres_to_msl,
+)
+
+
+RESOURCE_ID = "klima-v2-1d"
+
+# Mapping from GeoSphere Austria parameter names to Meteostat parameters
+# See: https://dataset.api.hub.geosphere.at/v1/station/historical/klima-v2-1d/metadata
+PARAMETER_MAPPING: Dict[str, Parameter] = {
+    "tl_mittel": Parameter.TEMP,  # Mean air temperature (°C) - Lufttemperatur 2m Mittelwert
+    "tlmax": Parameter.TMAX,  # Maximum air temperature (°C) - Lufttemperatur 2m Maximalwert
+    "tlmin": Parameter.TMIN,  # Minimum air temperature (°C) - Lufttemperatur 2m Minimalwert
+    "rr": Parameter.PRCP,  # Precipitation 24h sum (mm) - Niederschlag 24h Summe
+    "sh": Parameter.SNWD,  # Snow depth (cm) - Schneehöhe
+    "vv_mittel": Parameter.WSPD,  # Mean wind speed (km/h) - Windgeschwindigkeit Mittelwert
+    "ffx": Parameter.WPGT,  # Maximum wind gust (m/s) - Windböe Maximum
+    "p_mittel": Parameter.PRES,  # Mean air pressure (hPa) - Luftdruck Mittelwert
+    "rf_mittel": Parameter.RHUM,  # Mean relative humidity (%) - Relative Feuchte Mittelwert
+    "so_h": Parameter.TSUN,  # Sunshine duration (h) - Sonnenscheindauer
+    "bewm_mittel": Parameter.CLDC,  # Mean cloud cover (%) - Bedeckung Mittelwert
+}
+
+# Inverse mapping
+METEOSTAT_TO_GSA = {v: k for k, v in PARAMETER_MAPPING.items()}
+
+
+@cache_service.cache(TTL.WEEK, "pickle")
+def get_data(
+    station_id: str,
+    elevation: int | None,
+    parameters: list[str],
+    start: datetime,
+    end: datetime,
+) -> Optional[pd.DataFrame]:
+    """
+    Fetch data from GeoSphere Austria Data Hub API
+    """
+    logger.debug(
+        f"Fetching daily data for station '{station_id}' from {start} to {end}"
+    )
+
+    # Format dates as ISO 8601 (date only for daily data)
+    start_str = start.strftime("%Y-%m-%d")
+    end_str = end.strftime("%Y-%m-%d")
+
+    # Build URL
+    url = f"{config.gsa_api_base_url}/station/historical/{RESOURCE_ID}"
+
+    # Make request
+    response = network_service.get(
+        url,
+        params={
+            "parameters": ",".join(parameters),
+            "station_ids": station_id,
+            "start": start_str,
+            "end": end_str,
+            "output_format": "geojson",
+        },
+    )
+
+    if response.status_code != 200:
+        logger.warning(
+            f"Failed to fetch daily data for station {station_id} (status: {response.status_code})"
+        )
+        return None
+
+    try:
+        data = response.json()
+
+        if not data.get("features"):
+            logger.info(f"No daily data returned for station {station_id}")
+            return None
+
+        # Get timestamps array
+        timestamps = data.get("timestamps")
+        if not timestamps:
+            logger.warning("No timestamps in daily response")
+            return None
+
+        # Extract time series data from GeoJSON response
+        # New API format has timestamps at top level and data as arrays
+        feature = data["features"][0]
+        props = feature.get("properties", {})
+        params_data = props.get("parameters", {})
+
+        if not params_data:
+            logger.info(f"No parameter data returned for station {station_id}")
+            return None
+
+        # Build DataFrame from timestamps and parameter arrays
+        df_dict = {}
+        for param in parameters:
+            if param in params_data:
+                param_info = params_data[param]
+                if "data" in param_info:
+                    df_dict[param] = param_info["data"]
+
+        if not df_dict:
+            return None
+
+        # Create DataFrame with timestamps as index
+        df = pd.DataFrame(df_dict)
+        dt_index = pd.DatetimeIndex(pd.to_datetime(timestamps))
+        df.index = dt_index.tz_localize(None)
+        df.index.name = "time"
+
+        # Sort by time
+        df = df.sort_index()
+
+        # Rename columns to Meteostat parameter names
+        rename_map = {}
+        for gsadh_param, meteostat_param in PARAMETER_MAPPING.items():
+            if gsadh_param in df.columns:
+                rename_map[gsadh_param] = meteostat_param
+
+        df = df.rename(columns=rename_map)
+
+        # Convert units where necessary
+        if Parameter.WSPD in df.columns:
+            df[Parameter.WSPD] = df[Parameter.WSPD].apply(ms_to_kmh)
+
+        if Parameter.WPGT in df.columns:
+            df[Parameter.WPGT] = df[Parameter.WPGT].apply(ms_to_kmh)
+
+        if Parameter.TSUN in df.columns:
+            df[Parameter.TSUN] = df[Parameter.TSUN].apply(hours_to_minutes)
+
+        if Parameter.CLDC in df.columns:
+            df[Parameter.CLDC] = df[Parameter.CLDC].apply(percentage_to_okta)
+
+        if Parameter.PRES in df.columns:
+            df[Parameter.PRES] = df.apply(
+                lambda row: pres_to_msl(row, elevation), axis=1
+            )
+
+        # Round values
+        df = df.round(1)
+
+        return df
+
+    except Exception as error:
+        logger.warning(f"Error parsing daily response: {error}", exc_info=True)
+        return None
+
+
+def fetch(req: ProviderRequest) -> Optional[pd.DataFrame]:
+    """
+    Fetch daily data from GeoSphere Austria Data Hub
+    """
+    if "national" not in req.station.identifiers:
+        return None
+
+    station_id = req.station.identifiers["national"]
+
+    # Map Meteostat parameters to GeoSphere Austria parameters
+    gsa_params = []
+    for param in req.parameters:
+        if param in METEOSTAT_TO_GSA:
+            gsa_params.append(METEOSTAT_TO_GSA[param])
+
+    if not gsa_params:
+        logger.info("No mappable parameters for GeoSphere Austria daily data")
+        return None
+
+    # Fetch data
+    df = get_data(station_id, req.station.elevation, gsa_params, req.start, req.end)
+
+    if df is None or df.empty:
+        return None
+
+    return df

meteostat/providers/gsa/hourly.py

@@ -0,0 +1,175 @@
+"""
+GeoSphere Austria Data Hub hourly data import routine
+
+Get hourly climate data for weather stations in Austria.
+
+License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
+"""
+
+from datetime import datetime
+from typing import Dict, Optional
+
+import pandas as pd
+
+from meteostat.enumerations import TTL, Parameter
+from meteostat.core.logger import logger
+from meteostat.typing import ProviderRequest
+from meteostat.core.cache import cache_service
+from meteostat.api.config import config
+from meteostat.core.network import network_service
+from meteostat.utils.conversions import hours_to_minutes, ms_to_kmh
+
+
+RESOURCE_ID = "klima-v2-1h"
+
+# Mapping from GeoSphere Austria parameter names to Meteostat parameters
+# See: https://dataset.api.hub.geosphere.at/v1/station/historical/klima-v2-1h/metadata
+PARAMETER_MAPPING: Dict[str, Parameter] = {
+    "tl": Parameter.TEMP,  # Air temperature (°C)
+    "rr": Parameter.PRCP,  # Precipitation (mm)
+    "pred": Parameter.PRES,  # Air pressure (hPa)
+    "ff": Parameter.WSPD,  # Wind speed (m/s)
+    "ffx": Parameter.WPGT,  # Wind gust (m/s)
+    "dd": Parameter.WDIR,  # Wind direction (°)
+    "rf": Parameter.RHUM,  # Relative humidity (%)
+    "so_h": Parameter.TSUN,  # Sunshine duration (h)
+    "sh": Parameter.SNWD,  # Snow depth (cm)
+}
+
+# Inverse mapping
+METEOSTAT_TO_GSA = {v: k for k, v in PARAMETER_MAPPING.items()}
+
+
+@cache_service.cache(TTL.DAY, "pickle")
+def get_data(
+    station_id: str, parameters: list[str], start: datetime, end: datetime
+) -> Optional[pd.DataFrame]:
+    """
+    Fetch data from GeoSphere Austria Data Hub API
+    """
+    logger.debug(
+        f"Fetching hourly data for station '{station_id}' from {start} to {end}"
+    )
+
+    # Format dates as ISO 8601
+    start_str = start.strftime("%Y-%m-%dT%H:%M")
+    end_str = end.strftime("%Y-%m-%dT%H:%M")
+
+    # Build URL
+    url = f"{config.gsa_api_base_url}/station/historical/{RESOURCE_ID}"
+
+    # Make request
+    response = network_service.get(
+        url,
+        params={
+            "parameters": ",".join(parameters),
+            "station_ids": station_id,
+            "start": start_str,
+            "end": end_str,
+            "output_format": "geojson",
+        },
+    )
+
+    if response.status_code != 200:
+        logger.warning(
+            f"Failed to fetch data for station {station_id} (status: {response.status_code})"
+        )
+        return None
+
+    try:
+        data = response.json()
+
+        if not data.get("features"):
+            logger.info(f"No data returned for station {station_id}")
+            return None
+
+        # Get timestamps array
+        timestamps = data.get("timestamps")
+        if not timestamps:
+            logger.warning("No timestamps in hourly response")
+            return None
+
+        # Extract time series data from GeoJSON response
+        # New API format has timestamps at top level and data as arrays
+        feature = data["features"][0]
+        props = feature.get("properties", {})
+        params_data = props.get("parameters", {})
+
+        if not params_data:
+            logger.info(f"No parameter data returned for station {station_id}")
+            return None
+
+        # Build DataFrame from timestamps and parameter arrays
+        df_dict = {}
+        for param in parameters:
+            if param in params_data:
+                param_info = params_data[param]
+                if "data" in param_info:
+                    df_dict[param] = param_info["data"]
+
+        if not df_dict:
+            return None
+
+        # Create DataFrame with timestamps as index
+        df = pd.DataFrame(df_dict)
+        dt_index = pd.DatetimeIndex(pd.to_datetime(timestamps))
+        df.index = dt_index.tz_localize(None)
+        df.index.name = "time"
+
+        # Sort by time
+        df = df.sort_index()
+
+        # Rename columns to Meteostat parameter names
+        rename_map = {}
+        for gsadh_param, meteostat_param in PARAMETER_MAPPING.items():
+            if gsadh_param in df.columns:
+                rename_map[gsadh_param] = meteostat_param
+
+        df = df.rename(columns=rename_map)
+
+        # Convert units where necessary
+        if Parameter.WSPD in df.columns:
+            df[Parameter.WSPD] = df[Parameter.WSPD].apply(ms_to_kmh)
+
+        if Parameter.WPGT in df.columns:
+            df[Parameter.WPGT] = df[Parameter.WPGT].apply(ms_to_kmh)
+
+        if Parameter.TSUN in df.columns:
+            df[Parameter.TSUN] = df[Parameter.TSUN].apply(hours_to_minutes)
+
+        # Round values
+        df = df.round(1)
+
+        return df
+
+    except Exception as error:
+        logger.warning(f"Error parsing response: {error}", exc_info=True)
+        return None
+
+
+def fetch(req: ProviderRequest) -> Optional[pd.DataFrame]:
+    """
+    Fetch hourly data from GeoSphere Austria Data Hub
+    """
+    if "national" not in req.station.identifiers:
+        return None
+
+    station_id = req.station.identifiers["national"]
+
+    # Map Meteostat parameters to GeoSphere Austria parameters
+    gsa_params = []
+    for param in req.parameters:
+        if param in METEOSTAT_TO_GSA:
+            gsa_params.append(METEOSTAT_TO_GSA[param])
+
+    if not gsa_params:
+        logger.info("No mappable parameters for GeoSphere Austria hourly data")
+        return None
+
+    # Fetch data
+    df = get_data(station_id, gsa_params, req.start, req.end)
+
+    if df is None or df.empty:
+        return None
+
+    return df

meteostat/providers/gsa/monthly.py

@@ -0,0 +1,192 @@
+"""
+GeoSphere Austria Data Hub monthly data import routine
+
+Get monthly climate data for weather stations in Austria.
+
+License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
+"""
+
+from datetime import datetime
+from typing import Dict, Optional
+
+import pandas as pd
+
+from meteostat.enumerations import TTL, Parameter
+from meteostat.core.logger import logger
+from meteostat.typing import ProviderRequest
+from meteostat.core.cache import cache_service
+from meteostat.api.config import config
+from meteostat.core.network import network_service
+from meteostat.utils.conversions import (
+    hours_to_minutes,
+    ms_to_kmh,
+    percentage_to_okta,
+    pres_to_msl,
+)
+
+
+RESOURCE_ID = "klima-v2-1m"
+
+# Mapping from GeoSphere Austria parameter names to Meteostat parameters
+# See: https://dataset.api.hub.geosphere.at/v1/station/historical/klima-v2-1m/metadata
+PARAMETER_MAPPING: Dict[str, Parameter] = {
+    "tl_mittel": Parameter.TEMP,  # Mean air temperature (°C) - Lufttemperatur 2m Mittelwert
+    "tlmin": Parameter.TXMN,  # Minimum air temperature (°C) - Lufttemperatur 2m Minimalwert
+    "tlmax": Parameter.TXMX,  # Maximum air temperature (°C) - Lufttemperatur 2m Maximalwert
+    "tlmin_mittel": Parameter.TMIN,  # Mean minimum air temperature (°C) - Lufttemperatur 2m Mittelwert der Minima
+    "tlmax_mittel": Parameter.TMAX,  # Mean maximum air temperature (°C) - Lufttemperatur 2m Mittelwert der Maxima
+    "rf_mittel": Parameter.RHUM,  # Mean relative humidity (%) - Relative Feuchte Mittelwert
+    "rr": Parameter.PRCP,  # Precipitation sum (mm) - Niederschlag Summe der 24h-Summen
+    "vv_mittel": Parameter.WSPD,  # Mean wind speed (m/s) - Windgeschwindigkeit Mittelwert
+    "p": Parameter.PRES,  # Mean air pressure (hPa) - Luftdruck Mittelwert
+    "so_h": Parameter.TSUN,  # Sunshine duration (h) - Sonnenscheindauer
+    "bewm_mittel": Parameter.CLDC,  # Mean cloud cover (%) - Bedeckung Mittelwert
+}
+
+# Inverse mapping
+METEOSTAT_TO_GSA = {v: k for k, v in PARAMETER_MAPPING.items()}
+
+
+@cache_service.cache(TTL.MONTH, "pickle")
+def get_data(
+    station_id: str,
+    elevation: int | None,
+    parameters: list[str],
+    start: datetime,
+    end: datetime,
+) -> Optional[pd.DataFrame]:
+    """
+    Fetch data from GeoSphere Austria Data Hub API
+    """
+    logger.debug(
+        f"Fetching monthly data for station '{station_id}' from {start} to {end}"
+    )
+
+    # Format dates as ISO 8601 (full date for monthly data)
+    start_str = start.strftime("%Y-%m-%d")
+    end_str = end.strftime("%Y-%m-%d")
+
+    # Build URL
+    url = f"{config.gsa_api_base_url}/station/historical/{RESOURCE_ID}"
+
+    # Make request
+    response = network_service.get(
+        url,
+        params={
+            "parameters": ",".join(parameters),
+            "station_ids": station_id,
+            "start": start_str,
+            "end": end_str,
+            "output_format": "geojson",
+        },
+    )
+
+    if response.status_code != 200:
+        logger.warning(
+            f"Failed to fetch monthly data for station {station_id} (status: {response.status_code}): {response.json()}",
+        )
+        return None
+
+    try:
+        data = response.json()
+
+        if not data.get("features"):
+            logger.info(f"No monthly data returned for station {station_id}")
+            return None
+
+        # Get timestamps array
+        timestamps = data.get("timestamps")
+        if not timestamps:
+            logger.warning("No timestamps in monthly response")
+            return None
+
+        # Extract time series data from GeoJSON response
+        # New API format has timestamps at top level and data as arrays
+        feature = data["features"][0]
+        props = feature.get("properties", {})
+        params_data = props.get("parameters", {})
+
+        if not params_data:
+            logger.info(f"No parameter data returned for station {station_id}")
+            return None
+
+        # Build DataFrame from timestamps and parameter arrays
+        df_dict = {}
+        for param in parameters:
+            if param in params_data:
+                param_info = params_data[param]
+                if "data" in param_info:
+                    df_dict[param] = param_info["data"]
+
+        if not df_dict:
+            return None
+
+        # Create DataFrame with timestamps as index
+        df = pd.DataFrame(df_dict)
+        dt_index = pd.DatetimeIndex(pd.to_datetime(timestamps))
+        df.index = dt_index.tz_localize(None)
+        df.index.name = "time"
+
+        # Sort by time
+        df = df.sort_index()
+
+        # Rename columns to Meteostat parameter names
+        rename_map = {}
+        for gsadh_param, meteostat_param in PARAMETER_MAPPING.items():
+            if gsadh_param in df.columns:
+                rename_map[gsadh_param] = meteostat_param
+
+        df = df.rename(columns=rename_map)
+
+        # Convert units where necessary
+        if Parameter.WSPD in df.columns:
+            df[Parameter.WSPD] = df[Parameter.WSPD].apply(ms_to_kmh)
+
+        if Parameter.TSUN in df.columns:
+            df[Parameter.TSUN] = df[Parameter.TSUN].apply(hours_to_minutes)
+
+        if Parameter.CLDC in df.columns:
+            # Convert cloud cover from % to okta
+            df[Parameter.CLDC] = df[Parameter.CLDC].apply(percentage_to_okta)
+
+        if Parameter.PRES in df.columns:
+            df[Parameter.PRES] = df.apply(
+                lambda row: pres_to_msl(row, elevation), axis=1
+            )
+
+        # Round values
+        df = df.round(1)
+
+        return df
+
+    except Exception as error:
+        logger.warning(f"Error parsing monthly response: {error}", exc_info=True)
+        return None
+
+
+def fetch(req: ProviderRequest) -> Optional[pd.DataFrame]:
+    """
+    Fetch monthly data from GeoSphere Austria Data Hub
+    """
+    if "national" not in req.station.identifiers:
+        return None
+
+    station_id = req.station.identifiers["national"]
+
+    # Map Meteostat parameters to GeoSphere Austria parameters
+    gsa_params = []
+    for param in req.parameters:
+        if param in METEOSTAT_TO_GSA:
+            gsa_params.append(METEOSTAT_TO_GSA[param])
+
+    if not gsa_params:
+        logger.info("No mappable parameters for GeoSphere Austria monthly data")
+        return None
+
+    # Fetch data
+    df = get_data(station_id, req.station.elevation, gsa_params, req.start, req.end)
+
+    if df is None or df.empty:
+        return None
+
+    return df

meteostat/providers/gsa/synop.py

@@ -0,0 +1,184 @@
+"""
+GeoSphere Austria Data Hub SYNOP hourly data import routine
+
+Get SYNOP (synoptic observation) hourly data for weather stations in Austria.
+
+License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
+"""
+
+from datetime import datetime
+from typing import Dict, Optional
+
+import pandas as pd
+
+from meteostat.enumerations import TTL, Parameter
+from meteostat.core.logger import logger
+from meteostat.typing import ProviderRequest
+from meteostat.core.cache import cache_service
+from meteostat.api.config import config
+from meteostat.core.network import network_service
+from meteostat.utils.conversions import ms_to_kmh, pres_to_msl
+
+
+RESOURCE_ID = "synop-v1-1h"
+
+# Mapping from GeoSphere Austria SYNOP parameter names to Meteostat parameters
+# See: https://dataset.api.hub.geosphere.at/v1/station/historical/synop-v1-1h/metadata
+PARAMETER_MAPPING: Dict[str, Parameter] = {
+    "T": Parameter.TEMP,  # Air temperature (°C) - Lufttemperatur
+    "Pg": Parameter.PRES,  # Air pressure (hPa) - Luftdruck auf Stationshöhe
+    "rel": Parameter.RHUM,  # Relative humidity (%) - Relative Feuchte
+    "ff": Parameter.WSPD,  # Wind speed (m/s) - Windgeschwindigkeit
+    "boe": Parameter.WPGT,  # Wind gust (m/s) - Windböe
+    "dd": Parameter.WDIR,  # Wind direction (°) - Windrichtung
+    "RRR": Parameter.PRCP,  # Precipitation (mm) - Niederschlagsmenge
+    "N": Parameter.CLDC,  # Cloud cover (okta) - Bedeckungsgrad
+}
+
+# Inverse mapping
+METEOSTAT_TO_GSA = {v: k for k, v in PARAMETER_MAPPING.items()}
+
+
+@cache_service.cache(TTL.DAY, "pickle")
+def get_data(
+    station_id: str,
+    elevation: int | None,
+    parameters: list[str],
+    start: datetime,
+    end: datetime,
+) -> Optional[pd.DataFrame]:
+    """
+    Fetch SYNOP data from GeoSphere Austria Data Hub API
+    """
+    logger.debug(
+        f"Fetching SYNOP hourly data for station '{station_id}' from {start} to {end}"
+    )
+
+    # Format dates as ISO 8601
+    start_str = start.strftime("%Y-%m-%dT%H:%M")
+    end_str = end.strftime("%Y-%m-%dT%H:%M")
+
+    # Build URL
+    url = f"{config.gsa_api_base_url}/station/historical/{RESOURCE_ID}"
+
+    # Make request
+    response = network_service.get(
+        url,
+        params={
+            "parameters": ",".join(parameters),
+            "station_ids": station_id,
+            "start": start_str,
+            "end": end_str,
+            "output_format": "geojson",
+        },
+    )
+
+    if response.status_code != 200:
+        logger.warning(
+            f"Failed to fetch SYNOP data for station {station_id} (status: {response.status_code})"
+        )
+        return None
+
+    try:
+        data = response.json()
+
+        if not data.get("features"):
+            logger.info(f"No SYNOP data returned for station {station_id}")
+            return None
+
+        # Get timestamps array
+        timestamps = data.get("timestamps")
+        if not timestamps:
+            logger.warning("No timestamps in SYNOP response")
+            return None
+
+        # Extract time series data from GeoJSON response
+        # New API format has timestamps at top level and data as arrays
+        feature = data["features"][0]
+        props = feature.get("properties", {})
+        params_data = props.get("parameters", {})
+
+        if not params_data:
+            logger.info(f"No parameter data returned for station {station_id}")
+            return None
+
+        # Build DataFrame from timestamps and parameter arrays
+        df_dict = {}
+        for param in parameters:
+            if param in params_data:
+                param_info = params_data[param]
+                if "data" in param_info:
+                    df_dict[param] = param_info["data"]
+
+        if not df_dict:
+            return None
+
+        # Create DataFrame with timestamps as index
+        df = pd.DataFrame(df_dict)
+        dt_index = pd.DatetimeIndex(pd.to_datetime(timestamps))
+        df.index = dt_index.tz_localize(None)
+        df.index.name = "time"
+
+        # Sort by time
+        df = df.sort_index()
+
+        # Rename columns to Meteostat parameter names
+        rename_map = {}
+        for gsadh_param, meteostat_param in PARAMETER_MAPPING.items():
+            if gsadh_param in df.columns:
+                rename_map[gsadh_param] = meteostat_param
+
+        df = df.rename(columns=rename_map)
+
+        # Convert units where necessary
+        if Parameter.WSPD in df.columns:
+            df[Parameter.WSPD] = df[Parameter.WSPD].apply(ms_to_kmh)
+
+        if Parameter.WPGT in df.columns:
+            df[Parameter.WPGT] = df[Parameter.WPGT].apply(ms_to_kmh)
+
+        # RRR returns -1 for no precipitation; convert to 0
+        if Parameter.PRCP in df.columns:
+            df[Parameter.PRCP] = df[Parameter.PRCP].replace(-1, 0)
+
+        if Parameter.PRES in df.columns:
+            df[Parameter.PRES] = df.apply(
+                lambda row: pres_to_msl(row, elevation), axis=1
+            )
+
+        # Round values
+        df = df.round(1)
+
+        return df
+
+    except Exception as error:
+        logger.warning(f"Error parsing SYNOP response: {error}", exc_info=True)
+        return None
+
+
+def fetch(req: ProviderRequest) -> Optional[pd.DataFrame]:
+    """
+    Fetch SYNOP hourly data from GeoSphere Austria Data Hub
+    """
+    if "wmo" not in req.station.identifiers:
+        return None
+
+    station_id = req.station.identifiers["wmo"]
+
+    # Map Meteostat parameters to GeoSphere Austria SYNOP parameters
+    gsa_params = []
+    for param in req.parameters:
+        if param in METEOSTAT_TO_GSA:
+            gsa_params.append(METEOSTAT_TO_GSA[param])
+
+    if not gsa_params:
+        logger.info("No mappable parameters for GeoSphere Austria SYNOP data")
+        return None
+
+    # Fetch data
+    df = get_data(station_id, req.station.elevation, gsa_params, req.start, req.end)
+
+    if df is None or df.empty:
+        return None
+
+    return df

meteostat/providers/index.py

@@ -473,6 +473,113 @@ PROVIDER_METNO_FORECAST = ProviderSpec(
     module="meteostat.providers.metno.forecast",
 )
 
+PROVIDER_GSA_HOURLY = ProviderSpec(
+    id=Provider.GSA_HOURLY,
+    name="GeoSphere Austria Hourly",
+    granularity=Granularity.HOURLY,
+    priority=Priority.HIGHEST,
+    grade=Grade.RECORD,
+    license=License(
+        commercial=True,
+        attribution="GeoSphere Austria",
+        name="CC BY 4.0",
+        url="https://creativecommons.org/licenses/by/4.0/",
+    ),
+    requires=["identifiers"],
+    countries=["AT"],
+    parameters=[
+        Parameter.TEMP,
+        Parameter.PRCP,
+        Parameter.PRES,
+        Parameter.WSPD,
+        Parameter.WDIR,
+        Parameter.RHUM,
+        Parameter.TSUN,
+    ],
+    start=date(1880, 4, 1),
+    module="meteostat.providers.gsa.hourly",
+)
+
+PROVIDER_GSA_SYNOP = ProviderSpec(
+    id=Provider.GSA_SYNOP,
+    name="GeoSphere Austria SYNOP",
+    granularity=Granularity.HOURLY,
+    priority=Priority.HIGH,
+    grade=Grade.OBSERVATION,
+    license=License(
+        commercial=True,
+        attribution="GeoSphere Austria",
+        name="CC BY 4.0",
+        url="https://creativecommons.org/licenses/by/4.0/",
+    ),
+    requires=["identifiers"],
+    countries=["AT"],
+    parameters=[
+        Parameter.TEMP,
+        Parameter.PRES,
+        Parameter.RHUM,
+        Parameter.WSPD,
+        Parameter.WDIR,
+        Parameter.PRCP,
+    ],
+    start=date(2000, 1, 1),
+    module="meteostat.providers.gsa.synop",
+)
+
+PROVIDER_GSA_DAILY = ProviderSpec(
+    id=Provider.GSA_DAILY,
+    name="GeoSphere Austria Daily",
+    granularity=Granularity.DAILY,
+    priority=Priority.HIGHEST,
+    grade=Grade.RECORD,
+    license=License(
+        commercial=True,
+        attribution="GeoSphere Austria",
+        name="CC BY 4.0",
+        url="https://creativecommons.org/licenses/by/4.0/",
+    ),
+    requires=["identifiers"],
+    countries=["AT"],
+    parameters=[
+        Parameter.TEMP,
+        Parameter.TMIN,
+        Parameter.TMAX,
+        Parameter.PRCP,
+        Parameter.PRES,
+        Parameter.RHUM,
+        Parameter.WSPD,
+        Parameter.TSUN,
+    ],
+    start=date(1880, 4, 1),
+    module="meteostat.providers.gsa.daily",
+)
+
+PROVIDER_GSA_MONTHLY = ProviderSpec(
+    id=Provider.GSA_MONTHLY,
+    name="GeoSphere Austria Monthly",
+    granularity=Granularity.MONTHLY,
+    priority=Priority.HIGHEST,
+    grade=Grade.RECORD,
+    license=License(
+        commercial=True,
+        attribution="GeoSphere Austria",
+        name="CC BY 4.0",
+        url="https://creativecommons.org/licenses/by/4.0/",
+    ),
+    requires=["identifiers"],
+    countries=["AT"],
+    parameters=[
+        Parameter.TEMP,
+        Parameter.TMIN,
+        Parameter.TMAX,
+        Parameter.PRCP,
+        Parameter.PRES,
+        Parameter.TSUN,
+    ],
+    start=date(1880, 4, 1),
+    module="meteostat.providers.gsa.monthly",
+)
+
 
 DEFAULT_PROVIDERS = [
     PROVIDER_HOURLY,
@@ -493,4 +600,8 @@ DEFAULT_PROVIDERS = [
     PROVIDER_CLIMAT,
     PROVIDER_METAR,
     PROVIDER_METNO_FORECAST,
+    PROVIDER_GSA_HOURLY,
+    PROVIDER_GSA_SYNOP,
+    PROVIDER_GSA_DAILY,
+    PROVIDER_GSA_MONTHLY,
 ]

meteostat/providers/metno/forecast.py

@@ -11,9 +11,6 @@ from meteostat.typing import ProviderRequest
 from meteostat.utils.conversions import percentage_to_okta
 from meteostat.core.cache import cache_service
 
-
-ENDPOINT = config.metno_forecast_endpoint
-USER_AGENT = config.metno_user_agent
 CONDICODES = {
     "clearsky": 1,
     "cloudy": 3,
@@ -130,13 +127,26 @@ def map_data(record):
 
 @cache_service.cache(TTL.HOUR, "pickle")
 def get_df(latitude: float, longitude: float, elevation: int) -> Optional[pd.DataFrame]:
-    file_url = ENDPOINT.format(
+    endpoint = config.metno_forecast_endpoint
+    user_agent = config.metno_user_agent
+
+    if not endpoint:
+        logger.warning("MET Norway forecast endpoint is not configured.")
+        return None
+
+    if not user_agent:
+        logger.warning(
+            "MET Norway requires a unique user agent as per their terms of service. Please use config to specify your user agent. For now, this provider is skipped."
+        )
+        return None
+
+    file_url = endpoint.format(
         latitude=latitude,
         longitude=longitude,
         elevation=elevation,
     )
 
-    headers = {"User-Agent": USER_AGENT}
+    headers = {"User-Agent": user_agent}
 
     try:
         response = network_service.get(file_url, headers=headers)
@@ -173,12 +183,6 @@ def get_df(latitude: float, longitude: float, elevation: int) -> Optional[pd.Dat
 
 
 def fetch(req: ProviderRequest) -> Optional[pd.DataFrame]:
-    if not USER_AGENT:
-        logger.warning(
-            "MET Norway requires a unique user agent as per their terms of service. Please use config to specify your user agent. For now, this provider is skipped."
-        )
-        return None
-
     return get_df(
         req.station.latitude,
         req.station.longitude,

meteostat/providers/noaa/ghcnd.py

@@ -82,7 +82,7 @@ def create_df(element, dict_element):
         df_element = move_col_to_front(col, df_element)
 
     # Convert numerical values to float
-    df_element.loc[:, element] = df_element.loc[:, element].astype(float)
+    df_element[element] = df_element[element].astype(float)
 
     return df_element
 

meteostat/providers/noaa/isd_lite.py

@@ -65,13 +65,26 @@ def get_df(usaf: str, wban: str, year: int) -> Optional[pd.DataFrame]:
     try:
         df = pd.read_fwf(
             f"{ISD_LITE_ENDPOINT}{year}/{filename}",
-            parse_dates={"time": [0, 1, 2, 3]},
             na_values=["-9999", -9999],
             header=None,
             colspecs=COLSPECS,
             compression="gzip",
         )
 
+        # Parse datetime from first 4 columns (year, month, day, hour)
+        df[0] = pd.to_datetime(
+            df[0].astype(str)
+            + "-"
+            + df[1].astype(str).str.zfill(2)
+            + "-"
+            + df[2].astype(str).str.zfill(2)
+            + " "
+            + df[3].astype(str).str.zfill(2)
+            + ":00",
+            format="%Y-%m-%d %H:%M",
+        )
+        df = df.drop(columns=[1, 2, 3])
+
         # Rename columns
         df.columns = COLUMN_NAMES
 

meteostat/utils/conversions.py

@@ -8,7 +8,7 @@ The code is licensed under the MIT license.
 import math
 from typing import Optional
 
-from numpy import isnan
+import pandas as pd
 
 from meteostat.enumerations import Parameter, Unit, UnitSystem
 
@@ -73,14 +73,21 @@ def kelvin_to_celsius(value):
     """
     Convert Kelvin to Celsius
     """
-    return value - 273.15 if value is not None and not isnan(value) else None
+    return value - 273.15 if not pd.isna(value) else None
 
 
 def ms_to_kmh(value):
     """
     Convert m/s to km/h
     """
-    return value * 3.6 if value is not None and not isnan(value) else None
+    return value * 3.6 if not pd.isna(value) else None
+
+
+def hours_to_minutes(value):
+    """
+    Convert duration from hours to minutes
+    """
+    return value * 60 if not pd.isna(value) else None
 
 
 def temp_dwpt_to_rhum(row: dict):
@@ -93,38 +100,30 @@ def temp_dwpt_to_rhum(row: dict):
             math.exp((17.625 * row["dwpt"]) / (243.04 + row["dwpt"]))
             / math.exp((17.625 * row["temp"]) / (243.04 + row["temp"]))
         )
-        if row["temp"] is not None and row["dwpt"] is not None
+        if not pd.isna(row["temp"]) and not pd.isna(row["dwpt"])
         else None
     )
 
 
 def pres_to_msl(row: dict, altitude: Optional[int] = None, temp: str = Parameter.TEMP):
-    """
-    Convert local air pressure to MSL
-    """
     try:
-        return (
-            None
-            if (
-                not row[Parameter.PRES]
-                or not row[temp]
-                or not altitude
-                or row[Parameter.PRES] == -999
-            )
-            else round(
-                row[Parameter.PRES]
-                * math.pow(
-                    (
-                        1
-                        - (
-                            (0.0065 * altitude)
-                            / (row[temp] + 0.0065 * altitude + 273.15)
-                        )
-                    ),
-                    -5.257,
-                ),
-                1,
-            )
+        pres = row.get(Parameter.PRES)
+        t = row.get(temp)
+
+        if pd.isna(pres) or pd.isna(t) or altitude is None or pres == -999:
+            return None
+
+        # Type narrowing for arithmetic operations
+        if not isinstance(pres, (int, float)) or not isinstance(t, (int, float)):
+            return None
+
+        return round(
+            pres
+            * math.pow(
+                1 - (0.0065 * altitude) / (t + 0.0065 * altitude + 273.15),
+                -5.257,
+            ),
+            1,
         )
     except Exception:
         return None
@@ -134,14 +133,14 @@ def percentage_to_okta(value):
     """
     Convert cloud cover percentage to oktas
     """
-    return round(value / 12.5) if value is not None and not isnan(value) else None
+    return round(value / 12.5) if not pd.isna(value) else None
 
 
 def jcm2_to_wm2(value):
     """
     Convert Joule/CM^2 to Watt/M^2
     """
-    return round(value * 2.78) if value is not None and not isnan(value) else None
+    return round(value * 2.78) if not pd.isna(value) else None
 
 
 def to_direction(value):

{meteostat-2.0.1.dist-info → meteostat-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meteostat
-Version: 2.0.1
+Version: 2.1.0
 Summary: Access and analyze historical weather and climate data with Python.
 License-File: LICENSE
 Author: Meteostat
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: pandas (>=2.3.3,<3.0.0)
+Requires-Dist: pandas (>=2.3.0,<4.0.0)
 Requires-Dist: pytz (>=2023.3.post1,<2024.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Description-Content-Type: text/markdown

{meteostat-2.0.1.dist-info → meteostat-2.1.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-meteostat/__init__.py,sha256=uoBFnarB7WQtLj61mM-U2FHBq06FLHKLfdSKlTVq7i4,1555
+meteostat/__init__.py,sha256=bKXwCYMUdZrlNTPTHImXKbELKuEe0JS_YhBhZnAgWrI,1555
 meteostat/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-meteostat/api/config.py,sha256=DpZ20TLcc7S1uJV_N_SBv2qtVorNgB0hFzX2sHs0tXM,5065
+meteostat/api/config.py,sha256=NYRZBHZkxXsGQXgPptO_ic-Ct2dtczWWgpCIt2LgL78,5166
 meteostat/api/daily.py,sha256=SUYxR7HC5Cqyd6cBG42QmSpEP74HwDq5VnqfSznM46Y,2371
 meteostat/api/hourly.py,sha256=KGJ4xBwO__fBrQ5ll5ruLEkrpOCD8bybSBcXJ94-ntE,2556
 meteostat/api/interpolate.py,sha256=6i128g_x5ea3X2Nkn6IlrtPaKqRfakozOcSheTbmxIM,12602
@@ -19,17 +19,17 @@ meteostat/core/parameters.py,sha256=7BJIkFQaxcBRi1yIDgpAYm2VZxBfVPbi5_UdZL9teXE,
 meteostat/core/providers.py,sha256=DChq-vILb9uWEcsZmUcUnyeuVGtl3Ote49QhibdeNBo,5490
 meteostat/core/schema.py,sha256=Jbp84bTgWmfhPYhORluGWLEnogevsFiAjwC21Y4Mbwg,5070
 meteostat/core/validator.py,sha256=pJOJIU8FtYO4k7ihGqFxM6CSs9O6oO-fByYyJeJ9pZY,887
-meteostat/enumerations.py,sha256=1lWrnzejtV1uP5CjyeyN-UcYt8wBIqlc5sxwzwh5Rqg,3271
+meteostat/enumerations.py,sha256=FxB1s9gP1Ros2hN0zDZa1TSABfSgym11E0pigHqXPPY,3389
 meteostat/interpolation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meteostat/interpolation/idw.py,sha256=AyZWxXjq8mS9BEQtxgSEHQzn7TZYIdkc22kPkF5qZww,4435
 meteostat/interpolation/lapserate.py,sha256=D5Y2DLMgjCNmqfdm2J5MU67w0O6L0vx_TbgMaGrMQuc,2637
 meteostat/interpolation/nearest.py,sha256=xZg_6OCvU8uI-i7UbPQHjsJmtlz_DbZqrDz00dJthEM,782
 meteostat/parameters.py,sha256=w7G3ktLVasAbaR9OnjuMAvrq_c1zLz5PVt3zofDFun4,10074
 meteostat/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-meteostat/providers/dwd/climat.py,sha256=jEHvg9m8L0161n1j7DHOiBWyky7WL0SD-TrlkljoYCI,4875
+meteostat/providers/dwd/climat.py,sha256=vLCTk0PZgPliyTsNwbNWnKeUEXChA9dA23UtCxOa7tA,4866
 meteostat/providers/dwd/daily.py,sha256=qVZjMUu6a1GODaWrKpzbOYdXS9HyEkKp9XwnY47Md44,4030
 meteostat/providers/dwd/hourly.py,sha256=LAjnQJrp80wOhX24JwuceAtCi104DC8EDwEZetHDrso,6249
-meteostat/providers/dwd/monthly.py,sha256=JaXklCJrH_xlQPm1G6PXoVvV81qwnhT2o1mXXEzM2LQ,3658
+meteostat/providers/dwd/monthly.py,sha256=FiUdMzLwnGLFu1Nxt9KW5VAUyRYA9tXCbsr2T1iCw_w,3719
 meteostat/providers/dwd/mosmix.py,sha256=uDalWL-_Vayyq3iiiCUWPFmKXSYqQttXiDOF2Lk_qB4,8892
 meteostat/providers/dwd/poi.py,sha256=Qv4eDsi_a8hdBQKl1LPQJ0BO2UbTxfba9gH5Ht2giZ0,3087
 meteostat/providers/dwd/shared.py,sha256=z4LT0fd7LFUqpVPJRJyNWJxK_6TRzJFDvolv6_Y9PME,2917
@@ -37,28 +37,33 @@ meteostat/providers/eccc/daily.py,sha256=K-akr9JXYMnsdG1YlM9SPXUcDfVzv61KsCqD9Ie
 meteostat/providers/eccc/hourly.py,sha256=W2qMX0HxffMs1IlBzKY4b0M58wPJvtDw7Py4xyDuNO8,3209
 meteostat/providers/eccc/monthly.py,sha256=eA5JRpDa7-2H-Ce4FOstY24ECWj_gTY5vRbvZa_LCLE,1805
 meteostat/providers/eccc/shared.py,sha256=2m00uWYdWQrVqvxwMioLIKFxlrjLmCfqIYwjx30r_9k,1324
-meteostat/providers/index.py,sha256=6UrzxtynwbILOxg_lmE_Ylh747GZzDW_6ytGIEQHTNc,12670
+meteostat/providers/gsa/__init__.py,sha256=a4SQxle7PvurmZWrzw8mxOpWxv1cztnhf0I6OXza2Lk,44
+meteostat/providers/gsa/daily.py,sha256=OBD2oq2RQJ8CQBAKLsEyzfGWSkA2QylFLFlp5n_46Q8,6298
+meteostat/providers/gsa/hourly.py,sha256=yDeF-periIV0aq2PSHDHVpcgfHMaNA_twXZ-Ob6sP5o,5392
+meteostat/providers/gsa/monthly.py,sha256=hniTVaSvsidP0I7No42OncmeGBVU0k05jDnFrZrabhI,6376
+meteostat/providers/gsa/synop.py,sha256=P46RtF6nF5eaMiFUECML1XZiKzMcxbV0G5S6JCLNWRs,5827
+meteostat/providers/index.py,sha256=W4Jd3Fgq-iYpPLZopqKcFGPU_hCUjhTejLVw-l3WYk4,15511
 meteostat/providers/meteostat/daily.py,sha256=32vh0J5caMT9gshfUBQXoH8CB3r3qf4BUlB3VztvPN0,1795
 meteostat/providers/meteostat/daily_derived.py,sha256=_fiLSKxkaH9Caxp-Tg77rH39UXwy7SPDlCS_M-7kIqE,3170
 meteostat/providers/meteostat/hourly.py,sha256=INO5JVaDbd3zIEo3_spIwACoBpYqDXinyrL-pW1AIAk,1798
 meteostat/providers/meteostat/monthly.py,sha256=4N2ThwBroQVz2wI5UI2WpvIUGOH61gS63rP8ZVaMqOE,1253
 meteostat/providers/meteostat/monthly_derived.py,sha256=8BNSd2-xqABdr3lDU_9noypF91qhRJPhz5liTK0eoR8,3075
 meteostat/providers/meteostat/shared.py,sha256=mK2K3tbgtCcKLMITR5NJVuJSBkPm_jLcN0dBRT9hM90,2571
-meteostat/providers/metno/forecast.py,sha256=x-q21HiGkJ4yiv7vKcPnVSFin3rFGHWAZqtzJE0j4Tk,5661
-meteostat/providers/noaa/ghcnd.py,sha256=AaR-efQkbgc3afwcvMd_H25_l1dV5CFmautn9TWQ6Cw,6789
-meteostat/providers/noaa/isd_lite.py,sha256=YfqhWJjNjxirbqeGaRsQo07koEREvY-APVETkZ3eBKM,3817
+meteostat/providers/metno/forecast.py,sha256=aMoOikEh2agMCw6ZLFMcHPnT-9VMQ1_qpx7e2K3B_-g,5785
+meteostat/providers/noaa/ghcnd.py,sha256=xOvp0DGi6XARZQBwbImDI5o_5QoNEXXr2e2JtUAUTyk,6775
+meteostat/providers/noaa/isd_lite.py,sha256=bPnGEFzvb3LA8n8OmurCToW5HTb5aJSa1FXJQgC_3rI,4200
 meteostat/providers/noaa/metar.py,sha256=wqH0zEUZO0gS0inK5vvxKulz-LF3NEZIAsYHmR0Do64,4188
 meteostat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meteostat/typing.py,sha256=Q4_le4P_yOVyv1FAxtccNDfFc0OPzYKm3p-GTTptGAY,3504
 meteostat/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-meteostat/utils/conversions.py,sha256=B1qaL3_OSbWniIsFCwDPnwWtmglRiBBswFK1q0NH4bI,4755
+meteostat/utils/conversions.py,sha256=qR4eSyN8hpaSDKk-VvDmgT-paJq0fjxaT-lz6X1pmYk,4652
 meteostat/utils/data.py,sha256=d_aQy53jdhDAvFvo0qVPyhR2NH-WKIAeNm_kIobJOq8,6119
 meteostat/utils/geo.py,sha256=n_imXze6-u0vzFdYrgPyStKqGNuERcUmXUA-PsAja2w,664
 meteostat/utils/guards.py,sha256=fuBd4_6BXfZT_jPYU6GzXgDBnCc_GVLDpI6PSK3PCno,1746
 meteostat/utils/parsers.py,sha256=2y-QSubyrh_xdXJBdgWNiWNI_DDXCGxddcjGOZB9hCU,4646
 meteostat/utils/types.py,sha256=_hzGcVueIGZdjCB6mR4vVFedrPUWw0iMRaLkpnqaN2Y,3470
 meteostat/utils/validators.py,sha256=iBywF68ZhL3eD6fgemY2Tng3a-409eFU2oNZVqpYCpY,524
-meteostat-2.0.1.dist-info/METADATA,sha256=cAXHfPnAXC-3gEpeUMfmRqURQWjOufDsXHfX_fjm650,5024
-meteostat-2.0.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-meteostat-2.0.1.dist-info/licenses/LICENSE,sha256=kqpl7FVzWOCe11BZqJBZ1aRQi-aK87j3ljtG7P3VxLc,1066
-meteostat-2.0.1.dist-info/RECORD,,
+meteostat-2.1.0.dist-info/METADATA,sha256=wgyYCQMPf3x7L7AJVxfuIyMl0D02e5UYxGOwdSz5waM,5024
+meteostat-2.1.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+meteostat-2.1.0.dist-info/licenses/LICENSE,sha256=kqpl7FVzWOCe11BZqJBZ1aRQi-aK87j3ljtG7P3VxLc,1066
+meteostat-2.1.0.dist-info/RECORD,,

{meteostat-2.0.1.dist-info → meteostat-2.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any