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

meteostat/interface/normals.py

@@ -1,245 +0,0 @@
-"""
-Normals Interface Class
-
-Meteorological data provided by Meteostat (https://dev.meteostat.net)
-under the terms of the Creative Commons Attribution-NonCommercial
-4.0 International Public License.
-
-The code is licensed under the MIT license.
-"""
-
-from copy import copy
-from typing import Optional, Union
-from datetime import datetime
-import numpy as np
-import pandas as pd
-from meteostat.core.cache import file_in_cache, get_local_file_path
-from meteostat.core.loader import load_handler
-from meteostat.utilities.endpoint import generate_endpoint_path
-from meteostat.enumerations.granularity import Granularity
-from meteostat.core.warn import warn
-from meteostat.interface.meteodata import MeteoData
-from meteostat.interface.point import Point
-
-
-class Normals(MeteoData):
-    """
-    Retrieve climate normals for one or multiple weather stations or
-    a single geographical point
-    """
-
-    # The cache subdirectory
-    cache_subdir = "normals"
-
-    # Granularity
-    granularity = Granularity.NORMALS
-
-    # The list of weather Stations
-    _stations: Optional[pd.Index] = None
-
-    # The first year of the period
-    _start: Optional[int] = None
-
-    # The last year of the period
-    _end: Optional[int] = None
-
-    # The data frame
-    _data: pd.DataFrame = pd.DataFrame()
-
-    # Columns
-    _columns = [
-        "start",
-        "end",
-        "month",
-        "tmin",
-        "tmax",
-        "prcp",
-        "wspd",
-        "pres",
-        "tsun",
-    ]
-
-    # Index of first meteorological column
-    _first_met_col = 3
-
-    # Which columns should be parsed as dates?
-    _parse_dates = None
-
-    def _load_data(self, station: str, year: Optional[int] = None) -> None:
-        """
-        Load file for a single station from Meteostat
-        """
-
-        # File name
-        file = generate_endpoint_path(self.granularity, station, year)
-
-        # Get local file path
-        path = get_local_file_path(self.cache_dir, self.cache_subdir, file)
-
-        # Check if file in cache
-        if self.max_age > 0 and file_in_cache(path, self.max_age):
-            # Read cached data
-            df = pd.read_pickle(path)
-
-        else:
-            # Get data from Meteostat
-            df = load_handler(
-                self.endpoint,
-                file,
-                self.proxy,
-                self._columns,
-            )
-
-            # Validate and prepare data for further processing
-            if not df.empty:
-                # Add weather station ID
-                df["station"] = station
-
-                # Set index
-                df = df.set_index(["station", "start", "end", "month"])
-
-            # Save as Pickle
-            if self.max_age > 0:
-                df.to_pickle(path)
-
-        # Filter time period and append to DataFrame
-        if self.granularity == Granularity.NORMALS and not df.empty and self._end:
-            # Get time index
-            end = df.index.get_level_values("end")
-            # Filter & return
-            return df.loc[end == self._end]
-
-        # Return
-        return df
-
-    def __init__(
-        self,
-        loc: Union[pd.DataFrame, Point, list, str],
-        start: int = None,
-        end: int = None,
-    ) -> None:
-        # Set list of weather stations
-        if isinstance(loc, pd.DataFrame):
-            self._stations = loc.index
-
-        elif isinstance(loc, Point):
-            if start and end:
-                stations = loc.get_stations(
-                    "monthly", datetime(start, 1, 1), datetime(end, 12, 31)
-                )
-            else:
-                stations = loc.get_stations()
-
-            self._stations = stations.index
-
-        else:
-            if not isinstance(loc, list):
-                loc = [loc]
-
-            self._stations = pd.Index(loc)
-
-        # Check period
-        if (start and end) and (
-            end - start != 29 or end % 10 != 0 or end >= datetime.now().year
-        ):
-            raise ValueError("Invalid reference period")
-
-        # Set period
-        self._start = start
-        self._end = end
-
-        # Get data for all weather stations
-        self._data = self._get_data()
-
-        # Interpolate data
-        if isinstance(loc, Point):
-            self._resolve_point(loc.method, stations, loc.alt, loc.adapt_temp)
-
-        # Clear cache
-        if self.max_age > 0 and self.autoclean:
-            self.clear_cache()
-
-    def normalize(self):
-        """
-        Normalize the DataFrame
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        if self.count() == 0:
-            warn("Pointless normalization of empty DataFrame")
-
-        # Go through list of weather stations
-        for station in temp._stations:
-            # The list of periods
-            periods: pd.Index = pd.Index([])
-            # Get periods
-            if self.count() > 0:
-                periods = temp._data[
-                    temp._data.index.get_level_values("station") == station
-                ].index.unique("end")
-            elif periods.size == 0 and self._end:
-                periods = pd.Index([self._end])
-            # Go through all periods
-            for period in periods:
-                # Create DataFrame
-                df = pd.DataFrame(
-                    columns=temp._columns[temp._first_met_col :], dtype="float64"
-                )
-                # Populate index columns
-                df["month"] = range(1, 13)
-                df["station"] = station
-                df["start"] = period - 29
-                df["end"] = period
-                # Set index
-                df.set_index(["station", "start", "end", "month"], inplace=True)
-                # Merge data
-                temp._data = (
-                    pd.concat([temp._data, df], axis=0)
-                    .groupby(["station", "start", "end", "month"], as_index=True)
-                    .first()
-                    if temp._data.index.size > 0
-                    else df
-                )
-
-        # None -> nan
-        temp._data = temp._data.fillna(np.nan)
-
-        # Return class instance
-        return temp
-
-    def fetch(self) -> pd.DataFrame:
-        """
-        Fetch DataFrame
-        """
-
-        # Copy DataFrame
-        temp = copy(self._data)
-
-        # Add avg. temperature column
-        temp.insert(
-            0,
-            "tavg",
-            pd.to_numeric(
-                temp[["tmin", "tmax"]].dropna(how="any").mean(axis=1),
-                errors="coerce"
-            ).round(1)
-        )
-
-        # Remove station index if it's a single station
-        if len(self._stations) == 1 and "station" in temp.index.names:
-            temp = temp.reset_index(level="station", drop=True)
-
-        # Remove start & end year if period is set
-        if self._start and self._end and self.count() > 0:
-            temp = temp.reset_index(level="start", drop=True)
-            temp = temp.reset_index(level="end", drop=True)
-
-        # Return data frame
-        return temp
-
-    # Import methods
-    from meteostat.series.convert import convert
-    from meteostat.series.count import count
-    from meteostat.core.cache import clear_cache

meteostat/interface/point.py

@@ -1,143 +0,0 @@
-"""
-Point Class
-
-Meteorological data provided by Meteostat (https://dev.meteostat.net)
-under the terms of the Creative Commons Attribution-NonCommercial
-4.0 International Public License.
-
-The code is licensed under the MIT license.
-"""
-
-from datetime import datetime
-import pandas as pd
-from meteostat.interface.stations import Stations
-
-
-class Point:
-    """
-    Automatically select weather stations by geographic location
-    """
-
-    # The interpolation method (weighted or nearest)
-    method: str = "nearest"
-
-    # Maximum radius for nearby stations
-    radius: int = 35000
-
-    # Maximum difference in altitude
-    alt_range: int = 350
-
-    # Maximum number of stations
-    max_count: int = 4
-
-    # Adapt temperature data based on altitude
-    adapt_temp: bool = True
-
-    # Distance Weight
-    weight_dist: float = 0.6
-
-    # Altitude Weight
-    weight_alt: float = 0.4
-
-    # The list of weather stations
-    _stations: pd.Index = None
-
-    # The latitude
-    _lat: float = None
-
-    # The longitude
-    _lon: float = None
-
-    # The altitude
-    _alt: int = None
-
-    def __init__(self, lat: float, lon: float, alt: int = None) -> None:
-        self._lat = lat
-        self._lon = lon
-        self._alt = alt
-
-        if alt is None:
-            self.adapt_temp = False
-
-    def get_stations(
-        self,
-        freq: str = None,
-        start: datetime = None,
-        end: datetime = None,
-        model: bool = True,
-    ) -> pd.DataFrame:
-        """
-        Get list of nearby weather stations
-        """
-
-        # Get nearby weather stations
-        stations = Stations()
-        stations = stations.nearby(self._lat, self._lon, self.radius)
-
-        # Guess altitude if not set
-        if self._alt is None:
-            self._alt = stations.fetch().head(self.max_count)["elevation"].mean()
-
-        # Captue unfiltered weather stations
-        unfiltered = stations.fetch()
-        if self.alt_range:
-            unfiltered = unfiltered[
-                abs(self._alt - unfiltered["elevation"]) <= self.alt_range
-            ]
-
-        # Apply inventory filter
-        if freq and start and end:
-            age = (datetime.now() - end).days
-            if model is False or age > 180:
-                stations = stations.inventory(freq, (start, end))
-
-        # Apply altitude filter
-        stations = stations.fetch()
-        if self.alt_range:
-            stations = stations[
-                abs(self._alt - stations["elevation"]) <= self.alt_range
-            ]
-
-        # Fill up stations
-        selected: int = len(stations.index)
-        if selected < self.max_count:
-            # Remove already included stations from unfiltered
-            unfiltered = unfiltered.loc[~unfiltered.index.isin(stations.index)]
-            # Append to existing DataFrame
-            stations = pd.concat((stations, unfiltered.head(self.max_count - selected)))
-
-        # Score values
-        if self.radius:
-            # Calculate score values
-            stations["score"] = (
-                (1 - (stations["distance"] / self.radius)) * self.weight_dist
-            ) + (
-                (1 - (abs(self._alt - stations["elevation"]) / self.alt_range))
-                * self.weight_alt
-            )
-
-            # Sort by score (descending)
-            stations = stations.sort_values("score", ascending=False)
-
-        # Capture result
-        self._stations = stations.index[: self.max_count]
-
-        return stations.head(self.max_count)
-
-    @property
-    def alt(self) -> int:
-        """
-        Returns the point's altitude
-        """
-
-        # Return altitude
-        return self._alt
-
-    @property
-    def stations(self) -> pd.Index:
-        """
-        Returns the point's weather stations
-        """
-
-        # Return weather stations
-        return self._stations

meteostat/interface/stations.py

@@ -1,252 +0,0 @@
-"""
-Stations Class
-
-Meteorological data provided by Meteostat (https://dev.meteostat.net)
-under the terms of the Creative Commons Attribution-NonCommercial
-4.0 International Public License.
-
-The code is licensed under the MIT license.
-"""
-
-from copy import copy
-from datetime import datetime, timedelta
-from typing import Union
-import pandas as pd
-from meteostat.core.cache import get_local_file_path, file_in_cache
-from meteostat.core.loader import load_handler
-from meteostat.interface.base import Base
-from meteostat.utilities.helpers import get_distance
-
-
-class Stations(Base):
-    """
-    Select weather stations from the full list of stations
-    """
-
-    # The cache subdirectory
-    cache_subdir: str = "stations"
-
-    # The list of selected weather Stations
-    _data: pd.DataFrame = None
-
-    # Raw data columns
-    _columns: list = [
-        "id",
-        "name",
-        "country",
-        "region",
-        "wmo",
-        "icao",
-        "latitude",
-        "longitude",
-        "elevation",
-        "timezone",
-        "hourly_start",
-        "hourly_end",
-        "daily_start",
-        "daily_end",
-        "monthly_start",
-        "monthly_end",
-    ]
-
-    # Processed data columns with types
-    _types: dict = {
-        "id": "string",
-        "name": "object",
-        "country": "string",
-        "region": "string",
-        "wmo": "string",
-        "icao": "string",
-        "latitude": "float64",
-        "longitude": "float64",
-        "elevation": "float64",
-        "timezone": "string",
-    }
-
-    # Columns for date parsing
-    _parse_dates: list = [10, 11, 12, 13, 14, 15]
-
-    def _load(self) -> None:
-        """
-        Load file from Meteostat
-        """
-
-        # File name
-        file = "stations/slim.csv.gz"
-
-        # Get local file path
-        path = get_local_file_path(self.cache_dir, self.cache_subdir, file)
-
-        # Check if file in cache
-        if self.max_age > 0 and file_in_cache(path, self.max_age):
-            # Read cached data
-            df = pd.read_pickle(path)
-
-        else:
-            # Get data from Meteostat
-            df = load_handler(
-                self.endpoint,
-                file,
-                self.proxy,
-                self._columns,
-                self._types,
-                self._parse_dates,
-            )
-
-            # Add index
-            df = df.set_index("id")
-
-            # Save as Pickle
-            if self.max_age > 0:
-                df.to_pickle(path)
-
-        # Set data
-        self._data = df
-
-    def __init__(self) -> None:
-        # Get all weather stations
-        self._load()
-
-    def nearby(self, lat: float, lon: float, radius: int = None) -> "Stations":
-        """
-        Sort/filter weather stations by physical distance
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        # Get distance for each station
-        temp._data["distance"] = get_distance(
-            lat, lon, temp._data["latitude"], temp._data["longitude"]
-        )
-
-        # Filter by radius
-        if radius:
-            temp._data = temp._data[temp._data["distance"] <= radius]
-
-        # Sort stations by distance
-        temp._data.columns.str.strip()
-        temp._data = temp._data.sort_values("distance")
-
-        # Return self
-        return temp
-
-    def region(self, country: str, state: str = None) -> "Stations":
-        """
-        Filter weather stations by country/region code
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        # Country code
-        temp._data = temp._data[temp._data["country"] == country]
-
-        # State code
-        if state is not None:
-            temp._data = temp._data[temp._data["region"] == state]
-
-        # Return self
-        return temp
-
-    def bounds(self, top_left: tuple, bottom_right: tuple) -> "Stations":
-        """
-        Filter weather stations by geographical bounds
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        # Return stations in boundaries
-        temp._data = temp._data[
-            (temp._data["latitude"] <= top_left[0])
-            & (temp._data["latitude"] >= bottom_right[0])
-            & (temp._data["longitude"] <= bottom_right[1])
-            & (temp._data["longitude"] >= top_left[1])
-        ]
-
-        # Return self
-        return temp
-
-    def inventory(
-        self, freq: str, required: Union[datetime, tuple, bool] = True
-    ) -> "Stations":
-        """
-        Filter weather stations by inventory data
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        if required is True:
-            # Make sure data exists at all
-            temp._data = temp._data[~pd.isna(temp._data[f"{freq}_start"])]
-
-        elif isinstance(required, tuple):
-            # Make sure data exists across period
-            temp._data = temp._data[
-                (~pd.isna(temp._data[f"{freq}_start"]))
-                & (temp._data[freq + "_start"] <= required[0])
-                & (
-                    temp._data[freq + "_end"] + timedelta(seconds=temp.max_age)
-                    >= required[1]
-                )
-            ]
-
-        else:
-            # Make sure data exists on a certain day
-            temp._data = temp._data[
-                (~pd.isna(temp._data[f"{freq}_start"]))
-                & (temp._data[freq + "_start"] <= required)
-                & (
-                    temp._data[freq + "_end"] + timedelta(seconds=temp.max_age)
-                    >= required
-                )
-            ]
-
-        return temp
-
-    def convert(self, units: dict) -> "Stations":
-        """
-        Convert columns to a different unit
-        """
-
-        # Create temporal instance
-        temp = copy(self)
-
-        # Change data units
-        for parameter, unit in units.items():
-            if parameter in temp._data.columns.values:
-                temp._data[parameter] = temp._data[parameter].apply(unit)
-
-        # Return class instance
-        return temp
-
-    def count(self) -> int:
-        """
-        Return number of weather stations in current selection
-        """
-
-        return len(self._data.index)
-
-    def fetch(self, limit: int = None, sample: bool = False) -> pd.DataFrame:
-        """
-        Fetch all weather stations or a (sampled) subset
-        """
-
-        # Copy DataFrame
-        temp = copy(self._data)
-
-        # Return limited number of sampled entries
-        if sample and limit:
-            return temp.sample(limit)
-
-        # Return limited number of entries
-        if limit:
-            return temp.head(limit)
-
-        # Return all entries
-        return temp
-
-    # Import additional methods
-    from meteostat.core.cache import clear_cache