meteostat 1.7.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

meteostat/interface/hourly.py

@@ -1,154 +0,0 @@
-"""
-Hourly 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 math import floor
-from datetime import datetime, timedelta
-from typing import Optional, Union
-import pytz
-import pandas as pd
-from meteostat.enumerations.granularity import Granularity
-from meteostat.utilities.aggregations import degree_mean
-from meteostat.interface.timeseries import TimeSeries
-from meteostat.interface.point import Point
-from meteostat.utilities.mutations import calculate_dwpt
-
-
-class Hourly(TimeSeries):
-    """
-    Retrieve hourly weather observations for one or multiple weather stations or
-    a single geographical point
-    """
-
-    # The cache subdirectory
-    cache_subdir = "hourly"
-
-    # Granularity
-    granularity = Granularity.HOURLY
-
-    # Download data as annual chunks
-    # This cannot be changed and is only kept for backward compatibility
-    chunked = True
-
-    # The time zone
-    _timezone: Optional[str] = None
-
-    # Default frequency
-    _freq = "1h"
-
-    # Source mappings
-    _source_mappings = {
-        "metar": "D",
-        "model": "E",
-        "isd_lite": "B",
-        "synop": "C",
-        "dwd_poi": "C",
-        "dwd_hourly": "A",
-        "dwd_mosmix": "E",
-        "metno_forecast": "E",
-        "eccc_hourly": "A",
-    }
-
-    # Flag which represents model data
-    _model_flag = "E"
-
-    # Raw data columns
-    _columns = [
-        "year",
-        "month",
-        "day",
-        "hour",
-        "temp",
-        {"dwpt": calculate_dwpt},
-        "rhum",
-        "prcp",
-        {"snow": "snwd"},
-        "wdir",
-        "wspd",
-        "wpgt",
-        "pres",
-        "tsun",
-        "coco",
-    ]
-
-    # Index of first meteorological column
-    _first_met_col = 4
-
-    # Columns for date parsing
-    _parse_dates = ["year", "month", "day", "hour"]
-
-    # Default aggregation functions
-    aggregations = {
-        "temp": "mean",
-        "dwpt": "mean",
-        "rhum": "mean",
-        "prcp": "sum",
-        "snow": "max",
-        "wdir": degree_mean,
-        "wspd": "mean",
-        "wpgt": "max",
-        "pres": "mean",
-        "tsun": "sum",
-        "coco": "max",
-    }
-
-    def _set_time(
-        self,
-        start: Optional[datetime] = None,
-        end: Optional[datetime] = None,
-        timezone: Optional[str] = None,
-    ) -> None:
-        """
-        Set & adapt the period's time zone
-        """
-        if timezone:
-            # Save timezone
-            self._timezone = timezone
-
-            if start and end:
-                # Initialize time zone
-                timezone = pytz.timezone(self._timezone)
-
-                # Set start date
-                start = timezone.localize(start, is_dst=None).astimezone(pytz.utc)
-
-                # Set end date
-                end = timezone.localize(end, is_dst=None).astimezone(pytz.utc)
-
-        if self.chunked:
-            self._annual_steps = [
-                start.year + i for i in range(end.year - start.year + 1)
-            ]
-
-        self._start = start
-        self._end = end
-
-    def __init__(
-        self,
-        loc: Union[pd.DataFrame, Point, list, str],  # Station(s) or geo point
-        start=datetime(1890, 1, 1, 0, 0, 0),
-        end=datetime.combine(
-            datetime.today().date() + timedelta(days=10), datetime.max.time()
-        ),
-        timezone: Optional[str] = None,
-        model=True,  # Include model data?
-        flags=False,  # Load source flags?
-    ) -> None:
-        # Set time zone and adapt period
-        self._set_time(start, end, timezone)
-
-        # Initialize time series
-        self._init_time_series(loc, start, end, model, flags)
-
-    def expected_rows(self) -> int:
-        """
-        Return the number of rows expected for the defined date range
-        """
-
-        return floor((self._end - self._start).total_seconds() / 3600) + 1

meteostat/interface/meteodata.py

@@ -1,210 +0,0 @@
-"""
-Meteorological Data Class
-
-A parent class for both time series and
-climate normals 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 collections.abc import Callable
-from typing import Dict, List, Union
-import pandas as pd
-from meteostat.enumerations.granularity import Granularity
-from meteostat.core.loader import processing_handler
-from meteostat.utilities.mutations import adjust_temp
-from meteostat.utilities.aggregations import weighted_average
-from meteostat.interface.base import Base
-
-
-class MeteoData(Base):
-    """
-    A parent class for both time series and
-    climate normals data
-    """
-
-    # The list of weather Stations
-    _stations: Union[pd.Index, None] = None
-
-    # The data frame
-    _data: pd.DataFrame = pd.DataFrame()
-
-    @property
-    def _raw_columns(self) -> List[str]:
-        """
-        Get the list of raw data columns, excluding any dicts with callable values
-        """
-        return [
-            list(col.values())[0] if isinstance(col, dict) else col
-            for col in self._columns
-            if not (
-                isinstance(col, dict)
-                and (
-                    isinstance(list(col.values())[0], Callable)
-                    or list(col.values())[0] is None
-                )
-            )
-        ]
-
-    @property
-    def _processed_columns(self) -> List[str]:
-        """
-        Get the list of processed data columns, excluding any dicts with callable values
-        """
-        return [
-            list(col.keys())[0] if isinstance(col, dict) else col
-            for col in self._columns[self._first_met_col :]
-        ]
-
-    @property
-    def _renamed_columns(self) -> Dict[str, str]:
-        """
-        Get the dict of renamed data columns, including `_source` suffixes
-        """
-        return {
-            new_key: new_val
-            for d in self._columns
-            if isinstance(d, dict)
-            for k, v in d.items()
-            if not isinstance(v, Callable)
-            for new_key, new_val in ((v, k), (f"{v}_source", f"{k}_source"))
-        }
-
-    @property
-    def _virtual_columns(self) -> Dict[str, str]:
-        """
-        Get the dict of virtual data columns
-        """
-        return {
-            k: v
-            for d in self._columns
-            if isinstance(d, dict)
-            for k, v in d.items()
-            if isinstance(v, Callable)
-        }
-
-    def _get_datasets(self) -> list:
-        """
-        Get list of datasets
-        """
-
-        if self.granularity in (Granularity.HOURLY, Granularity.DAILY):
-            datasets = [
-                (str(station), year)
-                for station in self._stations
-                for year in self._annual_steps
-            ]
-        else:
-            datasets = [(str(station),) for station in self._stations]
-
-        return datasets
-
-    def _get_data(self) -> None:
-        """
-        Get all required data dumps
-        """
-
-        if len(self._stations) > 0:
-            # Get list of datasets
-            datasets = self._get_datasets()
-
-            # Data Processings
-            return processing_handler(
-                datasets, self._load_data, self.processes, self.threads
-            )
-
-        # Empty DataFrame
-        return pd.DataFrame(columns=self._processed_columns)
-
-    # pylint: disable=too-many-branches
-    def _resolve_point(
-        self, method: str, stations: pd.DataFrame, alt: int, adapt_temp: bool
-    ) -> None:
-        """
-        Project weather station data onto a single point
-        """
-
-        if self._stations.size == 0 or self._data.size == 0:
-            return
-
-        if method == "nearest":
-            if adapt_temp:
-                # Join elevation of involved weather stations
-                data = self._data.join(stations["elevation"], on="station")
-
-                # Adapt temperature-like data based on altitude
-                data = adjust_temp(data, alt)
-
-                # Drop elevation & round
-                data = data.drop("elevation", axis=1).round(1)
-
-            else:
-                data = self._data
-
-            if self.granularity == Granularity.NORMALS:
-                self._data = data.groupby(level=["start", "end", "month"]).agg("first")
-
-            else:
-                self._data = data.groupby(
-                    pd.Grouper(level="time", freq=self._freq)
-                ).agg("first")
-
-        else:
-            # Join score and elevation of involved weather stations
-            data = self._data.join(stations[["score", "elevation"]], on="station")
-
-            # Adapt temperature-like data based on altitude
-            if adapt_temp:
-                data = adjust_temp(data, alt)
-
-            # Exclude non-mean data & perform aggregation
-            if not self.granularity == Granularity.NORMALS:
-                excluded = data["wdir"]
-                excluded = excluded.groupby(
-                    pd.Grouper(level="time", freq=self._freq)
-                ).agg("first")
-
-            # Aggregate mean data
-            if self.granularity == Granularity.NORMALS:
-                data = data.groupby(level=["start", "end", "month"]).apply(
-                    weighted_average
-                )
-
-                # Remove obsolete index column
-                try:
-                    data = data.reset_index(level=3, drop=True)
-                except IndexError:
-                    pass
-
-            else:
-                data = data.groupby(pd.Grouper(level="time", freq=self._freq)).apply(
-                    weighted_average
-                )
-
-                # Drop RangeIndex
-                data.index = data.index.droplevel(1)
-
-                # Merge excluded fields
-                data["wdir"] = excluded
-
-            # Drop score and elevation
-            self._data = data.drop(["score", "elevation"], axis=1).round(1)
-
-        # Set placeholder station ID
-        self._data["station"] = "XXXXX"
-
-        # Set index
-        if self.granularity == Granularity.NORMALS:
-            self._data = self._data.set_index("station", append=True)
-            self._data = self._data.reorder_levels(["station", "start", "end", "month"])
-        else:
-            self._data = self._data.set_index(
-                ["station", self._data.index.get_level_values("time")]
-            )
-
-        # Set station index
-        self._stations = pd.Index(["XXXXX"])

meteostat/interface/monthly.py

@@ -1,109 +0,0 @@
-"""
-Monthly 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 Union
-import pandas as pd
-from meteostat.enumerations.granularity import Granularity
-from meteostat.interface.timeseries import TimeSeries
-from meteostat.interface.point import Point
-
-
-class Monthly(TimeSeries):
-    """
-    Retrieve monthly weather data for one or multiple weather stations or
-    a single geographical point
-    """
-
-    # The cache subdirectory
-    cache_subdir = "monthly"
-
-    # Granularity
-    granularity = Granularity.MONTHLY
-
-    # Default frequency
-    _freq = "1MS"
-
-    # Source mappings
-    _source_mappings = {
-        "dwd_monthly": "A",
-        "eccc_monthly": "A",
-        "dwd_daily": "C",
-        "eccc_daily": "C",
-        "ghcnd": "D",
-        "dwd_hourly": "E",
-        "eccc_hourly": "E",
-        "isd_lite": "F",
-        "synop": "G",
-        "dwd_poi": "G",
-        "metar": "H",
-        "model": "I",
-        "dwd_mosmix": "I",
-        "metno_forecast": "I",
-    }
-
-    # Flag which represents model data
-    _model_flag = "I"
-
-    # Columns
-    _columns = [
-        "year",
-        "month",
-        {"tavg": "temp"},
-        "tmin",
-        "tmax",
-        "prcp",
-        "wspd",
-        "pres",
-        "tsun",
-    ]
-
-    # Index of first meteorological column
-    _first_met_col = 2
-
-    # Columns for date parsing
-    _parse_dates = ["year", "month"]
-
-    # Default aggregation functions
-    aggregations = {
-        "tavg": "mean",
-        "tmin": "mean",
-        "tmax": "mean",
-        "prcp": "sum",
-        "wspd": "mean",
-        "pres": "mean",
-        "tsun": "sum",
-    }
-
-    def __init__(
-        self,
-        loc: Union[pd.DataFrame, Point, list, str],  # Station(s) or geo point
-        start: datetime = None,
-        end: datetime = None,
-        model: bool = True,  # Include model data?
-        flags: bool = False,  # Load source flags?
-    ) -> None:
-        # Set start date
-        if start is not None:
-            start = start.replace(day=1)
-
-        # Initialize time series
-        self._init_time_series(loc, start, end, model, flags)
-
-    def expected_rows(self) -> int:
-        """
-        Return the number of rows expected for the defined date range
-        """
-
-        return (
-            (self._end.year - self._start.year) * 12
-            + self._end.month
-            - self._start.month
-        ) + 1