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

meteostat/interface/timeseries.py

@@ -1,237 +0,0 @@
-"""
-TimeSeries 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
-from typing import Optional, Union
-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.enumerations.granularity import Granularity
-from meteostat.utilities.endpoint import generate_endpoint_path
-from meteostat.utilities.mutations import filter_time, localize
-from meteostat.utilities.validations import validate_series
-from meteostat.utilities.helpers import get_flag_from_source_factory, with_suffix
-from meteostat.interface.point import Point
-from meteostat.interface.meteodata import MeteoData
-
-
-class TimeSeries(MeteoData):
-    """
-    TimeSeries class which provides features which are
-    used across all time series classes
-    """
-
-    # Base URL of the Meteostat bulk data interface
-    endpoint = "https://data.meteostat.net/"
-
-    # The list of origin weather Stations
-    _origin_stations: Optional[pd.Index] = None
-
-    # The start date
-    _start: Optional[datetime] = None
-
-    # The end date
-    _end: Optional[datetime] = None
-
-    # Include model data?
-    _model = True
-
-    # Fetch source flags?
-    _flags = False
-
-    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,
-                default_df=pd.DataFrame(
-                    columns=self._raw_columns
-                    + with_suffix(self._raw_columns, "_source")
-                ),
-            )
-
-            # Add time column and drop original columns
-            if len(self._parse_dates) < 3:
-                df["day"] = 1
-
-            df["time"] = pd.to_datetime(
-                df[
-                    (
-                        self._parse_dates
-                        if len(self._parse_dates) > 2
-                        else self._parse_dates + ["day"]
-                    )
-                ]
-            )
-            df = df.drop(self._parse_dates, axis=1)
-
-            # Validate and prepare data for further processing
-            df = validate_series(df, station)
-
-            # Rename columns
-            df = df.rename(columns=self._renamed_columns, errors="ignore")
-
-            # Convert sources to flags
-            for col in df.columns:
-                basecol = col[:-7] if col.endswith("_source") else col
-
-                if basecol not in self._processed_columns:
-                    df.drop(col, axis=1, inplace=True)
-                    continue
-
-                if basecol == col:
-                    df[col] = df[col].astype("Float64")
-
-                if col.endswith("_source"):
-                    flagcol = f"{basecol}_flag"
-                    df[flagcol] = pd.NA
-                    df[flagcol] = df[flagcol].astype("string")
-                    mask = df[col].notna()
-                    df.loc[mask, flagcol] = df.loc[mask, col].apply(
-                        get_flag_from_source_factory(
-                            self._source_mappings, self._model_flag
-                        )
-                    )
-                    df.drop(col, axis=1, inplace=True)
-
-            # Process virtual columns
-            for key, value in self._virtual_columns.items():
-                df = value(df, key)
-
-            # Save as Pickle
-            if self.max_age > 0:
-                df.to_pickle(path)
-
-        # Localize time column
-        if (
-            self.granularity == Granularity.HOURLY
-            and self._timezone is not None
-            and len(df.index) > 0
-        ):
-            df = localize(df, self._timezone)
-
-        # Filter time period and append to DataFrame
-        df = filter_time(df, self._start, self._end)
-
-        # Return
-        return df
-
-    def _filter_model(self) -> None:
-        """
-        Remove model data from time series
-        """
-
-        for col_name in self._processed_columns:
-            self._data.loc[
-                (pd.isna(self._data[f"{col_name}_flag"]))
-                | (self._data[f"{col_name}_flag"].str.contains(self._model_flag)),
-                col_name,
-            ] = pd.NA
-
-        # Drop nan-only rows
-        self._data.dropna(how="all", subset=self._processed_columns, inplace=True)
-
-    def _init_time_series(
-        self,
-        loc: Union[pd.DataFrame, Point, list, str],  # Station(s) or geo point
-        start: datetime = None,
-        end: datetime = None,
-        model=True,  # Include model data?
-        flags=False,  # Load source flags?
-    ) -> None:
-        """
-        Common initialization for all time series, regardless
-        of its granularity
-        """
-
-        # Set list of weather stations based on user
-        # input or retrieve list of stations programatically
-        # if location is a geographical point
-        if isinstance(loc, pd.DataFrame):
-            self._stations = loc.index
-        elif isinstance(loc, Point):
-            stations = loc.get_stations("daily", start, end, model)
-            self._stations = stations.index
-        else:
-            if not isinstance(loc, list):
-                loc = [loc]
-            self._stations = pd.Index(loc)
-
-        # Preserve settings
-        self._start = start if self._start is None else self._start
-        self._end = end if self._end is None else self._end
-        self._model = model
-        self._flags = flags
-
-        # Get data for all weather stations
-        self._data = self._get_data()
-
-        # Fill columns if they don't exist
-        for col in self._processed_columns:
-            if col not in self._data.columns:
-                self._data[col] = pd.NA
-                self._data[col] = self._data[col].astype("Float64")
-            if (flagcol := f"{col}_flag") not in self._data.columns:
-                self._data[flagcol] = pd.NA
-                self._data[flagcol] = self._data[flagcol].astype("string")
-
-        # Reorder the DataFrame
-        self._data = self._data[
-            self._processed_columns + with_suffix(self._processed_columns, "_flag")
-        ]
-
-        # Remove model data from DataFrame
-        if not model:
-            self._filter_model()
-
-        # Conditionally, remove flags from DataFrame
-        if not self._flags:
-            self._data.drop(
-                with_suffix(self._processed_columns, "_flag"),
-                axis=1,
-                errors="ignore",
-                inplace=True,
-            )
-
-        # Interpolate data spatially if requested
-        # location is a geographical point
-        if isinstance(loc, Point):
-            self._resolve_point(loc.method, stations, loc.alt, loc.adapt_temp)
-
-        # Clear cache if auto cleaning is enabled
-        if self.max_age > 0 and self.autoclean:
-            self.clear_cache()
-
-    # Import methods
-    from meteostat.series.normalize import normalize
-    from meteostat.series.interpolate import interpolate
-    from meteostat.series.aggregate import aggregate
-    from meteostat.series.convert import convert
-    from meteostat.series.coverage import coverage
-    from meteostat.series.count import count
-    from meteostat.series.fetch import fetch
-    from meteostat.series.stations import stations
-    from meteostat.core.cache import clear_cache

meteostat/series/aggregate.py

@@ -1,48 +0,0 @@
-"""
-Aggregate Data
-
-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
-import pandas as pd
-from meteostat.core.warn import warn
-
-
-def aggregate(self, freq: str = None, spatial: bool = False):
-    """
-    Aggregate observations
-    """
-
-    if self.count() > 0 and not self._data.isnull().values.all():
-        # Create temporal instance
-        temp = copy(self)
-
-        # Set default frequency if not set
-        if freq is None:
-            freq = self._freq
-
-        # Time aggregation
-        temp._data = temp._data.groupby(
-            ["station", pd.Grouper(level="time", freq=freq)]
-        ).agg(temp.aggregations)
-
-        # Spatial aggregation
-        if spatial:
-            temp._data = temp._data.groupby(
-                [pd.Grouper(level="time", freq=freq)]
-            ).mean()
-
-        # Round
-        temp._data = temp._data.round(1)
-
-        # Return class instance
-        return temp
-
-    # Show warning & return self
-    warn("Skipping aggregation on empty DataFrame")
-    return self

meteostat/series/convert.py

@@ -1,28 +0,0 @@
-"""
-Convert Data Units
-
-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
-
-
-def convert(self, units: dict):
-    """
-    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._processed_columns:
-            temp._data[parameter] = temp._data[parameter].apply(unit)
-
-    # Return class instance
-    return temp

meteostat/series/count.py

@@ -1,17 +0,0 @@
-"""
-Get Number Of Rows
-
-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.
-"""
-
-
-def count(self) -> int:
-    """
-    Return number of rows in DataFrame
-    """
-
-    return len(self._data.index)

meteostat/series/coverage.py

@@ -1,20 +0,0 @@
-"""
-Calculate Data Coverage
-
-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.
-"""
-
-
-def coverage(self, parameter: str = None) -> float:
-    """
-    Calculate data coverage (overall or by parameter)
-    """
-
-    if parameter is None:
-        return len(self._data.index) / self.expected_rows()
-
-    return round(self._data[parameter].count() / self.expected_rows(), 2)

meteostat/series/fetch.py

@@ -1,28 +0,0 @@
-"""
-Fetch Data
-
-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
-import pandas as pd
-
-
-def fetch(self) -> pd.DataFrame:
-    """
-    Fetch DataFrame
-    """
-
-    # Copy DataFrame
-    temp = copy(self._data)
-
-    # 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)
-
-    # Return data frame
-    return temp

meteostat/series/interpolate.py

@@ -1,47 +0,0 @@
-"""
-Interpolate Data
-
-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
-import numpy as np
-from meteostat.core.warn import warn
-
-
-def interpolate(self, limit: int = 3):
-    """
-    Interpolate NULL values
-    """
-
-    if self.count() > 0 and not self._data.isnull().values.all():
-        # Create temporal instance
-        temp = copy(self)
-
-        # Convert to float64
-        temp._data = temp._data.astype("float64")
-
-        # Apply interpolation
-        temp._data = temp._data.groupby("station", group_keys=False).apply(
-            lambda group: group.interpolate(
-                method="linear",
-                limit=limit,
-                limit_direction="both",
-                axis=0,
-                fill_value=np.nan,
-            )
-        )
-
-        # Convert to original type
-        temp._data = temp._data.astype("Float64")
-
-        # Return class instance
-        return temp
-
-    # Show warning & return self
-    warn("Skipping interpolation on empty DataFrame")
-    return self

meteostat/series/normalize.py

@@ -1,76 +0,0 @@
-"""
-Normalize Data
-
-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 numpy import nan
-import pandas as pd
-import pytz
-from meteostat.core.warn import warn
-
-
-def normalize(self):
-    """
-    Normalize the DataFrame
-    """
-
-    if self.count() == 0:
-        warn("Pointless normalization of empty DataFrame")
-
-    # Create temporal instance
-    temp = copy(self)
-
-    if temp._start and temp._end and temp.coverage() < 1:
-        # Create result DataFrame
-        result = pd.DataFrame(columns=temp._processed_columns, dtype="Float64")
-
-        # Handle tz-aware date ranges
-        if hasattr(temp, "_timezone") and temp._timezone is not None:
-            timezone = pytz.timezone(temp._timezone)
-            start = temp._start.astimezone(timezone)
-            end = temp._end.astimezone(timezone)
-        else:
-            start = temp._start
-            end = temp._end
-
-        # Go through list of weather stations
-        for station in temp._stations:
-            # Create data frame
-            df = pd.DataFrame(columns=temp._processed_columns, dtype="Float64")
-            # Add time series
-            df["time"] = pd.date_range(
-                start,
-                end,
-                freq=self._freq,
-                tz=temp._timezone if hasattr(temp, "_timezone") else None,
-            )
-            # Add station ID
-            df["station"] = station
-            # Add columns
-            for column in temp._processed_columns:
-                # Add column to DataFrame
-                df[column] = nan
-
-            result = pd.concat([result, df], axis=0)
-
-        # Set index
-        result = result.set_index(["station", "time"])
-
-        # Merge data
-        temp._data = (
-            pd.concat([temp._data, result], axis=0)
-            .groupby(["station", "time"], as_index=True)
-            .first()
-        )
-
-        # None -> nan
-        temp._data = temp._data.fillna(pd.NA)
-
-    # Return class instance
-    return temp

meteostat/series/stations.py

@@ -1,22 +0,0 @@
-"""
-Get Weather Stations
-
-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
-import pandas as pd
-
-
-@property
-def stations(self) -> pd.Index:
-    """
-    Fetch Weather Stations
-    """
-
-    # Return index of weather stations
-    return copy(self._stations)

meteostat/units.py

@@ -1,149 +0,0 @@
-"""
-Meteorological Data Units
-
-Convert a Pandas Series to any meteorological data unit
-
-The code is licensed under the MIT license.
-"""
-
-from numpy import nan, isnan
-
-
-def fahrenheit(value):
-    """
-    Convert Celsius to Fahrenheit
-    """
-
-    return round((value * 9 / 5) + 32, 1)
-
-
-def kelvin(value):
-    """
-    Convert Celsius to Kelvin
-    """
-
-    return round(value + 273.15, 1)
-
-
-def inches(value):
-    """
-    Convert millimeters to inches
-    """
-
-    return round(value / 25.4, 3)
-
-
-def feet(value):
-    """
-    Convert meters to feet
-    """
-
-    return round(value / 0.3048, 1)
-
-
-def ms(value):
-    """
-    Convert kilometers per hour to meters per second
-    """
-
-    return round(value / 3.6, 1)
-
-
-def mph(value):
-    """
-    Convert kilometers per hour to miles per hour
-    """
-
-    return round(value * 0.6214, 1)
-
-
-def direction(value):
-    """
-    Convert degrees to wind direction
-    """
-
-    wdir = nan
-
-    if (337 <= value <= 360) or value <= 23:
-        wdir = "N"
-    if 24 <= value <= 68:
-        wdir = "NE"
-    if 69 <= value <= 113:
-        wdir = "E"
-    if 114 <= value <= 158:
-        wdir = "SE"
-    if 159 <= value <= 203:
-        wdir = "S"
-    if 204 <= value <= 248:
-        wdir = "SW"
-    if 249 <= value <= 293:
-        wdir = "W"
-    if 294 <= value <= 336:
-        wdir = "NW"
-
-    return wdir
-
-
-def condition(value):
-    """
-    Convert Meteostat condition code to descriptive string
-    """
-
-    if isnan(value) or value < 1 or value > 27:
-        return nan
-
-    return [
-        "Clear",
-        "Fair",
-        "Cloudy",
-        "Overcast",
-        "Fog",
-        "Freezing Fog",
-        "Light Rain",
-        "Rain",
-        "Heavy Rain",
-        "Freezing Rain",
-        "Heavy Freezing Rain",
-        "Sleet",
-        "Heavy Sleet",
-        "Light Snowfall",
-        "Snowfall",
-        "Heavy Snowfall",
-        "Rain Shower",
-        "Heavy Rain Shower",
-        "Sleet Shower",
-        "Heavy Sleet Shower",
-        "Snow Shower",
-        "Heavy Snow Shower",
-        "Lightning",
-        "Hail",
-        "Thunderstorm",
-        "Heavy Thunderstorm",
-        "Storm",
-    ][int(value) - 1]
-
-
-# Imperial units
-imperial = {
-    "temp": fahrenheit,
-    "tavg": fahrenheit,
-    "tmin": fahrenheit,
-    "tmax": fahrenheit,
-    "dwpt": fahrenheit,
-    "prcp": inches,
-    "snow": inches,
-    "wspd": mph,
-    "wpgt": mph,
-    "distance": feet,
-}
-
-# Scientific units
-scientific = {
-    "temp": kelvin,
-    "tavg": kelvin,
-    "tmin": kelvin,
-    "tmax": kelvin,
-    "dwpt": kelvin,
-    "wspd": ms,
-    "wpgt": ms,
-}