weatherdb 1.1.0__py3-none-any.whl

weatherdb/stations/StationsBaseTET.py

@@ -0,0 +1,30 @@
+# libraries
+import logging
+
+from ..db.connections import db_engine
+from .StationsBase import StationsBase
+from .StationsP import StationsP
+
+# set settings
+# ############
+__all__ = ["StationsBaseTET"]
+log = logging.getLogger(__name__)
+
+# class definition
+##################
+class StationsBaseTET(StationsBase):
+    @db_engine.deco_update_privilege
+    def fillup(self, only_real=False, stids="all", **kwargs):
+        # create virtual stations if necessary
+        if not only_real:
+            meta = self.get_meta(
+                infos=["Station_id"], only_real=False)
+            meta_p = StationsP().get_meta(
+                infos=["Station_id"], only_real=False)
+            stids_missing = set(meta_p.index.values) - set(meta.index.values)
+            if stids != "all":
+                stids_missing = set(stids).intersection(stids_missing)
+            for stid in stids_missing:
+                self._StationClass(stid) # this creates the virtual station
+
+        super().fillup(only_real=only_real, stids=stids, **kwargs)

weatherdb/stations/StationsET.py

@@ -0,0 +1,17 @@
+# libraries
+import logging
+
+from ..station import StationET
+from .StationsBaseTET import StationsBaseTET
+
+# set settings
+# ############
+__all__ = ["StationsET"]
+log = logging.getLogger(__name__)
+
+# class definition
+##################
+class StationsET(StationsBaseTET):
+    """A class to work with and download potential Evapotranspiration (VPGB) data for several stations."""
+    _StationClass = StationET
+    _timeout_raw_imp = 120

weatherdb/stations/StationsP.py

@@ -0,0 +1,128 @@
+# libraries
+import logging
+
+from ..db.connections import db_engine
+from ..station import StationP
+from .StationsBase import StationsBase
+
+# set settings
+# ############
+__all__ = ["StationsP"]
+log = logging.getLogger(__name__)
+
+# class definition
+##################
+class StationsP(StationsBase):
+    """A class to work with and download 10 minutes precipitation data for several stations."""
+    _StationClass = StationP
+    _timeout_raw_imp = 360
+
+    @db_engine.deco_update_privilege
+    def update_richter_class(self, stids="all", do_mp=True, **kwargs):
+        """Update the Richter exposition class.
+
+        Get the value from the raster, compare with the richter categories and save to the database.
+
+        Parameters
+        ----------
+        stids: string or list of int, optional
+            The Stations for which to compute.
+            Can either be "all", for all possible stations
+            or a list with the Station IDs.
+            The default is "all".
+        **kwargs : dict, optional
+            The keyword arguments to be handed to the station.StationP.update_richter_class and get_stations method.
+
+        Raises
+        ------
+        ValueError
+            If the given stids (Station_IDs) are not all valid.
+        """
+        self._run_method(
+            stations=self.get_stations(only_real=True, stids=stids, **kwargs),
+            method="update_richter_class",
+            name="update richter class for {para}".format(para=self._para.upper()),
+            kwds=kwargs,
+            do_mp=do_mp)
+
+    @db_engine.deco_update_privilege
+    def richter_correct(self, stids="all", **kwargs):
+        """Richter correct the filled data.
+
+        Parameters
+        ----------
+        stids: string or list of int, optional
+            The Stations for which to compute.
+            Can either be "all", for all possible stations
+            or a list with the Station IDs.
+            The default is "all".
+        **kwargs : dict, optional
+            The additional keyword arguments for the _run_method and get_stations method
+
+        Raises
+        ------
+        ValueError
+            If the given stids (Station_IDs) are not all valid.
+        """
+        self._run_method(
+            stations=self.get_stations(only_real=False, stids=stids, **kwargs),
+            method="richter_correct",
+            name="richter correction on {para}".format(para=self._para.upper()),
+            do_mp=False, **kwargs)
+
+    @db_engine.deco_update_privilege
+    def last_imp_corr(self, stids="all", do_mp=False, **kwargs):
+        """Richter correct the filled data for the last imported period.
+
+        Parameters
+        ----------
+        stids: string or list of int, optional
+            The Stations for which to compute.
+            Can either be "all", for all possible stations
+            or a list with the Station IDs.
+            The default is "all".
+        do_mp : bool, optional
+            Should the method be done in multiprocessing mode?
+            If False the methods will be called in threading mode.
+            Multiprocessing needs more memory and a bit more initiating time. Therefor it is only usefull for methods with a lot of computation effort in the python code.
+            If the most computation of a method is done in the postgresql database, then threading is enough to speed the process up.
+            The default is False.
+        **kwargs : dict, optional
+            The additional keyword arguments for the _run_method and get_stations method
+
+        Raises
+        ------
+        ValueError
+            If the given stids (Station_IDs) are not all valid.
+        """
+        stations = self.get_stations(only_real=True, stids=stids, **kwargs)
+        period = stations[0].get_last_imp_period(all=True)
+        log.info("The {para_long} Stations fillup of the last import is started for the period {min_tstp} - {max_tstp}".format(
+            para_long=self._para_long,
+            **period.get_sql_format_dict(format="%Y%m%d %H:%M")))
+        self._run_method(
+            stations=stations,
+            method="last_imp_corr",
+            kwds={"_last_imp_period": period},
+            name="richter correction on {para}".format(para=self._para.upper()),
+            do_mp=do_mp, **kwargs)
+
+    @db_engine.deco_update_privilege
+    def update(self, only_new=True, **kwargs):
+        """Make a complete update of the stations.
+
+        Does the update_raw, quality check, fillup and richter correction of the stations.
+
+        Parameters
+        ----------
+        only_new : bool, optional
+            Should a only new values be computed?
+            If False: The stations are updated for the whole possible period.
+            If True, the stations are only updated for new values.
+            The default is True.
+        """
+        super().update(only_new=only_new, **kwargs)
+        if only_new:
+            self.last_imp_richter_correct(**kwargs)
+        else:
+            self.richter_correct(**kwargs)

weatherdb/stations/StationsPD.py

@@ -0,0 +1,24 @@
+# libraries
+import logging
+
+from ..station import StationPD
+from .StationsP import StationsP
+from .StationsBase import StationsBase
+
+# set settings
+# ############
+__all__ = ["StationsPD"]
+log = logging.getLogger(__name__)
+
+# class definition
+##################
+
+class StationsPD(StationsBase):
+    """A class to work with and download daily precipitation data for several stations.
+
+    Those stations data are only downloaded to do some quality checks on the 10 minutes data.
+    Therefor there is no special quality check and richter correction done on this data.
+    If you want daily precipitation data, better use the 10 minutes station class (StationP) and aggregate to daily values.
+    """
+    _StationClass = StationPD
+    _timeout_raw_imp = 120

weatherdb/stations/StationsT.py

@@ -0,0 +1,21 @@
+# libraries
+import logging
+
+from ..station import StationT
+from .StationsBaseTET import StationsBaseTET
+
+# set settings
+# ############
+__all__ = ["StationsT"]
+log = logging.getLogger(__name__)
+
+# class definition
+##################
+
+class StationsT(StationsBaseTET):
+    """A class to work with and download temperature data for several stations."""
+    _StationClass = StationT
+    _timeout_raw_imp = 120
+
+    def get_quotient(self, **kwargs):
+        raise NotImplementedError("The quotient is not yet implemented for temperature.")

weatherdb/stations/__init__.py

@@ -0,0 +1,11 @@
+"""
+This module has grouping classes for all the stations of one parameter. E.G. StationsP (or StationsP) groups all the Precipitation Stations available.
+Those classes can get used to do actions on all the stations.
+"""
+from .StationsP import StationsP
+from .StationsPD import StationsPD
+from .StationsT import StationsT
+from .StationsET import StationsET
+from .GroupStations import GroupStations
+
+__all__ = ["StationsP", "StationsPD", "StationsT", "StationsET", "GroupStations"]

weatherdb/utils/TimestampPeriod.py

@@ -0,0 +1,369 @@
+import re
+from pandas import Timestamp, NaT, Timedelta
+import datetime
+
+class TimestampPeriod(object):
+    """A class to save a Timespan with a minimal and maximal Timestamp.
+    """
+    _COMPARE = {
+        "inner": {
+            0: max,
+            1: min},
+        "outer": {
+            0: min,
+            1: max}}
+    _REGEX_HAS_TIME = re.compile(
+        r"((^\d{6}[ \-\.]+)"+ # 991231
+        r"|(^\d{8}[ \-\.]*)|" + # 19991231
+        r"(^\d{1,4}[ \-\.]\d{1,2}[ \-\.]\d{1,4}[ \-\.]+))" + # 1999-12-31
+        r"+(\d+)") # has additional numbers -> time
+
+    def __init__(self, start, end, tzinfo="UTC"):
+        """Initiate a TimestampPeriod.
+
+        Parameters
+        ----------
+        start : pd.Timestamp or similar
+            The start of the Period.
+        end : pd.Timestamp or similar
+            The end of the Period.
+        tzinfo : str or datetime.timezone object or None, optional
+            The timezone to set to the timestamps.
+            If the timestamps already have a timezone they will get converted.
+            If None, then the timezone is not changed or set.
+            The default is "UTC".
+        """
+        # check if input is a date or a timestamp
+        if ((isinstance(start, datetime.date) and isinstance(end, datetime.date)) or
+            (isinstance(start, str) and not self._REGEX_HAS_TIME.match(start) and
+             isinstance(end, str) and not self._REGEX_HAS_TIME.match(end))):
+            self.is_date = True
+        else:
+            self.is_date = False
+
+        # convert to correct timestamp format
+        period = list([start, end])
+        for i, tstp in enumerate(period):
+            if not isinstance(tstp, Timestamp):
+                period[i] = Timestamp(tstp)
+
+            # check timezone
+            self.tzinfo = tzinfo
+            if tzinfo is not None:
+                if period[i].tzinfo is None:
+                    period[i] = period[i].tz_localize(tzinfo)
+                else:
+                    period[i] = period[i].tz_convert(tzinfo)
+
+        self.start = period[0]
+        self.end = period[1]
+
+    @staticmethod
+    def _check_period(period):
+        if not isinstance(period, TimestampPeriod):
+            period = TimestampPeriod(*period)
+        return period
+
+    def union(self, other, how="inner"):
+        """Unite 2 TimestampPeriods to one.
+
+        Compares the Periods and computes a new one.
+
+        Parameters
+        ----------
+        other : TimestampPeriod
+            The other TimestampPeriod with whome to compare.
+        how : str, optional
+            How to compare the 2 TimestampPeriods.
+            Can be "inner" or "outer".
+            "inner": the maximal Timespan for both is computed.
+            "outer": The minimal Timespan for both is computed.
+            The default is "inner".
+
+        Returns
+        -------
+        TimestampPeriod
+            A new TimespanPeriod object uniting both TimestampPeriods.
+        """
+        other = self._check_period(other)
+
+        # check for daily period in elements
+        tdsother = [Timedelta(0), Timedelta(0)]
+        tdsself = [Timedelta(0), Timedelta(0)]
+        if self.is_date and not other.is_date and not other.is_empty():
+            tdsself[1] = Timedelta(
+                hours=other.end.hour,
+                minutes=other.end.minute,
+                seconds=other.end.second)
+        elif not self.is_date and other.is_date and not self.is_empty():
+            tdsother[1] = Timedelta(
+                hours=self.end.hour,
+                minutes=self.end.minute,
+                seconds=self.end.second)
+
+        # check if empty and inner
+        if how=="inner" and (self.is_empty() or other.is_empty()):
+            return TimestampPeriod(None, None)
+
+        # get the united period
+        period = [None, None]
+        for i in range(2):
+            comp_list = [val + td
+                for val, td in zip([self[i], other[i]],
+                                   [tdsself[i], tdsother[i]])
+                if isinstance(val, Timestamp)]
+            if len(comp_list) > 0:
+                period[i] = self._COMPARE[how][i](comp_list)
+
+        # check if end < start
+        if period[0]>=period[1]:
+            period = (None, None)
+
+        # return the period
+        if self.is_date and other.is_date and all(period):
+            # if both were data periods, then the result should also be a date period
+            return TimestampPeriod(
+                *[val.date() for val in period
+                             if isinstance(val, Timestamp)])
+        else:
+            return TimestampPeriod(*period)
+
+    def get_period(self):
+        return (self.start, self.end)
+
+    def __getitem__(self, key):
+        if key == 0 or key == "start":
+            return self.start
+        elif key == 1 or key == "end":
+            return self.end
+
+    def __setitem__(self, key, value):
+        if value != Timestamp:
+            value = Timestamp(value)
+
+        if key == 0 or key == "start":
+            self.start = value
+        elif key == 1 or key == "end":
+            self.end = value
+
+    def __iter__(self):
+        return self.get_period().__iter__()
+
+    def __str__(self):
+        msg = "TimestampPeriod: {0} - {1}"
+        if self.is_date:
+            return msg.format(*self.strftime(format="%Y-%m-%d"))
+        else:
+            return msg.format(*self.strftime(format="%Y-%m-%d %H:%M:%S"))
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __eq__(self, other):
+        other = self._check_period(other)
+
+        if self.start == other.start and self.end == other.end:
+            return True
+        else:
+            return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        return self.inside(other)
+
+    def __le__(self, other):
+        return self.inside(other)
+
+    def __gt__(self, other):
+        return self.contains(other)
+
+    def __ge__(self, other):
+        return self.contains(other)
+
+    def has_NaT(self):
+        """Has the TimestampPeriod at least one NaT.
+
+        This means that the start or end is not given.
+        Normally this should never happen, because it makes no sense.
+
+        Returns
+        -------
+        bool
+            True if the TimestampPeriod has at least on NaT.
+            False if the TimestampPeriod has at least a start or a end.
+        """
+        return any([tstp is NaT for tstp in self])
+
+    def has_only_NaT(self):
+        """Has the TimestampPeriod only NaT, meaning is empty.
+
+        This means that the start and end is not given.
+
+        Returns
+        -------
+        bool
+            True if the TimestampPeriod is empty.
+            False if the TimestampPeriod has a start and an end.
+        """
+        return all([tstp is NaT for tstp in self])
+
+    def is_empty(self):
+        """Is the TimestampPeriod empty.
+
+        This means that the start and end is not given.
+
+        Returns
+        -------
+        bool
+            True if the TimestampPeriod is empty.
+            False if the TimestampPeriod has a start and an end.
+        """
+        return self.has_only_NaT()
+
+    def strftime(self, format="%Y-%m-%d %H:%M:%S"):
+        """Convert the TimestampPeriod to a list of strings.
+
+        Formates the Timestamp as a string.
+
+        Parameters
+        ----------
+        format : str, optional
+            The Timestamp-format to use.
+            The Default is "%Y-%m-%d %H:%M:%S"
+
+        Returns
+        -------
+        list of 2 strings
+            A list of the start and end of the TimestampPeriod as formated string.
+        """
+        out = [tstp.strftime(format) if tstp is not NaT else None
+                    for tstp in self.get_period()]
+        return out
+
+    def inside(self, other):
+        """Is the TimestampPeriod inside another TimestampPeriod?
+
+        Parameters
+        ----------
+        other : Timestampperiod or tuple of 2 Timestamp or Timestamp strings
+            The other Timestamp to test against.
+            Test if this TimestampPeriod is inside the other.
+
+        Returns
+        -------
+        bool
+            True if this TimestampPeriod is inside the other.
+            Meaning that the start is higher or equal than the others starts
+            and the end is smaller than the others end.
+        """
+        other = self._check_period(other)
+        if self.start >= other.start and self.end <= other.end:
+            return True
+        else:
+            return False
+
+    def contains(self, other):
+        """Does this TimestampPeriod contain another TimestampPeriod?
+
+        Parameters
+        ----------
+        other : Timestampperiod or tuple of 2 Timestamp or Timestamp strings
+            The other Timestamp to test against.
+            Test if this TimestampPeriod contains the other.
+
+        Returns
+        -------
+        bool
+            True if this TimestampPeriod contains the other.
+            Meaning that the start is smaller or equal than the others starts
+            and the end is higher than the others end.
+        """
+        other = self._check_period(other)
+        return other.inside(self)
+
+    def get_sql_format_dict(self, format="'%Y%m%d %H:%M'"):
+        """Get the dictionary to use in sql queries.
+
+        Parameters
+        ----------
+        format : str, optional
+            The Timestamp-format to use.
+            The Default is "'%Y%m%d %H:%M'"
+
+        Returns
+        -------
+        dict
+            a dictionary with 2 keys (min_tstp, max_tstp) and the corresponding Timestamp as formated string.
+        """
+        period_str = self.strftime(format=format)
+        period_str = [str(el).replace("None", "NULL") for el in period_str]
+        return dict(min_tstp=period_str[0], max_tstp=period_str[1])
+
+    def get_interval(self):
+        """Get the interval of the TimestampPeriod.
+
+        Returns
+        -------
+        pd.Timedelta
+            The interval of this TimestampPeriod.
+            E.G. Timedelta(2 days 12:30:12)
+        """
+        return self.end - self.start
+
+    def get_middle(self):
+        """Get the middle Timestamp of the TimestampPeriod.
+
+        Returns
+        -------
+        Timestamp
+            The middle Timestamp of this TimestampPeriod.
+        """
+        middle = self.start + self.get_interval() / 2
+        if self.is_date:
+            middle = Timestamp(middle.date())
+        if self.tzinfo is not None:
+            if middle.tzinfo is None:
+                middle = middle.tz_localize(self.tzinfo)
+        return middle
+
+    def copy(self):
+        """Copy this TimestampPeriod.
+
+        Returns
+        -------
+        TimestampPeriod
+            a new TimestampPeriod object that is equal to this one.
+        """
+        new = TimestampPeriod(self.start, self.end)
+        new.is_date = self.is_date
+        return new
+
+    def expand_to_timestamp(self):
+        if self.is_date:
+            return TimestampPeriod(
+                start=self.start,
+                end=self.end + Timedelta(
+                    hours=23, minutes=59, seconds=59, milliseconds=999))
+        else:
+            return self
+
+    def set_tz(self, tzinfo):
+        """Set the TimestampPeriod to a new timezone.
+
+        Parameters
+        ----------
+        tzinfo : str or datetime.timezone object
+            The timezone to set the TimestampPeriod to.
+
+        Returns
+        -------
+        TimestampPeriod
+            This TimestampPeriod.
+        """
+        if not self.is_date:
+            self.start.replace(tzinfo=tzinfo)
+            self.end.replace(tzinfo=tzinfo)
+        return self
+

weatherdb/utils/__init__.py

@@ -0,0 +1,3 @@
+from .TimestampPeriod import TimestampPeriod
+from . import dwd
+from . import geometry